commit 9aa2da72b5fd97ae714bd2e2c003df6cbbbafc27 Author: Tom Kasper Date: Sun Aug 30 20:44:00 2026 +0200 Initial version diff --git a/planning/mcp-server-plan.md b/planning/mcp-server-plan.md new file mode 100644 index 0000000..8956a67 --- /dev/null +++ b/planning/mcp-server-plan.md @@ -0,0 +1,441 @@ +# LabVoice MCP Server — Implementation Plan + +Status: **draft for review** (nothing below is built yet; `src/` is empty and +`vendor/elabapi-python` holds the vendored official `elabapi_python` client) + +## 1. Goal + +An MCP server exposing the eLabFTW REST API v2 as a small set of **aggregate tools** +designed for small/low-power models and voice-driven wetlab use. + +Design decisions already made: + +1. **Consumables live in the protocol template** — machine-readable JSON at the end of + the step text, hidden from the client UI in an HTML comment. +2. **Direct execution** — no preview/confirmation round. The point is hands-free + voice operation. +3. **Portable** — templates reference stable *semantic resource keys*, never eLabFTW + numeric IDs. The server installs on top of any existing eLabFTW instance with only + template edits (plus optional resource markers). +4. **Reads are dual-purpose** — the same read tools are exposed both as MCP tools and + over a plain read-only REST API. REST lets the mobile app render state without + spending model tokens; MCP lets the LLM fetch detail on demand. The edge LLM + receives only a **minimal handoff context** from the app (experiment id, user id, + current step id, device id, location id — on-device compute means a tight token + budget), so it pulls anything beyond the ids via the read tools. +5. **Templates are first-class** — new experiments are created from a template, chosen + interactively via a template-listing/search tool (short descriptions, semantic + ranking). + +## 2. Architecture + +```text + mobile app ──REST: reads for the UI (no LLM)──┐ + │ │ + │ voice + minimal handoff │ + │ context (ids only) │ + ▼ │ + small LLM ──MCP: reads on demand, aggregates──┤ + (stdio / streamable HTTP) │ + ▼ + ┌──────────────────────────────┐ + │ mcp_server │ + │ ├── tools.py │ small tool surface, compact results + │ ├── rest.py │ read-only REST mirror of the reads + │ ├── templates.py │ template search index + creation + │ ├── workflows/ │ aggregate operations (the point) + │ │ ├── protocol.py │ step completion saga + │ │ └── inventory.py │ allocation, unit handling + │ ├── resolve.py │ resource_key → item id mapping + │ ├── annotate.py │ annotation parse/validate + │ ├── elabftw.py │ async adapter over vendored elabapi_python + │ └── journal.py │ SQLite operation journal (sagas) + └──────────────────────────────┘ + │ HTTPS, Authorization: + ▼ + eLabFTW REST API v2 + (client: vendor/elabapi-python) +``` + +Layers, top to bottom: **MCP tools / REST routes → workflow services → +elabapi_python adapter → eLabFTW**. The read tools are single implementations behind +two transports: `tools.py` (MCP, for the LLM) and `rest.py` (REST, for the app UI). +No generic `PATCH/POST/DELETE` passthrough tools — aggregate tools only, so a small +model cannot pick an unsafe raw mutation. + +## 3. Module layout (`src/mcp_server/`) + +```text +src/mcp_server/ + __init__.py + __main__.py # entry point: stdio (default) or streamable-http + config.py # env-driven settings (pydantic-settings) + models.py # tool input/output schemas, compact result types + errors.py # typed errors → voice-friendly messages + elabftw.py # async adapter over the vendored elabapi_python client: + # Configuration/ApiClient setup, error normalization, + # sync calls wrapped with asyncio.to_thread + schemas.py # pydantic models for the eLabFTW entities we use + annotate.py # labvoice:v1 annotation parser + validator + resolve.py # resource key resolution (mapping store + markers) + allocate.py # container selection, unit whitelist/conversion + templates.py # experiment templates: description extraction, semantic + # ranking (embedding cache in SQLite), creation flow + journal.py # SQLite saga journal (idempotency + compensation) + workflows/ + __init__.py + protocol.py # complete_next/complete/observation workflows + inventory.py # adjust_inventory, stock reads + setup.py # scan_instance, map_resource, validate_templates + tools.py # MCP tool registration (one function per tool) + rest.py # FastAPI: read-only REST mirror of the read tools + # (state rendering for the app UI; bearer-token protected) + server.py # FastMCP assembly, lifespan; mounts rest.py in http mode +vendor/elabapi-python/ # official generated client (package elabapi_python, + # sync urllib3) — vendored, not edited; imported as-is +``` + +Dependencies to add: `mcp` (official Python SDK), `pydantic-settings`, +`aiosqlite` (journal), `fastapi` + `uvicorn` (REST fast path), `fastembed` +(optional — semantic template ranking, unset ⇒ lexical fallback). The REST client +itself comes from the vendored `elabapi_python` package +(`elabapi_python.Configuration` with `host = ELABFTW_URL + /api/v2`, api-key auth +header); because it is synchronous, the adapter runs calls via `asyncio.to_thread`. +Python 3.12 (already pinned). + +## 4. Protocol annotation format (portable) + +Appended at the end of a template step body: + +```html + +``` + +Field rules: + +| field | required | notes | +|-----------------|----------|----------------------------------------------------| +| `resource_key` | yes | slug; stable across instances — never an item id | +| `quantity` | yes | positive number consumed per execution | +| `unit` | yes | must be in the unit whitelist | +| `allocation` | no | `fifo` (default), `nearest_expiry`, `specific` | +| `container_id` | no | only with `allocation: "specific"`; local hint, ignored if it does not match the resolved resource | +| `optional` | no | `true` → skip (with a warning) if stock is missing | + +Parser rules (`annotate.py`): + +- Recognize only ``; take the **last** valid block. +- Malformed JSON or schema violations ⇒ `annotation_error`, surfaced by + `validate_protocol_template` and blocking step completion (never silently ignored). +- `quantity` may also be `null` with `"prompt_quantity": true` for steps where the + used amount varies — completion then **requires** the caller to supply quantities + (voice: “how much did you use?”), otherwise it fails with a clarification request. +- Visible step text is never modified by the server. + +Unit whitelist (extensible in config): `μL, mL, L, mg, g, kg, μg`, `ea` (each). +Conversions only within the same dimension and only tested pairs (e.g. `mL↔L`, +`mg↔g↔kg↔μg`); anything else ⇒ clarification, never a guess. + +## 5. Resource resolution (`resolve.py`) + +`resource_key` → eLabFTW `items` id, resolved in this order: + +1. **Local mapping store** (SQLite table): `resource_key → item_id`, written during + setup. Authoritative at execution time. +2. **Resource marker** — hidden comment in the resource body: + ``, auto-discovered by scanning. +3. **Configured matchers** at setup time only (CAS extra field, `custom_id`). +4. **Exact title match** — setup-time suggestion only, requires admin approval; + never applied silently during execution. + +Ambiguous or missing mapping ⇒ execution stops with a voice-friendly clarification +listing candidate resources. No fuzzy matching at runtime, ever. + +### Installation on an existing instance (setup workflow) + +- `scan_instance` — walk `GET /items` (paginated), inventory containers, detect + markers, propose matches from title/CAS/custom_id. +- `map_resource` — bind `resource_key → item_id` (idempotent, upsert). +- `export_mapping` / `import_mapping` — JSON mapping file for porting between + instances; import proposes but still requires approval of ambiguous matches. + +Mapping file example: + +```json +{ + "ethanol_absolute": {"cas": "64-17-5", "title": "Absolute Ethanol", "unit": "mL"} +} +``` + +## 6. MCP tool surface + +Ten tools total. The read tools are dual-purpose: the mobile app calls them via the +REST mirror (§8) to render state with zero model tokens, while the edge LLM — which +receives only a minimal handoff context of ids from the app — calls the same reads +over MCP when it needs detail (e.g. `get_next_protocol_step` for the full step body +and stock preview). + +Reads (safe, any API key): + +| tool | purpose | +|-------------------------|--------------------------------------------------------| +| `find_experiments` | search by title/text/tag/custom id, compact results | +| `get_experiment_context`| metadata + unfinished steps + linked resources + recent comments, all compact | +| `get_next_protocol_step`| next unfinished step: text, parsed consumables, stock preview | +| `list_experiment_templates` | list/search templates: id, title, short description, tags (semantic ranking, §9) | +| `validate_protocol_template` | check annotations + mappings of a template/experiment | + +Aggregates (mutating): + +| tool | purpose | +|-----------------------------|-------------------------------------------------------------------------| +| `complete_next_protocol_step` | the headline tool — see §7 | +| `complete_protocol_step` | same, with explicit step id (for “redo step 3” voice commands) | +| `record_protocol_observation` | add a comment (+ optional step body edit) without completing anything | +| `create_experiment_from_template` | start a new experiment from a template (interactive flow, §9) | +| `adjust_inventory` | restock / correct a container, voice: “add 500 mL to …” | + +Setup (admin, mutating only the local mapping store): + +| tool | purpose | +|---------------|---------------------------------------------| +| `scan_instance`, `map_resource`, `export_mapping`, `import_mapping` | §5 onboarding | + +Result shapes are deliberately small: every tool returns compact JSON (ids, titles, +quantities, statuses) — never a raw eLabFTW entity dump. Tool descriptions are one or +two short sentences (small-model friendly). Mutating tools return exactly what +changed, for text-to-speech readback: + +```json +{ + "ok": true, + "experiment_id": 123, + "step": {"id": 9, "body": "Add ethanol", "finished": true}, + "consumed": [{"resource_key": "ethanol_absolute", "container_id": 12, + "amount": "2.0 mL", "remaining": "48.0 mL"}], + "comment_id": 77, + "next_step": {"id": 10, "body": "Incubate 30 min"} +} +``` + +## 7. `complete_next_protocol_step` workflow (direct execution) + +Input: `{experiment_id, comment?, quantities?}` — nothing else. + +1. `GET /experiments/{id}` + steps; select lowest-`ordering` unfinished step. + None left ⇒ explicit `protocol_complete` result. +2. Parse annotation (§4). No annotation ⇒ complete step + comment, skip inventory. +3. Resolve every `resource_key` (§5). Unresolvable ⇒ clarification result, no mutation. +4. `GET /{entity_type}/{id}/containers` per resource; filter by unit compatibility; + apply allocation policy (`fifo` = lowest container id with stock, + `nearest_expiry` needs an expiry extra field, configured). +5. Validate stock: total available ≥ required (unit-converted). Insufficient ⇒ + clarification listing what is short; `optional` consumables are skipped with a warning. +6. Execute as a journaled saga (§10), in this order: + 1. decrement each container (`PATCH .../containers/{subid}` `qty_stored`), + 2. finish the step (`PATCH .../steps/{subid}` `{"action":"finish"}`), + 3. post the comment (`POST .../comments`). +7. Re-read the step to verify; return compact confirmation + next step. + +The model makes **one tool call**; all sequencing is server-side. + +## 8. Read-only REST API (app fast path) + +The read tools are single implementations behind two transports: `rest.py` exposes +them as REST endpoints so the mobile app renders state without spending LLM tokens, +while `tools.py` keeps them available over MCP for the LLM and standalone clients. +Mutations are **not** exposed over REST — they exist only as MCP tools, so every +mutation is journaled (§10). + +- Auth: static bearer token (`LABVOICE_REST_TOKEN`) — the app is a trusted client; + per-device tokens are an open question (§15). +- Same compact result shapes and typed errors as the MCP tools + (`{"error": "clarification", "message": ...}`). + +| endpoint | purpose | +|---------------------------------------|---------------------------------------------------------------| +| `GET /api/experiments?q=&limit=` | `find_experiments` | +| `GET /api/experiments/{id}/state` | full app state: title, unfinished steps, linked resources, next step + parsed consumables + stock preview | +| `GET /api/experiments/{id}/next-step` | just the next step (the hot path for voice) | +| `GET /api/templates?q=&limit=` | `list_experiment_templates` (§9) | + +The `state` response is what the app renders (title, steps, stock, etc.). What the +app forwards to the LLM is deliberately **minimal** — a handoff context of ids only, +since LLM compute is on-device at the edge and the token budget is tight: + +```json +{"experiment_id": 123, "user_id": 2, "step_id": 9, + "device_id": "bench-7", "location_id": "lab-2"} +``` + +When the model needs more than the ids — full step body, parsed consumables, stock, +comments — it calls the corresponding MCP read tool (same services that back the +endpoints above). REST serves the UI; MCP serves the model; one implementation of +each read. + +## 9. Experiment templates: semantic search & creation + +Voice flow ("start a new experiment for the PCR cleanup"): + +1. `list_experiment_templates(query?, limit?)` — templates as + `{id, title, short_description, tags}`, ranked by semantic similarity when a + query is given (best match first). +2. The LLM reads the short descriptions back; the user picks one interactively. +3. `create_experiment_from_template(template_id, title?)` — `POST /experiments` + with the template id; returns `{experiment_id, title, first_step}`. eLabFTW + copies the template steps, so `labvoice:v1` annotations come along and the + step-completion workflow (§7) applies immediately. + +Short description: first paragraph of the template description, truncated +(`LABVOICE_TEMPLATE_DESC_LIMIT`, default 200 chars). It doubles as readback text +for the LLM and as part of the search corpus. + +Semantic ranking (`templates.py`): + +- Corpus per template: title + tags + full description. +- Preferred backend: local tiny embedding model (`fastembed`, ONNX, CPU, ~30 MB, + `LABVOICE_EMBED_MODEL`); template vectors computed at scan time (or lazily on + first use) and cached in the SQLite database as `template_id → vector`, + refreshed when templates change. +- Fallback (no model configured): lexical scoring — weighted token overlap, + title > tags > description. Same interface, just dumber ranking. +- Only templates visible to the current API key are ever returned; no fuzzy + matching on ids. + +Creation notes: + +- A single `POST /experiments` — no multi-step saga; still journaled for audit + (§10). +- `title` optional — eLabFTW applies the template's default title format when + omitted. +- A created-but-unwanted experiment is archived via eLabFTW itself; this server + never deletes. + +## 10. Saga journal & failure handling (`journal.py`) + +eLabFTW has no cross-entity transactions, so every mutating workflow runs as a +journaled saga in SQLite (`LABVOICE_DB_PATH`, default `~/.labvoice/journal.sqlite`): + +- Each execution gets an `operation_id`; journal rows record planned actions, their + status, and eLabFTW responses. +- Sub-actions are idempotent (re-read before write; finishing an already-finished + step is a no-op; decrement uses read-modify-write with a re-read check). +- On failure of step 6.2 or 6.3: **compensate** — restore decremented quantities + (PATCH back), then: + - success ⇒ return `reverted` result explaining what happened; + - compensation fails ⇒ mark `partial_failure` in the journal **and** post an audit + comment on the experiment describing exactly what is inconsistent; result tells + the user which container to check. +- Journal is also the audit log (who/when/what) and powers a future reconciliation tool. + +## 11. Configuration & deployment + +Env vars (all via `config.py`): + +```text +ELABFTW_URL # https://eln.example.org (adapter sets host to this + /api/v2) +ELABFTW_API_KEY # read-only works for read tools; writes need can_write +ELABFTW_TIMEOUT=10 # per-request timeout seconds +ELABFTW_RETRIES=2 +LABVOICE_DB_PATH=~/.labvoice/journal.sqlite +LABVOICE_REST_TOKEN=... # bearer token for the read-only REST API (§8) +LABVOICE_TEMPLATE_DESC_LIMIT=200 +LABVOICE_EMBED_MODEL=... # optional; unset ⇒ lexical template ranking +LABVOICE_UNIT_WHITELIST=... # optional override +LABVOICE_EXPIRY_FIELD=... # extra-field name for nearest_expiry allocation +``` + +- Transports: **stdio** (default; local/phone use) and **streamable-http** + (`--transport http`, for a shared Raspberry-Pi-class deployment). In http mode a + single uvicorn process serves both the MCP app and the read-only REST API + (`rest.py`) — one deployment for app + LLM. `stateless_http` mode; no session + affinity needed. +- Health check = `GET /info` through the client (auth + reachability in one call). +- Packaging: uv project, console script `labvoice`; single Dockerfile (optional). + +## 12. eLabFTW endpoints used + +```text +GET /info +GET /experiments (search: q, tags, limit/offset) +GET /experiments/{id} +POST /experiments {"template": , "title"?} (§9 creation) +GET /{entity_type}/{id}/steps +PATCH /{entity_type}/{id}/steps/{subid} {"action": "finish"} +GET /{entity_type}/{id}/comments +POST /{entity_type}/{id}/comments +GET /items (scan/search) +GET /items/{id} +GET /{entity_type}/{id}/containers +PATCH /{entity_type}/{id}/containers/{subid} {"qty_stored": ...} +GET /storage_units?hierarchy=true (location names for readback) +GET /experiments_templates (list/search templates, §9) +GET /experiments_templates/{id} +``` + +`entity_type` ∈ {`experiments`, `items`} only — templates are read, never mutated, by +this server (template editing happens in eLabFTW itself). The adapter (`elabftw.py`) +normalizes all client errors into typed errors (`auth_error`, `permission_error`, +`not_found`, `api_error`) with voice-friendly messages; never leaks the API key into +results or logs. + +## 13. Testing & verification + +- **Unit** (pytest, mocked `elabapi_python` API instances): annotation parser (valid/malformed/ + last-block/prompt_quantity), resolver precedence + ambiguity, allocator (fifo, + splitting across containers, unit conversion, insufficient stock), journal + (idempotency, compensation, partial_failure), error normalization, template + ranking (golden queries for semantic + lexical fallback, description truncation), + creation from template (steps + annotations copied). +- **REST API**: FastAPI TestClient — bearer auth enforced, `state`/`next-step` + responses (snapshot tests). +- **MCP-level**: tool schema lint (small input schemas), `tools/list` snapshot test, + golden results for the headline workflow. +- **Integration** (optional, manual): disposable eLabFTW docker instance; script + creates experiment + template with annotations, maps resources, runs the saga, + asserts final state via the API. +- **Safety checks as tests**: read-only key must fail cleanly on every mutating tool; + immutable step → explicit error; double execution of same operation_id is idempotent. + +## 14. Build order (PR-sized milestones) + +1. `config.py`, `errors.py`, `models.py`, elabftw adapter over `elabapi_python` + schemas (read paths only) +2. `annotate.py` parser + `validate_protocol_template` tool +3. `resolve.py` mapping store + `scan_instance` / `map_resource` tools +4. read tools: `find_experiments`, `get_experiment_context`, `get_next_protocol_step` +5. `rest.py`: read-only REST mirror over the same services (bearer auth) +6. `journal.py` saga engine +7. `workflows/protocol.py`: `complete_protocol_step` → `complete_next_protocol_step` + → `record_protocol_observation` +8. `templates.py`: `list_experiment_templates` (search index) + + `create_experiment_from_template` +9. `adjust_inventory` +10. MCP server assembly (stdio + http, REST mount), entry point, README, Dockerfile +11. integration script + docs (annotation authoring guide for template editors) + +Milestones 1–5 are read-only and independently testable; the first mutating code +lands in milestone 7 on top of the journal (6). + +## 15. Open questions (need your input before/at build time) + +1. **Step selection** — strictly lowest `ordering` among unfinished steps, or should + `complete_protocol_step` also accept a step *number* spoken by the user (“done + with step three”)? (Plan assumes yes: accept id or 1-based position.) +2. **`nearest_expiry`** — is an expiry extra field available in your resources, or is + `fifo` + `specific` enough for v1? (Plan: ship `fifo`/`specific` first.) +3. **Journal location on phone/mobile** — default `~/.labvoice/journal.sqlite` okay, + or should the SQLite file live next to the config for easy backup? +4. **MCP SDK line** — plan targets the current stable `mcp` SDK (v2 line). Pin major + version at build time. +5. **Template search backend** — ship lexical ranking first and add `fastembed` + embeddings only if ranking disappoints, or embed from day one? (Plan: lexical + first, same interface for both.) +6. **REST auth** — one shared bearer token per deployment enough, or per-device + tokens for app installs? diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..174545b --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,41 @@ +[project] +name = "labvoice" +version = "0.0.1" +description = "Voice-driven eLabFTW assistant: MCP server + read-only REST fast path" +requires-python = ">=3.12" +dependencies = [ + "mcp>=1.0", + "pydantic>=2.7", + "pydantic-settings>=2.2", + "aiosqlite>=0.20", + "fastapi>=0.111", + "uvicorn>=0.30", +] + +[project.optional-dependencies] +embeddings = ["fastembed>=0.3"] + +[dependency-groups] +dev = [ + "pytest>=8.0", + "pytest-asyncio>=0.24", + # deps of the vendored elabapi_python client, imported (not installed) by tests + "six>=1.16", + "urllib3>=2.0", + "certifi>=2024.0", +] + +[project.scripts] +labvoice = "mcp_server.__main__:main" + +[build-system] +requires = ["hatchling"] +build-backend = "hatchling.build" + +[tool.hatch.build.targets.wheel] +packages = ["src/mcp_server"] + +[tool.pytest.ini_options] +testpaths = ["tests"] +asyncio_mode = "auto" +asyncio_default_fixture_loop_scope = "function" diff --git a/src/mcp_server/__init__.py b/src/mcp_server/__init__.py new file mode 100644 index 0000000..6821aba --- /dev/null +++ b/src/mcp_server/__init__.py @@ -0,0 +1,3 @@ +"""LabVoice MCP server: aggregate eLabFTW tools for voice-driven wetlab use.""" + +__version__ = "0.0.1" diff --git a/src/mcp_server/__main__.py b/src/mcp_server/__main__.py new file mode 100644 index 0000000..dfcd44a --- /dev/null +++ b/src/mcp_server/__main__.py @@ -0,0 +1,19 @@ +"""Entry point: stdio (default) or streamable-http.""" + +import argparse + + +def main(argv: list[str] | None = None) -> None: + """Console script entry point; parses --transport and hands off to server.run.""" + parser = argparse.ArgumentParser(prog="labvoice") + parser.add_argument( + "--transport", + choices=("stdio", "streamable-http"), + default="stdio", + ) + args = parser.parse_args(argv) + raise NotImplementedError + + +if __name__ == "__main__": + main() diff --git a/src/mcp_server/__pycache__/__init__.cpython-313.pyc b/src/mcp_server/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000..b643bf4 Binary files /dev/null and b/src/mcp_server/__pycache__/__init__.cpython-313.pyc differ diff --git a/src/mcp_server/__pycache__/allocate.cpython-313.pyc b/src/mcp_server/__pycache__/allocate.cpython-313.pyc new file mode 100644 index 0000000..5c9bc57 Binary files /dev/null and b/src/mcp_server/__pycache__/allocate.cpython-313.pyc differ diff --git a/src/mcp_server/__pycache__/annotate.cpython-313.pyc b/src/mcp_server/__pycache__/annotate.cpython-313.pyc new file mode 100644 index 0000000..77dc5e7 Binary files /dev/null and b/src/mcp_server/__pycache__/annotate.cpython-313.pyc differ diff --git a/src/mcp_server/__pycache__/config.cpython-313.pyc b/src/mcp_server/__pycache__/config.cpython-313.pyc new file mode 100644 index 0000000..9072632 Binary files /dev/null and b/src/mcp_server/__pycache__/config.cpython-313.pyc differ diff --git a/src/mcp_server/__pycache__/elabftw.cpython-313.pyc b/src/mcp_server/__pycache__/elabftw.cpython-313.pyc new file mode 100644 index 0000000..f9ff0e3 Binary files /dev/null and b/src/mcp_server/__pycache__/elabftw.cpython-313.pyc differ diff --git a/src/mcp_server/__pycache__/errors.cpython-313.pyc b/src/mcp_server/__pycache__/errors.cpython-313.pyc new file mode 100644 index 0000000..cb4d725 Binary files /dev/null and b/src/mcp_server/__pycache__/errors.cpython-313.pyc differ diff --git a/src/mcp_server/__pycache__/journal.cpython-313.pyc b/src/mcp_server/__pycache__/journal.cpython-313.pyc new file mode 100644 index 0000000..d2211a0 Binary files /dev/null and b/src/mcp_server/__pycache__/journal.cpython-313.pyc differ diff --git a/src/mcp_server/__pycache__/models.cpython-313.pyc b/src/mcp_server/__pycache__/models.cpython-313.pyc new file mode 100644 index 0000000..2607847 Binary files /dev/null and b/src/mcp_server/__pycache__/models.cpython-313.pyc differ diff --git a/src/mcp_server/__pycache__/resolve.cpython-313.pyc b/src/mcp_server/__pycache__/resolve.cpython-313.pyc new file mode 100644 index 0000000..d35fe2c Binary files /dev/null and b/src/mcp_server/__pycache__/resolve.cpython-313.pyc differ diff --git a/src/mcp_server/__pycache__/rest.cpython-313.pyc b/src/mcp_server/__pycache__/rest.cpython-313.pyc new file mode 100644 index 0000000..f48aac2 Binary files /dev/null and b/src/mcp_server/__pycache__/rest.cpython-313.pyc differ diff --git a/src/mcp_server/__pycache__/schemas.cpython-313.pyc b/src/mcp_server/__pycache__/schemas.cpython-313.pyc new file mode 100644 index 0000000..5bb0027 Binary files /dev/null and b/src/mcp_server/__pycache__/schemas.cpython-313.pyc differ diff --git a/src/mcp_server/__pycache__/templates.cpython-313.pyc b/src/mcp_server/__pycache__/templates.cpython-313.pyc new file mode 100644 index 0000000..7700aa8 Binary files /dev/null and b/src/mcp_server/__pycache__/templates.cpython-313.pyc differ diff --git a/src/mcp_server/__pycache__/tools.cpython-313.pyc b/src/mcp_server/__pycache__/tools.cpython-313.pyc new file mode 100644 index 0000000..51b9237 Binary files /dev/null and b/src/mcp_server/__pycache__/tools.cpython-313.pyc differ diff --git a/src/mcp_server/allocate.py b/src/mcp_server/allocate.py new file mode 100644 index 0000000..2d42384 --- /dev/null +++ b/src/mcp_server/allocate.py @@ -0,0 +1,27 @@ +"""Container selection and unit whitelist/conversion.""" + +from mcp_server.models import AllocationPolicy, ContainerAllocation, ContainerStock + +DEFAULT_UNIT_WHITELIST: tuple[str, ...] = ("μL", "mL", "L", "μg", "mg", "g", "kg", "ea") + + +def are_compatible(unit_a: str, unit_b: str) -> bool: + """True when both units share a dimension and a tested conversion exists.""" + raise NotImplementedError + + +def convert(quantity: float, from_unit: str, to_unit: str) -> float: + """Convert within the same dimension across tested pairs only.""" + raise NotImplementedError + + +def choose_containers( + containers: list[ContainerStock], + required: float, + unit: str, + policy: AllocationPolicy, + *, + expiry_field: str | None = None, +) -> list[ContainerAllocation]: + """Apply the allocation policy (fifo/nearest_expiry/specific), splitting across containers.""" + raise NotImplementedError diff --git a/src/mcp_server/annotate.py b/src/mcp_server/annotate.py new file mode 100644 index 0000000..f57a3d1 --- /dev/null +++ b/src/mcp_server/annotate.py @@ -0,0 +1,21 @@ +"""labvoice:v1 annotation parser + validator.""" + +from mcp_server.models import ProtocolAnnotation + +ANNOTATION_PREFIX = "" + + +def extract_annotation_block(step_body: str) -> str | None: + """Return the raw last labvoice:v1 comment block, or None when absent.""" + raise NotImplementedError + + +def parse_annotation(step_body: str) -> ProtocolAnnotation | None: + """Parse the last valid labvoice:v1 block; None when no annotation present.""" + raise NotImplementedError + + +def validate_annotation(step_body: str) -> list[str]: + """Return schema violations for the annotation in the step body.""" + raise NotImplementedError diff --git a/src/mcp_server/config.py b/src/mcp_server/config.py new file mode 100644 index 0000000..a89481b --- /dev/null +++ b/src/mcp_server/config.py @@ -0,0 +1,35 @@ +"""Env-driven settings (pydantic-settings).""" + +from functools import lru_cache +from pathlib import Path + +from pydantic_settings import BaseSettings, SettingsConfigDict + + +class Settings(BaseSettings): + model_config = SettingsConfigDict(env_file=".env", extra="ignore") + + elabftw_url: str = "" + elabftw_api_key: str = "" + elabftw_timeout: float = 10.0 + elabftw_retries: int = 2 + + labvoice_db_path: Path = Path("~/.labvoice/journal.sqlite") + labvoice_rest_token: str | None = None + labvoice_template_desc_limit: int = 200 + labvoice_embed_model: str | None = None + labvoice_unit_whitelist: str = "μL,mL,L,μg,mg,g,kg,ea" + labvoice_expiry_field: str | None = None + + @property + def unit_whitelist(self) -> tuple[str, ...]: + return tuple(u.strip() for u in self.labvoice_unit_whitelist.split(",") if u.strip()) + + @property + def api_base_url(self) -> str: + return f"{self.elabftw_url.rstrip('/')}/api/v2" + + +@lru_cache +def get_settings() -> Settings: + return Settings() diff --git a/src/mcp_server/elabftw.py b/src/mcp_server/elabftw.py new file mode 100644 index 0000000..2f27126 --- /dev/null +++ b/src/mcp_server/elabftw.py @@ -0,0 +1,98 @@ +"""Async adapter over the vendored elabapi_python client (sync urllib3, run via asyncio.to_thread).""" + +from typing import Literal + +from mcp_server import schemas +from mcp_server.config import Settings + +EntityType = Literal["experiments", "items"] + + +class ElabftwClient: + def __init__(self, settings: Settings) -> None: + self.settings = settings + + async def get_info(self) -> schemas.ElabftwInfo: + """GET /info — auth + reachability health check.""" + raise NotImplementedError + + async def search_experiments( + self, + *, + q: str | None = None, + tags: list[str] | None = None, + limit: int = 15, + offset: int = 0, + ) -> list[schemas.ElabftwExperiment]: + """GET /experiments — search by query/tags with pagination.""" + raise NotImplementedError + + async def get_experiment(self, experiment_id: int) -> schemas.ElabftwExperiment: + """GET /experiments/{id}.""" + raise NotImplementedError + + async def create_experiment( + self, template_id: int, title: str | None = None + ) -> schemas.ElabftwExperiment: + """POST /experiments — create an experiment from a template.""" + raise NotImplementedError + + async def get_steps( + self, entity_type: EntityType, entity_id: int + ) -> list[schemas.ElabftwStep]: + """GET /{entity_type}/{id}/steps.""" + raise NotImplementedError + + async def finish_step( + self, entity_type: EntityType, entity_id: int, step_id: int + ) -> schemas.ElabftwStep: + """PATCH /{entity_type}/{id}/steps/{subid} {"action": "finish"}.""" + raise NotImplementedError + + async def list_comments( + self, entity_type: EntityType, entity_id: int + ) -> list[schemas.ElabftwComment]: + """GET /{entity_type}/{id}/comments.""" + raise NotImplementedError + + async def post_comment( + self, entity_type: EntityType, entity_id: int, body: str + ) -> schemas.ElabftwComment: + """POST /{entity_type}/{id}/comments.""" + raise NotImplementedError + + async def search_items( + self, *, q: str | None = None, limit: int = 15, offset: int = 0 + ) -> list[schemas.ElabftwItem]: + """GET /items — scan/search resources.""" + raise NotImplementedError + + async def get_item(self, item_id: int) -> schemas.ElabftwItem: + """GET /items/{id}.""" + raise NotImplementedError + + async def get_containers( + self, entity_type: EntityType, entity_id: int + ) -> list[schemas.ContainerLink]: + """GET /{entity_type}/{id}/containers.""" + raise NotImplementedError + + async def set_container_quantity( + self, entity_type: EntityType, entity_id: int, subitem_id: int, qty_stored: float + ) -> None: + """PATCH /{entity_type}/{id}/containers/{subid} {"qty_stored": ...}.""" + raise NotImplementedError + + async def list_storage_units(self) -> list[schemas.StorageUnit]: + """GET /storage_units?hierarchy=true — location names for readback.""" + raise NotImplementedError + + async def list_templates( + self, *, q: str | None = None, limit: int = 25, offset: int = 0 + ) -> list[schemas.ElabftwTemplate]: + """GET /experiments_templates — list/search templates.""" + raise NotImplementedError + + async def get_template(self, template_id: int) -> schemas.ElabftwTemplate: + """GET /experiments_templates/{id}.""" + raise NotImplementedError diff --git a/src/mcp_server/errors.py b/src/mcp_server/errors.py new file mode 100644 index 0000000..7d1f734 --- /dev/null +++ b/src/mcp_server/errors.py @@ -0,0 +1,60 @@ +"""Typed errors mapped to voice-friendly messages.""" + +from enum import StrEnum + + +class ErrorKind(StrEnum): + AUTH = "auth_error" + PERMISSION = "permission_error" + NOT_FOUND = "not_found" + API = "api_error" + ANNOTATION = "annotation_error" + CLARIFICATION = "clarification" + INSUFFICIENT_STOCK = "insufficient_stock" + + +class LabVoiceError(Exception): + kind: ErrorKind = ErrorKind.API + + def __init__(self, message: str, *, detail: str | None = None) -> None: + super().__init__(message) + self.message = message + self.detail = detail + + +class AuthError(LabVoiceError): + kind = ErrorKind.AUTH + + +class PermissionDeniedError(LabVoiceError): + kind = ErrorKind.PERMISSION + + +class NotFoundError(LabVoiceError): + kind = ErrorKind.NOT_FOUND + + +class ApiError(LabVoiceError): + kind = ErrorKind.API + + +class AnnotationError(LabVoiceError): + kind = ErrorKind.ANNOTATION + + +class ClarificationNeededError(LabVoiceError): + kind = ErrorKind.CLARIFICATION + + def __init__( + self, + message: str, + *, + options: list[str] | None = None, + detail: str | None = None, + ) -> None: + super().__init__(message, detail=detail) + self.options = options or [] + + +class InsufficientStockError(LabVoiceError): + kind = ErrorKind.INSUFFICIENT_STOCK diff --git a/src/mcp_server/journal.py b/src/mcp_server/journal.py new file mode 100644 index 0000000..fabc98b --- /dev/null +++ b/src/mcp_server/journal.py @@ -0,0 +1,81 @@ +"""SQLite saga journal: idempotency, compensation, audit log.""" + +from enum import StrEnum +from pathlib import Path +from typing import Any + +from pydantic import BaseModel, Field + + +class OperationStatus(StrEnum): + PLANNED = "planned" + RUNNING = "running" + COMPLETED = "completed" + FAILED = "failed" + COMPENSATED = "compensated" + PARTIAL_FAILURE = "partial_failure" + + +class ActionStatus(StrEnum): + PLANNED = "planned" + DONE = "done" + FAILED = "failed" + COMPENSATED = "compensated" + + +class ActionRecord(BaseModel): + id: int + operation_id: str + action: str + status: ActionStatus = ActionStatus.PLANNED + payload: dict[str, Any] = Field(default_factory=dict) + response: dict[str, Any] | None = None + + +class OperationRecord(BaseModel): + operation_id: str + kind: str + status: OperationStatus = OperationStatus.PLANNED + actions: list[ActionRecord] = Field(default_factory=list) + + +class SagaJournal: + def __init__(self, db_path: Path) -> None: + self.db_path = db_path + + async def connect(self) -> None: + """Open/initialize the SQLite journal.""" + raise NotImplementedError + + async def close(self) -> None: + raise NotImplementedError + + async def begin_operation( + self, kind: str, operation_id: str | None = None + ) -> OperationRecord: + """Start a journaled operation; an existing completed operation_id means idempotent replay.""" + raise NotImplementedError + + async def record_action( + self, operation_id: str, action: str, payload: dict[str, Any] + ) -> ActionRecord: + raise NotImplementedError + + async def mark_action( + self, + operation_id: str, + action_id: int, + status: ActionStatus, + response: dict[str, Any] | None = None, + ) -> ActionRecord: + raise NotImplementedError + + async def finish_operation(self, operation_id: str, status: OperationStatus) -> None: + raise NotImplementedError + + async def get_operation(self, operation_id: str) -> OperationRecord: + raise NotImplementedError + + async def has_completed(self, operation_id: str) -> bool: + """True when this operation_id already ran to completion (idempotency check).""" + raise NotImplementedError diff --git a/src/mcp_server/models.py b/src/mcp_server/models.py new file mode 100644 index 0000000..f14f3a9 --- /dev/null +++ b/src/mcp_server/models.py @@ -0,0 +1,179 @@ +"""Tool input/output schemas and compact result types.""" + +from enum import StrEnum +from typing import Literal + +from pydantic import BaseModel, Field + + +class AllocationPolicy(StrEnum): + FIFO = "fifo" + NEAREST_EXPIRY = "nearest_expiry" + SPECIFIC = "specific" + + +class Consumable(BaseModel): + resource_key: str + quantity: float | None = None + unit: str + allocation: AllocationPolicy = AllocationPolicy.FIFO + container_id: int | None = None + optional: bool = False + + +class ProtocolAnnotation(BaseModel): + consumables: list[Consumable] = Field(default_factory=list) + prompt_quantity: bool = False + + +class StepInfo(BaseModel): + id: int + position: int | None = None + body: str + finished: bool = False + + +class ContainerStock(BaseModel): + container_id: int + amount: str + available: float + unit: str + + +class NextStep(BaseModel): + experiment_id: int + step: StepInfo + consumables: list[Consumable] = Field(default_factory=list) + stock: list[ContainerStock] = Field(default_factory=list) + + +class ItemSummary(BaseModel): + id: int + title: str + resource_key: str | None = None + + +class CommentInfo(BaseModel): + id: int + body: str + created_at: str | None = None + + +class ExperimentSummary(BaseModel): + id: int + title: str + status: str | None = None + + +class ExperimentContext(BaseModel): + experiment_id: int + title: str + status: str | None = None + unfinished_steps: list[StepInfo] = Field(default_factory=list) + linked_resources: list[ItemSummary] = Field(default_factory=list) + recent_comments: list[CommentInfo] = Field(default_factory=list) + + +class AppState(BaseModel): + experiment_id: int + title: str + next_step: NextStep | None = None + unfinished_steps: list[int] = Field(default_factory=list) + + +class HandoffContext(BaseModel): + """Minimal id-only context the app forwards to the edge LLM.""" + + experiment_id: int + user_id: int + step_id: int | None = None + device_id: str | None = None + location_id: str | None = None + + +class TemplateSummary(BaseModel): + id: int + title: str + short_description: str + tags: list[str] = Field(default_factory=list) + + +class CreateExperimentResult(BaseModel): + ok: bool = True + experiment_id: int + title: str + first_step: StepInfo | None = None + + +class ConsumedRecord(BaseModel): + resource_key: str + container_id: int + amount: str + remaining: str + + +class CompleteStepResult(BaseModel): + ok: bool = True + status: Literal["completed", "protocol_complete", "reverted", "partial_failure"] = "completed" + experiment_id: int + step: StepInfo + consumed: list[ConsumedRecord] = Field(default_factory=list) + comment_id: int | None = None + next_step: StepInfo | None = None + + +class ObservationResult(BaseModel): + ok: bool = True + experiment_id: int + comment_id: int | None = None + step: StepInfo | None = None + + +class InventoryResult(BaseModel): + ok: bool = True + container_id: int + resource_key: str | None = None + amount: str + remaining: str + + +class ContainerAllocation(BaseModel): + container_id: int + take: float + unit: str + remaining: str + + +class MappingEntry(BaseModel): + resource_key: str + item_id: int + title: str | None = None + unit: str | None = None + + +class MappingProposal(BaseModel): + resource_key: str + item_id: int + title: str | None = None + reason: str | None = None + score: float | None = None + + +class ScanResult(BaseModel): + containers_seen: int = 0 + markers_found: int = 0 + proposals: list[MappingProposal] = Field(default_factory=list) + + +class ValidationIssue(BaseModel): + severity: Literal["error", "warning"] + message: str + step_id: int | None = None + resource_key: str | None = None + + +class ValidationReport(BaseModel): + entity_type: str + entity_id: int + ok: bool + issues: list[ValidationIssue] = Field(default_factory=list) diff --git a/src/mcp_server/resolve.py b/src/mcp_server/resolve.py new file mode 100644 index 0000000..f5a1db3 --- /dev/null +++ b/src/mcp_server/resolve.py @@ -0,0 +1,35 @@ +"""resource_key → item id resolution (mapping store, markers, setup-time matchers).""" + +from typing import Any + +from mcp_server.config import Settings +from mcp_server.models import MappingEntry, MappingProposal + + +class ResourceResolver: + def __init__(self, settings: Settings) -> None: + self.settings = settings + + async def resolve(self, resource_key: str) -> int: + """Resolve a resource_key to an items id; ambiguity/absence raises ClarificationNeededError.""" + raise NotImplementedError + + async def find_candidates(self, resource_key: str) -> list[MappingProposal]: + """Candidate resources for an unmapped key (markers, CAS, exact title).""" + raise NotImplementedError + + async def upsert_mapping(self, resource_key: str, item_id: int) -> MappingEntry: + """Bind resource_key → item_id (idempotent upsert into the local store).""" + raise NotImplementedError + + async def list_mappings(self) -> list[MappingEntry]: + """All bindings in the local mapping store.""" + raise NotImplementedError + + async def export_mapping(self) -> dict[str, Any]: + """Serialize the mapping store to the portable JSON structure.""" + raise NotImplementedError + + async def import_mapping(self, data: dict[str, Any]) -> list[MappingProposal]: + """Import a mapping file; propose matches, ambiguous ones need approval.""" + raise NotImplementedError diff --git a/src/mcp_server/rest.py b/src/mcp_server/rest.py new file mode 100644 index 0000000..4de2b03 --- /dev/null +++ b/src/mcp_server/rest.py @@ -0,0 +1,30 @@ +"""Read-only REST mirror of the read tools for the mobile app (bearer-token protected).""" + +from typing import TYPE_CHECKING, Any + +if TYPE_CHECKING: + from fastapi import FastAPI + + from mcp_server.config import Settings + +ENDPOINTS: tuple[str, ...] = ( + "GET /api/experiments?q=&limit=", + "GET /api/experiments/{id}/state", + "GET /api/experiments/{id}/next-step", + "GET /api/templates?q=&limit=", +) + + +def create_rest_app(settings: "Settings") -> "FastAPI": + """Assemble the FastAPI app exposing the read endpoints; mutations never appear here.""" + raise NotImplementedError + + +def verify_token(token: str) -> None: + """Validate the bearer token against LABVOICE_REST_TOKEN.""" + raise NotImplementedError + + +def error_payload(kind: str, message: str) -> dict[str, Any]: + """Compact typed-error JSON body shared with the MCP results.""" + raise NotImplementedError diff --git a/src/mcp_server/schemas.py b/src/mcp_server/schemas.py new file mode 100644 index 0000000..4578506 --- /dev/null +++ b/src/mcp_server/schemas.py @@ -0,0 +1,48 @@ +"""Pydantic models for the eLabFTW entities we consume.""" + +from pydantic import BaseModel, ConfigDict + + +class ElabftwEntity(BaseModel): + model_config = ConfigDict(extra="allow") + + +class ElabftwInfo(ElabftwEntity): + pass + + +class ElabftwExperiment(ElabftwEntity): + id: int + title: str + + +class ElabftwItem(ElabftwEntity): + id: int + title: str + + +class ElabftwStep(ElabftwEntity): + id: int + body: str + finished: bool = False + ordering: int | None = None + + +class ElabftwComment(ElabftwEntity): + id: int + + +class ElabftwTemplate(ElabftwEntity): + id: int + title: str + + +class ContainerLink(ElabftwEntity): + id: int + qty_stored: float | None = None + unit: str | None = None + + +class StorageUnit(ElabftwEntity): + id: int + label: str | None = None diff --git a/src/mcp_server/server.py b/src/mcp_server/server.py new file mode 100644 index 0000000..15c0fee --- /dev/null +++ b/src/mcp_server/server.py @@ -0,0 +1,25 @@ +"""FastMCP assembly, lifespan and service wiring.""" + +from typing import TYPE_CHECKING, Any, Literal + +from mcp_server.config import Settings, get_settings + +if TYPE_CHECKING: + from mcp.server.fastmcp import FastMCP + +Transport = Literal["stdio", "streamable-http"] + + +def build_services(settings: Settings) -> dict[str, Any]: + """Wire adapter, resolver, journal, workflows and template service into one container.""" + raise NotImplementedError + + +async def create_mcp_server(settings: Settings | None = None) -> "FastMCP": + """Assemble the FastMCP server with all tools registered and a lifespan managing services.""" + raise NotImplementedError + + +def run(transport: Transport = "stdio") -> None: + """Run the server: stdio (default) or streamable-http (mounted with the REST app).""" + raise NotImplementedError diff --git a/src/mcp_server/templates.py b/src/mcp_server/templates.py new file mode 100644 index 0000000..435d8f8 --- /dev/null +++ b/src/mcp_server/templates.py @@ -0,0 +1,27 @@ +"""Experiment templates: description extraction, semantic ranking, creation flow.""" + +from mcp_server.config import Settings +from mcp_server.elabftw import ElabftwClient +from mcp_server.models import CreateExperimentResult, TemplateSummary + + +class TemplateService: + def __init__(self, client: ElabftwClient, settings: Settings) -> None: + self.client = client + self.settings = settings + + async def list_templates( + self, query: str | None = None, limit: int = 10 + ) -> list[TemplateSummary]: + """List/search templates (id, title, short description, tags); semantic ranking when queried.""" + raise NotImplementedError + + async def build_search_index(self) -> None: + """(Re)build the template search corpus/vector cache in SQLite.""" + raise NotImplementedError + + async def create_experiment_from_template( + self, template_id: int, title: str | None = None + ) -> CreateExperimentResult: + """Create an experiment from a template; steps + annotations are copied by eLabFTW.""" + raise NotImplementedError diff --git a/src/mcp_server/tools.py b/src/mcp_server/tools.py new file mode 100644 index 0000000..facaf6b --- /dev/null +++ b/src/mcp_server/tools.py @@ -0,0 +1,142 @@ +"""MCP tool registration: one thin async function per tool, compact results.""" + +from typing import Any + +from mcp_server.models import ( + CompleteStepResult, + CreateExperimentResult, + ExperimentContext, + ExperimentSummary, + InventoryResult, + MappingEntry, + NextStep, + ObservationResult, + ScanResult, + TemplateSummary, + ValidationReport, +) + + +async def find_experiments( + query: str | None = None, + tags: list[str] | None = None, + limit: int = 15, +) -> list[ExperimentSummary]: + """Search experiments by title/text/tag/custom id.""" + raise NotImplementedError + + +async def get_experiment_context(experiment_id: int) -> ExperimentContext: + """Metadata, unfinished steps, linked resources and recent comments, compact.""" + raise NotImplementedError + + +async def get_next_protocol_step(experiment_id: int) -> NextStep | None: + """Next unfinished step: text, parsed consumables, stock preview.""" + raise NotImplementedError + + +async def list_experiment_templates( + query: str | None = None, + limit: int = 10, +) -> list[TemplateSummary]: + """List/search experiment templates with a short description (semantic ranking).""" + raise NotImplementedError + + +async def validate_protocol_template( + entity_type: str, + entity_id: int, +) -> ValidationReport: + """Check labvoice annotations + resource mappings of a template/experiment.""" + raise NotImplementedError + + +async def complete_next_protocol_step( + experiment_id: int, + comment: str | None = None, + quantities: dict[str, float] | None = None, +) -> CompleteStepResult: + """Allocate + decrement stock, finish the next step and post the comment in one call.""" + raise NotImplementedError + + +async def complete_protocol_step( + experiment_id: int, + step_id: int, + comment: str | None = None, + quantities: dict[str, float] | None = None, +) -> CompleteStepResult: + """Complete an explicit step (for “redo step 3” voice commands).""" + raise NotImplementedError + + +async def record_protocol_observation( + experiment_id: int, + comment: str, + step_id: int | None = None, +) -> ObservationResult: + """Add a comment (+ optional step body edit) without completing anything.""" + raise NotImplementedError + + +async def create_experiment_from_template( + template_id: int, + title: str | None = None, +) -> CreateExperimentResult: + """Start a new experiment from a template (interactive template pick happens first).""" + raise NotImplementedError + + +async def adjust_inventory( + amount: float, + unit: str, + container_id: int | None = None, + resource_key: str | None = None, + note: str | None = None, +) -> InventoryResult: + """Restock/correct a container (voice: “add 500 mL to …”).""" + raise NotImplementedError + + +async def scan_instance() -> ScanResult: + """Inventory containers, detect resource markers, propose resource matches.""" + raise NotImplementedError + + +async def map_resource(resource_key: str, item_id: int) -> MappingEntry: + """Bind a semantic resource_key to an eLabFTW items id.""" + raise NotImplementedError + + +async def export_mapping() -> dict[str, Any]: + """Export the resource_key → item_id mapping store as portable JSON.""" + raise NotImplementedError + + +async def import_mapping(data: dict[str, Any]) -> dict[str, Any]: + """Import a mapping file; ambiguous matches are proposals requiring approval.""" + raise NotImplementedError + + +TOOL_FUNCTIONS: tuple[Any, ...] = ( + find_experiments, + get_experiment_context, + get_next_protocol_step, + list_experiment_templates, + validate_protocol_template, + complete_next_protocol_step, + complete_protocol_step, + record_protocol_observation, + create_experiment_from_template, + adjust_inventory, + scan_instance, + map_resource, + export_mapping, + import_mapping, +) + + +def register_tools(mcp: Any) -> None: + """Register every tool function on the FastMCP instance.""" + raise NotImplementedError diff --git a/src/mcp_server/workflows/__init__.py b/src/mcp_server/workflows/__init__.py new file mode 100644 index 0000000..d1a74bb --- /dev/null +++ b/src/mcp_server/workflows/__init__.py @@ -0,0 +1 @@ +"""Aggregate workflow services (the point of the server).""" diff --git a/src/mcp_server/workflows/__pycache__/__init__.cpython-313.pyc b/src/mcp_server/workflows/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000..6c496d0 Binary files /dev/null and b/src/mcp_server/workflows/__pycache__/__init__.cpython-313.pyc differ diff --git a/src/mcp_server/workflows/__pycache__/inventory.cpython-313.pyc b/src/mcp_server/workflows/__pycache__/inventory.cpython-313.pyc new file mode 100644 index 0000000..7be9274 Binary files /dev/null and b/src/mcp_server/workflows/__pycache__/inventory.cpython-313.pyc differ diff --git a/src/mcp_server/workflows/__pycache__/protocol.cpython-313.pyc b/src/mcp_server/workflows/__pycache__/protocol.cpython-313.pyc new file mode 100644 index 0000000..214f459 Binary files /dev/null and b/src/mcp_server/workflows/__pycache__/protocol.cpython-313.pyc differ diff --git a/src/mcp_server/workflows/__pycache__/setup.cpython-313.pyc b/src/mcp_server/workflows/__pycache__/setup.cpython-313.pyc new file mode 100644 index 0000000..b0f1d9b Binary files /dev/null and b/src/mcp_server/workflows/__pycache__/setup.cpython-313.pyc differ diff --git a/src/mcp_server/workflows/inventory.py b/src/mcp_server/workflows/inventory.py new file mode 100644 index 0000000..9be65d2 --- /dev/null +++ b/src/mcp_server/workflows/inventory.py @@ -0,0 +1,37 @@ +"""adjust_inventory and stock reads.""" + +from mcp_server.config import Settings +from mcp_server.elabftw import ElabftwClient +from mcp_server.journal import SagaJournal +from mcp_server.models import ContainerStock, InventoryResult +from mcp_server.resolve import ResourceResolver + + +class InventoryWorkflow: + def __init__( + self, + client: ElabftwClient, + resolver: ResourceResolver, + journal: SagaJournal, + settings: Settings, + ) -> None: + self.client = client + self.resolver = resolver + self.journal = journal + self.settings = settings + + async def stock_for_resource(self, resource_key: str) -> list[ContainerStock]: + """Containers holding the resolved resource with compatible units and current stock.""" + raise NotImplementedError + + async def adjust_inventory( + self, + *, + amount: float, + unit: str, + resource_key: str | None = None, + container_id: int | None = None, + note: str | None = None, + ) -> InventoryResult: + """Restock/correct a container (voice: “add 500 mL to …”); journaled.""" + raise NotImplementedError diff --git a/src/mcp_server/workflows/protocol.py b/src/mcp_server/workflows/protocol.py new file mode 100644 index 0000000..1917283 --- /dev/null +++ b/src/mcp_server/workflows/protocol.py @@ -0,0 +1,63 @@ +"""complete_next/complete/observation workflows (step completion saga).""" + +from typing import Mapping + +from mcp_server.config import Settings +from mcp_server.elabftw import ElabftwClient +from mcp_server.journal import SagaJournal +from mcp_server.models import ( + CompleteStepResult, + NextStep, + ObservationResult, +) +from mcp_server.resolve import ResourceResolver + + +class ProtocolWorkflow: + def __init__( + self, + client: ElabftwClient, + resolver: ResourceResolver, + journal: SagaJournal, + settings: Settings, + ) -> None: + self.client = client + self.resolver = resolver + self.journal = journal + self.settings = settings + + async def get_next_step(self, experiment_id: int) -> NextStep | None: + """Next unfinished step: text, parsed consumables, stock preview; None when protocol complete.""" + raise NotImplementedError + + async def complete_next_step( + self, + experiment_id: int, + *, + comment: str | None = None, + quantities: Mapping[str, float] | None = None, + ) -> CompleteStepResult: + """Headline workflow: allocate + decrement stock, finish step, post comment, journaled saga.""" + raise NotImplementedError + + async def complete_step( + self, + experiment_id: int, + step_id: int, + *, + comment: str | None = None, + quantities: Mapping[str, float] | None = None, + ) -> CompleteStepResult: + """Same saga with an explicit step id (for “redo step 3” voice commands).""" + raise NotImplementedError + + async def record_observation( + self, + experiment_id: int, + comment: str, + *, + step_id: int | None = None, + body: str | None = None, + ) -> ObservationResult: + """Add a comment (+ optional step body edit) without completing anything.""" + raise NotImplementedError diff --git a/src/mcp_server/workflows/setup.py b/src/mcp_server/workflows/setup.py new file mode 100644 index 0000000..c67d6ef --- /dev/null +++ b/src/mcp_server/workflows/setup.py @@ -0,0 +1,32 @@ +"""Instance onboarding: scan, mapping, template validation.""" + +from mcp_server.config import Settings +from mcp_server.elabftw import ElabftwClient +from mcp_server.models import MappingEntry, ScanResult, ValidationReport +from mcp_server.resolve import ResourceResolver + + +class SetupWorkflow: + def __init__( + self, + client: ElabftwClient, + resolver: ResourceResolver, + settings: Settings, + ) -> None: + self.client = client + self.resolver = resolver + self.settings = settings + + async def scan_instance(self) -> ScanResult: + """Walk /items, inventory containers, detect markers, propose resource matches.""" + raise NotImplementedError + + async def map_resource(self, resource_key: str, item_id: int) -> MappingEntry: + """Bind resource_key → item_id (idempotent, upsert into the mapping store).""" + raise NotImplementedError + + async def validate_protocol_template( + self, entity_type: str, entity_id: int + ) -> ValidationReport: + """Check annotations + mappings of a template/experiment; blocking issues are errors.""" + raise NotImplementedError diff --git a/tests/__pycache__/conftest.cpython-313-pytest-9.1.1.pyc b/tests/__pycache__/conftest.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..c036680 Binary files /dev/null and b/tests/__pycache__/conftest.cpython-313-pytest-9.1.1.pyc differ diff --git a/tests/__pycache__/conftest.cpython-313.pyc b/tests/__pycache__/conftest.cpython-313.pyc new file mode 100644 index 0000000..8df5db4 Binary files /dev/null and b/tests/__pycache__/conftest.cpython-313.pyc differ diff --git a/tests/__pycache__/fakes.cpython-313.pyc b/tests/__pycache__/fakes.cpython-313.pyc new file mode 100644 index 0000000..44fa864 Binary files /dev/null and b/tests/__pycache__/fakes.cpython-313.pyc differ diff --git a/tests/__pycache__/test_allocate.cpython-313-pytest-9.1.1.pyc b/tests/__pycache__/test_allocate.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..e449c28 Binary files /dev/null and b/tests/__pycache__/test_allocate.cpython-313-pytest-9.1.1.pyc differ diff --git a/tests/__pycache__/test_allocate.cpython-313.pyc b/tests/__pycache__/test_allocate.cpython-313.pyc new file mode 100644 index 0000000..d469870 Binary files /dev/null and b/tests/__pycache__/test_allocate.cpython-313.pyc differ diff --git a/tests/__pycache__/test_annotate.cpython-313-pytest-9.1.1.pyc b/tests/__pycache__/test_annotate.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..53beb48 Binary files /dev/null and b/tests/__pycache__/test_annotate.cpython-313-pytest-9.1.1.pyc differ diff --git a/tests/__pycache__/test_annotate.cpython-313.pyc b/tests/__pycache__/test_annotate.cpython-313.pyc new file mode 100644 index 0000000..458d998 Binary files /dev/null and b/tests/__pycache__/test_annotate.cpython-313.pyc differ diff --git a/tests/__pycache__/test_config.cpython-313-pytest-9.1.1.pyc b/tests/__pycache__/test_config.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..c873f2d Binary files /dev/null and b/tests/__pycache__/test_config.cpython-313-pytest-9.1.1.pyc differ diff --git a/tests/__pycache__/test_config.cpython-313.pyc b/tests/__pycache__/test_config.cpython-313.pyc new file mode 100644 index 0000000..41becb8 Binary files /dev/null and b/tests/__pycache__/test_config.cpython-313.pyc differ diff --git a/tests/__pycache__/test_elabftw_adapter.cpython-313-pytest-9.1.1.pyc b/tests/__pycache__/test_elabftw_adapter.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..69c3c3b Binary files /dev/null and b/tests/__pycache__/test_elabftw_adapter.cpython-313-pytest-9.1.1.pyc differ diff --git a/tests/__pycache__/test_elabftw_adapter.cpython-313.pyc b/tests/__pycache__/test_elabftw_adapter.cpython-313.pyc new file mode 100644 index 0000000..707c16d Binary files /dev/null and b/tests/__pycache__/test_elabftw_adapter.cpython-313.pyc differ diff --git a/tests/__pycache__/test_errors.cpython-313-pytest-9.1.1.pyc b/tests/__pycache__/test_errors.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..489cb0d Binary files /dev/null and b/tests/__pycache__/test_errors.cpython-313-pytest-9.1.1.pyc differ diff --git a/tests/__pycache__/test_errors.cpython-313.pyc b/tests/__pycache__/test_errors.cpython-313.pyc new file mode 100644 index 0000000..08170d9 Binary files /dev/null and b/tests/__pycache__/test_errors.cpython-313.pyc differ diff --git a/tests/__pycache__/test_journal.cpython-313-pytest-9.1.1.pyc b/tests/__pycache__/test_journal.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..3c5fdc4 Binary files /dev/null and b/tests/__pycache__/test_journal.cpython-313-pytest-9.1.1.pyc differ diff --git a/tests/__pycache__/test_journal.cpython-313.pyc b/tests/__pycache__/test_journal.cpython-313.pyc new file mode 100644 index 0000000..72aaafb Binary files /dev/null and b/tests/__pycache__/test_journal.cpython-313.pyc differ diff --git a/tests/__pycache__/test_models.cpython-313-pytest-9.1.1.pyc b/tests/__pycache__/test_models.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..08b14a7 Binary files /dev/null and b/tests/__pycache__/test_models.cpython-313-pytest-9.1.1.pyc differ diff --git a/tests/__pycache__/test_models.cpython-313.pyc b/tests/__pycache__/test_models.cpython-313.pyc new file mode 100644 index 0000000..11cd32d Binary files /dev/null and b/tests/__pycache__/test_models.cpython-313.pyc differ diff --git a/tests/__pycache__/test_resolve.cpython-313-pytest-9.1.1.pyc b/tests/__pycache__/test_resolve.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..67daf28 Binary files /dev/null and b/tests/__pycache__/test_resolve.cpython-313-pytest-9.1.1.pyc differ diff --git a/tests/__pycache__/test_resolve.cpython-313.pyc b/tests/__pycache__/test_resolve.cpython-313.pyc new file mode 100644 index 0000000..2d2d32f Binary files /dev/null and b/tests/__pycache__/test_resolve.cpython-313.pyc differ diff --git a/tests/__pycache__/test_rest_api.cpython-313-pytest-9.1.1.pyc b/tests/__pycache__/test_rest_api.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..5083424 Binary files /dev/null and b/tests/__pycache__/test_rest_api.cpython-313-pytest-9.1.1.pyc differ diff --git a/tests/__pycache__/test_rest_api.cpython-313.pyc b/tests/__pycache__/test_rest_api.cpython-313.pyc new file mode 100644 index 0000000..1b4adaa Binary files /dev/null and b/tests/__pycache__/test_rest_api.cpython-313.pyc differ diff --git a/tests/__pycache__/test_safety.cpython-313-pytest-9.1.1.pyc b/tests/__pycache__/test_safety.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..fc9f470 Binary files /dev/null and b/tests/__pycache__/test_safety.cpython-313-pytest-9.1.1.pyc differ diff --git a/tests/__pycache__/test_safety.cpython-313.pyc b/tests/__pycache__/test_safety.cpython-313.pyc new file mode 100644 index 0000000..2bd067b Binary files /dev/null and b/tests/__pycache__/test_safety.cpython-313.pyc differ diff --git a/tests/__pycache__/test_templates.cpython-313-pytest-9.1.1.pyc b/tests/__pycache__/test_templates.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..aeadc77 Binary files /dev/null and b/tests/__pycache__/test_templates.cpython-313-pytest-9.1.1.pyc differ diff --git a/tests/__pycache__/test_templates.cpython-313.pyc b/tests/__pycache__/test_templates.cpython-313.pyc new file mode 100644 index 0000000..8ec0a9a Binary files /dev/null and b/tests/__pycache__/test_templates.cpython-313.pyc differ diff --git a/tests/__pycache__/test_tools_mcp.cpython-313-pytest-9.1.1.pyc b/tests/__pycache__/test_tools_mcp.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..d383cbd Binary files /dev/null and b/tests/__pycache__/test_tools_mcp.cpython-313-pytest-9.1.1.pyc differ diff --git a/tests/__pycache__/test_tools_mcp.cpython-313.pyc b/tests/__pycache__/test_tools_mcp.cpython-313.pyc new file mode 100644 index 0000000..093abd7 Binary files /dev/null and b/tests/__pycache__/test_tools_mcp.cpython-313.pyc differ diff --git a/tests/__pycache__/test_workflows_inventory.cpython-313-pytest-9.1.1.pyc b/tests/__pycache__/test_workflows_inventory.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..d555876 Binary files /dev/null and b/tests/__pycache__/test_workflows_inventory.cpython-313-pytest-9.1.1.pyc differ diff --git a/tests/__pycache__/test_workflows_inventory.cpython-313.pyc b/tests/__pycache__/test_workflows_inventory.cpython-313.pyc new file mode 100644 index 0000000..b557bce Binary files /dev/null and b/tests/__pycache__/test_workflows_inventory.cpython-313.pyc differ diff --git a/tests/__pycache__/test_workflows_protocol.cpython-313-pytest-9.1.1.pyc b/tests/__pycache__/test_workflows_protocol.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..7ec54a0 Binary files /dev/null and b/tests/__pycache__/test_workflows_protocol.cpython-313-pytest-9.1.1.pyc differ diff --git a/tests/__pycache__/test_workflows_protocol.cpython-313.pyc b/tests/__pycache__/test_workflows_protocol.cpython-313.pyc new file mode 100644 index 0000000..02213d6 Binary files /dev/null and b/tests/__pycache__/test_workflows_protocol.cpython-313.pyc differ diff --git a/tests/__pycache__/test_workflows_setup.cpython-313-pytest-9.1.1.pyc b/tests/__pycache__/test_workflows_setup.cpython-313-pytest-9.1.1.pyc new file mode 100644 index 0000000..9011d9a Binary files /dev/null and b/tests/__pycache__/test_workflows_setup.cpython-313-pytest-9.1.1.pyc differ diff --git a/tests/__pycache__/test_workflows_setup.cpython-313.pyc b/tests/__pycache__/test_workflows_setup.cpython-313.pyc new file mode 100644 index 0000000..c8f475d Binary files /dev/null and b/tests/__pycache__/test_workflows_setup.cpython-313.pyc differ diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..f1a22da --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,164 @@ +"""Shared fixtures for the LabVoice MCP server test suite. + +Conventions pinned by this suite (adjust here if the implementation diverges): + +1. Workflows and services receive their collaborators via constructor + arguments (``client``, ``resolver``, ``journal``, ``settings``) exactly as + declared in the scaffolds — tests inject ``FakeElabftwClient`` / + ``StubResolver`` and a real ``SagaJournal`` against a temp SQLite file. +2. ``SagaJournal`` has an explicit ``connect()``/``close()`` lifecycle. +3. The REST app and MCP tools resolve their read services through + ``mcp_server.server.build_services(settings)`` (the wiring container from + the scaffold); tests monkeypatch that factory. The service container is a + dict with the keys implied by the scaffold's build_services comment: + ``client``, ``resolver``, ``journal``, ``protocol``, ``inventory``, + ``setup``, ``templates``. +4. MCP-level tests drive the real ``FastMCP`` server (from ``mcp`` 2.1.x) + in-process via ``mcp.client.Client``. +""" + +from __future__ import annotations + +import sys +from pathlib import Path + +import pytest + +# Make the vendored elabapi_python client importable for tests (it is vendored, +# not installed). Its deps (six, urllib3, certifi) come from the dev group. +_VENDOR = Path(__file__).resolve().parent.parent / "vendor" / "elabapi-python" +if str(_VENDOR) not in sys.path: + sys.path.insert(0, str(_VENDOR)) + +from mcp_server.config import Settings +from mcp_server.journal import SagaJournal +from mcp_server.resolve import ResourceResolver +from mcp_server.templates import TemplateService +from mcp_server.workflows.inventory import InventoryWorkflow +from mcp_server.workflows.protocol import ProtocolWorkflow +from mcp_server.workflows.setup import SetupWorkflow + +from fakes import ( + FakeElabftwClient, + StubResolver, + make_experiment, + make_item, +) + + +@pytest.fixture +def settings(tmp_path, monkeypatch) -> Settings: + """Isolated settings: temp DB, no env/.env interference, distinctive API key.""" + for var in ( + "ELABFTW_URL", + "ELABFTW_API_KEY", + "LABVOICE_DB_PATH", + "LABVOICE_REST_TOKEN", + "LABVOICE_TEMPLATE_DESC_LIMIT", + "LABVOICE_EMBED_MODEL", + "LABVOICE_UNIT_WHITELIST", + "LABVOICE_EXPIRY_FIELD", + ): + monkeypatch.delenv(var, raising=False) + return Settings( + _env_file=None, + elabftw_url="https://eln.example.org", + elabftw_api_key="labvoice-secret-key-do-not-leak", + elabftw_timeout=5.0, + elabftw_retries=0, + labvoice_db_path=tmp_path / "journal.sqlite", + ) + + +@pytest.fixture +def client() -> FakeElabftwClient: + """Standard scenario: experiment 123 (steps 9, 10) and ethanol item 12.""" + return FakeElabftwClient(experiments=[make_experiment()], items=[make_item()]) + + +@pytest.fixture +def resolver_stub() -> StubResolver: + """ethanol_absolute → item 12; other keys raise clarification.""" + return StubResolver(mappings={"ethanol_absolute": 12}) + + +@pytest.fixture +async def journal(settings) -> SagaJournal: + journal = SagaJournal(settings.labvoice_db_path) + await journal.connect() + yield journal + await journal.close() + + +@pytest.fixture +def protocol(client, resolver_stub, journal, settings) -> ProtocolWorkflow: + return ProtocolWorkflow( + client=client, resolver=resolver_stub, journal=journal, settings=settings + ) + + +@pytest.fixture +def inventory(client, resolver_stub, journal, settings) -> InventoryWorkflow: + return InventoryWorkflow( + client=client, resolver=resolver_stub, journal=journal, settings=settings + ) + + +@pytest.fixture +def setup(client, resolver_stub, settings) -> SetupWorkflow: + return SetupWorkflow(client=client, resolver=resolver_stub, settings=settings) + + +@pytest.fixture +def templates_service(client, settings) -> TemplateService: + return TemplateService(client=client, settings=settings) + + +@pytest.fixture +async def real_resolver(settings): + """Real ResourceResolver over a temp DB — resolver/mapping-store tests only.""" + resolver = ResourceResolver(settings) + if hasattr(resolver, "connect"): + await resolver.connect() + yield resolver + if hasattr(resolver, "close"): + await resolver.close() + + +@pytest.fixture +def service_container(client, resolver_stub, journal, settings, templates_service) -> dict: + """Fake ``build_services`` container (keys per scaffold comment).""" + return { + "client": client, + "resolver": resolver_stub, + "journal": journal, + "protocol": ProtocolWorkflow( + client=client, resolver=resolver_stub, journal=journal, settings=settings + ), + "inventory": InventoryWorkflow( + client=client, resolver=resolver_stub, journal=journal, settings=settings + ), + "setup": SetupWorkflow(client=client, resolver=resolver_stub, settings=settings), + "templates": templates_service, + } + + +@pytest.fixture +def patch_build_services(monkeypatch, service_container): + """Intercept ``build_services`` wherever a transport layer imports it.""" + + def _patch(): + import mcp_server.rest as rest_module + import mcp_server.server as server_module + import mcp_server.tools as tools_module + + for module in (server_module, rest_module, tools_module): + monkeypatch.setattr( + module, + "build_services", + lambda _settings, _container=service_container: _container, + raising=False, + ) + return service_container + + return _patch diff --git a/tests/fakes.py b/tests/fakes.py new file mode 100644 index 0000000..f2b9162 --- /dev/null +++ b/tests/fakes.py @@ -0,0 +1,505 @@ +"""Test doubles shared across the suite. + +Three fakes live here, each at a different seam: + +* :class:`FakeElabftwClient` duck-types the ``ElabftwClient`` adapter interface. + It is a stateful in-memory eLabFTW instance used by workflow/service tests, + so saga behaviour can be asserted against real state changes. +* :class:`StubResolver` duck-types ``ResourceResolver`` with a plain dict of + mappings, keeping workflow tests independent of the SQLite mapping store. +* :func:`stub_elabapi` installs fake ``elabapi_python`` API classes into the + ``mcp_server.elabftw`` module namespace. Convention under test: the adapter + resolves vendored API classes as module globals of ``mcp_server.elabftw`` + (``from elabapi_python import ExperimentsApi`` ...) and instantiates them + with an api_client. If the implementation wires this differently, only the + injection point in these stubs needs to move. + +Scenario builders (``make_experiment``, ``make_item`` ...) produce the standard +fixtures referenced throughout the tests. +""" + +from __future__ import annotations + +from dataclasses import dataclass, field + +from mcp_server.errors import ClarificationNeededError, NotFoundError, PermissionDeniedError +from mcp_server.models import ( + AllocationPolicy, + MappingEntry, + MappingProposal, +) +from mcp_server.schemas import ( + ContainerLink, + ElabftwComment, + ElabftwExperiment, + ElabftwInfo, + ElabftwItem, + ElabftwStep, + ElabftwTemplate, + StorageUnit, +) + + +# --------------------------------------------------------------------------- +# Annotation snippets (the labvoice:v1 format from planning §4) +# --------------------------------------------------------------------------- + +ANNOTATION_ETHANOL_FIFO = ( + "" +) + + +# --------------------------------------------------------------------------- +# Fake eLabFTW state (adapter-level) +# --------------------------------------------------------------------------- + + +@dataclass +class FakeStep: + id: int + body: str + finished: bool = False + ordering: int | None = None + + +@dataclass +class FakeComment: + id: int + body: str + created_at: str | None = None + + +@dataclass +class FakeContainer: + sub_id: int + qty_stored: float + unit: str + + +@dataclass +class FakeItem: + id: int + title: str + body: str = "" + extra_fields: dict = field(default_factory=dict) + containers: list[FakeContainer] = field(default_factory=list) + + +@dataclass +class FakeExperiment: + id: int + title: str + status: str = "running" + steps: list[FakeStep] = field(default_factory=list) + comments: list[FakeComment] = field(default_factory=list) + linked_items: list[int] = field(default_factory=list) + + +@dataclass +class FakeTemplate: + id: int + title: str + description: str = "" + tags: list[str] = field(default_factory=list) + steps: list[FakeStep] = field(default_factory=list) + + +def make_template(**overrides) -> FakeTemplate: + """Standard template: two plain steps, description with two paragraphs.""" + tpl = FakeTemplate( + id=7, + title="PCR cleanup", + description="Purify an amplicon after PCR.\n\nLonger protocol notes follow here.", + tags=["dna", "cleanup"], + steps=[ + FakeStep(id=41, body="Add binding buffer", ordering=1), + FakeStep(id=42, body="Elute", ordering=2), + ], + ) + for key, value in overrides.items(): + setattr(tpl, key, value) + return tpl + + +def make_experiment(**overrides) -> FakeExperiment: + """Standard experiment: step 9 (annotated) and step 10 (plain), both unfinished.""" + exp = FakeExperiment( + id=123, + title="Plasmid prep", + steps=[ + FakeStep( + id=9, + body=f"Add ethanol to the tube\n{ANNOTATION_ETHANOL_FIFO}", + ordering=1, + ), + FakeStep(id=10, body="Incubate 30 min", ordering=2), + ], + linked_items=[12], + ) + for key, value in overrides.items(): + setattr(exp, key, value) + return exp + + +def make_item(**overrides) -> FakeItem: + """Standard resource: ethanol with the marker comment and two containers.""" + item = FakeItem( + id=12, + title="Absolute Ethanol", + body="

Absolutely ethanol.

\n", + containers=[ + FakeContainer(sub_id=31, qty_stored=50.0, unit="mL"), + FakeContainer(sub_id=32, qty_stored=10.0, unit="mL"), + ], + ) + for key, value in overrides.items(): + setattr(item, key, value) + return item + + +class FakeElabftwClient: + """In-memory stand-in for the async eLabFTW adapter. + + Mirrors the ``ElabftwClient`` method surface. All mutations are recorded + in ``self.calls`` as ``(method_name, kwargs)`` tuples so tests can assert + exactly what changed (and that nothing changed when a workflow must abort). + ``read_only=True`` makes every mutating method raise + ``PermissionDeniedError`` like a canwrite=false API key would. + """ + + def __init__( + self, + *, + experiments: list[FakeExperiment] | None = None, + items: list[FakeItem] | None = None, + templates: list[FakeTemplate] | None = None, + storage_units: list[StorageUnit] | None = None, + read_only: bool = False, + ) -> None: + self.experiments = {e.id: e for e in (experiments or [])} + self.items = {i.id: i for i in (items or [])} + self.templates = {t.id: t for t in (templates or [])} + self.storage_units = storage_units or [ + StorageUnit(id=1, label="Bench fridge / Shelf 2") + ] + self.read_only = read_only + self.calls: list[tuple[str, dict]] = [] + self._next_comment_id = 500 + self._next_experiment_id = 1000 + + # -- call recording ---------------------------------------------------- + + def _record(self, method: str, **kwargs) -> None: + self.calls.append((method, kwargs)) + + def calls_of(self, method: str) -> list[dict]: + return [kwargs for name, kwargs in self.calls if name == method] + + def _deny_if_read_only(self) -> None: + if self.read_only: + raise PermissionDeniedError( + "The API key cannot modify eLabFTW; ask an admin for a writable key." + ) + + # -- reads --------------------------------------------------------------- + + async def get_info(self) -> ElabftwInfo: + self._record("get_info") + return ElabftwInfo(elabftw_version="5.0.0", api_version="2") + + async def search_experiments(self, *, q=None, tags=None, limit=15, offset=0): + self._record("search_experiments", q=q, tags=tags, limit=limit, offset=offset) + hits = list(self.experiments.values()) + if q: + hits = [e for e in hits if q.lower() in e.title.lower()] + if tags: + hits = [e for e in hits if any(t in tags for t in getattr(e, "tags", []))] + return [ + ElabftwExperiment(id=e.id, title=e.title, status=e.status) + for e in hits[offset : offset + limit] + ] + + async def get_experiment(self, experiment_id: int) -> ElabftwExperiment: + self._record("get_experiment", experiment_id=experiment_id) + exp = self._entity("experiments", experiment_id) + return ElabftwExperiment(id=exp.id, title=exp.title, status=exp.status) + + async def create_experiment(self, template_id: int, title=None): + self._record("create_experiment", template_id=template_id, title=title) + self._deny_if_read_only() + if template_id not in self.templates: + raise NotFoundError(f"Template {template_id} not found.") + tpl = self.templates[template_id] + new_id = self._next_experiment_id + self._next_experiment_id += 1 + exp = FakeExperiment( + id=new_id, + title=title or tpl.title, + steps=[ + FakeStep(id=s.id, body=s.body, ordering=s.ordering) for s in tpl.steps + ], + ) + self.experiments[new_id] = exp + return ElabftwExperiment(id=exp.id, title=exp.title, status=exp.status) + + async def get_steps(self, entity_type, entity_id): + self._record("get_steps", entity_type=entity_type, entity_id=entity_id) + steps = self._entity(entity_type, entity_id).steps + return [ + ElabftwStep(id=s.id, body=s.body, finished=s.finished, ordering=s.ordering) + for s in steps + ] + + async def finish_step(self, entity_type, entity_id, step_id): + self._record( + "finish_step", entity_type=entity_type, entity_id=entity_id, step_id=step_id + ) + self._deny_if_read_only() + for step in self._entity(entity_type, entity_id).steps: + if step.id == step_id: + if step.finished: + return ElabftwStep( + id=step.id, body=step.body, finished=True, ordering=step.ordering + ) + step.finished = True + return ElabftwStep( + id=step.id, body=step.body, finished=True, ordering=step.ordering + ) + raise NotFoundError(f"Step {step_id} not found on {entity_type} {entity_id}.") + + async def list_comments(self, entity_type, entity_id): + self._record("list_comments", entity_type=entity_type, entity_id=entity_id) + return [ + ElabftwComment(id=c.id, body=c.body, created_at=c.created_at) + for c in self._entity(entity_type, entity_id).comments + ] + + async def post_comment(self, entity_type, entity_id, body): + self._record( + "post_comment", entity_type=entity_type, entity_id=entity_id, body=body + ) + self._deny_if_read_only() + comment = FakeComment(id=self._next_comment_id, body=body) + self._next_comment_id += 1 + self._entity(entity_type, entity_id).comments.append(comment) + return ElabftwComment(id=comment.id, body=comment.body, created_at=None) + + async def search_items(self, *, q=None, limit=15, offset=0): + self._record("search_items", q=q, limit=limit, offset=offset) + hits = list(self.items.values()) + if q: + hits = [i for i in hits if q.lower() in i.title.lower()] + return [self._item_model(i) for i in hits[offset : offset + limit]] + + async def get_item(self, item_id: int) -> ElabftwItem: + self._record("get_item", item_id=item_id) + return self._item_model(self._entity("items", item_id)) + + async def get_containers(self, entity_type, entity_id): + self._record("get_containers", entity_type=entity_type, entity_id=entity_id) + item = self._entity("items", entity_id) + return [ + ContainerLink(id=c.sub_id, qty_stored=c.qty_stored, unit=c.unit) + for c in item.containers + ] + + async def set_container_quantity(self, entity_type, entity_id, subitem_id, qty_stored): + self._record( + "set_container_quantity", + entity_type=entity_type, + entity_id=entity_id, + subitem_id=subitem_id, + qty_stored=qty_stored, + ) + self._deny_if_read_only() + for container in self._entity("items", entity_id).containers: + if container.sub_id == subitem_id: + container.qty_stored = qty_stored + return + raise NotFoundError(f"Container {subitem_id} not found on item {entity_id}.") + + async def list_storage_units(self): + self._record("list_storage_units") + return list(self.storage_units) + + async def list_templates(self, *, q=None, limit=25, offset=0): + self._record("list_templates", q=q, limit=limit, offset=offset) + hits = list(self.templates.values()) + if q: + hits = [t for t in hits if q.lower() in t.title.lower()] + return [ + ElabftwTemplate(id=t.id, title=t.title, description=t.description, tags=t.tags) + for t in hits[offset : offset + limit] + ] + + async def get_template(self, template_id: int) -> ElabftwTemplate: + self._record("get_template", template_id=template_id) + if template_id not in self.templates: + raise NotFoundError(f"Template {template_id} not found.") + t = self.templates[template_id] + return ElabftwTemplate(id=t.id, title=t.title, description=t.description, tags=t.tags) + + # -- helpers ------------------------------------------------------------- + + def _entity(self, entity_type, entity_id): + if entity_type == "experiments": + if entity_id not in self.experiments: + raise NotFoundError(f"Experiment {entity_id} not found.") + return self.experiments[entity_id] + if entity_id not in self.items: + raise NotFoundError(f"Item {entity_id} not found.") + return self.items[entity_id] + + def _item_model(self, item: FakeItem) -> ElabftwItem: + return ElabftwItem( + id=item.id, + title=item.title, + body=item.body, + **{"extra_fields": item.extra_fields} if item.extra_fields else {}, + ) + + +# --------------------------------------------------------------------------- +# Stub resolver (resolver-level) +# --------------------------------------------------------------------------- + + +class StubResolver: + """Dict-backed ``ResourceResolver`` stand-in for workflow tests.""" + + def __init__( + self, + mappings: dict[str, int] | None = None, + *, + fail_on: set[str] | None = None, + options_by_key: dict[str, list[str]] | None = None, + ) -> None: + self.mappings = dict(mappings or {}) + self.fail_on = fail_on or set() + self.options_by_key = options_by_key or {} + self.resolved: list[str] = [] + + async def resolve(self, resource_key: str) -> int: + self.resolved.append(resource_key) + if resource_key in self.fail_on or resource_key not in self.mappings: + raise ClarificationNeededError( + f"I don't know which resource '{resource_key}' refers to.", + options=self.options_by_key.get(resource_key, []), + ) + return self.mappings[resource_key] + + async def find_candidates(self, resource_key: str) -> list[MappingProposal]: + return [ + MappingProposal(resource_key=resource_key, item_id=item_id) + for item_id in sorted(self.mappings.values()) + ] + + async def upsert_mapping(self, resource_key: str, item_id: int) -> MappingEntry: + self.mappings[resource_key] = item_id + return MappingEntry(resource_key=resource_key, item_id=item_id) + + async def list_mappings(self) -> list[MappingEntry]: + return [ + MappingEntry(resource_key=k, item_id=v) + for k, v in sorted(self.mappings.items()) + ] + + +# --------------------------------------------------------------------------- +# elabapi_python stubs (client construction seam, adapter tests only) +# --------------------------------------------------------------------------- + + +class StubElabapi: + """Fake vendored elabapi_python client hub. + + Each generated ``*Api`` class is replaced by a thin proxy that forwards + every method call to :meth:`handle`, which consults routes registered by + the test. Unrouted calls fail loudly, so adapter tests only ever pass + against the endpoints they explicitly define. + """ + + API_CLASSES = ( + "InfoApi", + "InstanceApi", + "ExperimentsApi", + "ExperimentsTemplatesApi", + "StepsApi", + "CommentsApi", + "ItemsApi", + "ContainersApi", + "StorageUnitsApi", + "LinksToItemsApi", + "UnfinishedStepsApi", + "TodolistApi", + ) + + def __init__(self) -> None: + self.routes: dict[tuple[str, str], object] = {} + self.calls: list[tuple[str, str, dict]] = [] + self.thread_ids: list[tuple[str, int]] = [] + + def route(self, api: str, method: str, handler) -> None: + self.routes[(api, method)] = handler + + async def handle(self, api: str, method: str, args: tuple, kwargs: dict): + self.calls.append((api, method, kwargs)) + self.thread_ids.append((f"{api}.{method}", __import__("threading").get_ident())) + if (api, method) not in self.routes and (api, "*") not in self.routes: + raise AssertionError(f"Unexpected elabapi call: {api}.{method}{args}{kwargs}") + handler = self.routes.get((api, method)) or self.routes[(api, "*")] + return handler(*args, **kwargs) + + +def make_stub_elabapi_cls(hub: StubElabapi, api_name: str): + class _ApiProxy: + def __init__(self, api_client=None, *args, **kwargs): + self.api_client = api_client + + def __getattr__(self, method: str): + async def _call(*args, **kwargs): + return await hub.handle(api_name, method, args, kwargs) + + _call.__name__ = method + return _call + + _ApiProxy.__name__ = f"Stub{api_name}" + return _ApiProxy + + +def stub_elabapi(monkeypatch, hub: StubElabapi) -> StubElabapi: + """Patch elabapi API classes (and Configuration/ApiClient) into mcp_server.elabftw.""" + import elabapi_python.rest as elabapi_rest + import mcp_server.elabftw as elabftw_module + + for api_name in hub.API_CLASSES: + monkeypatch.setattr( + elabftw_module, + api_name, + make_stub_elabapi_cls(hub, api_name), + raising=False, + ) + + class _StubConfiguration: + def __init__(self, host=None, api_key=None, username=None, password=None, **kw): + self.host = host + self.api_key = api_key + self.username = username + self.password = password + + class _StubApiClient: + def __init__(self, configuration=None, **kw): + self.configuration = configuration + + def set_default_header(self, name, value): + pass + + monkeypatch.setattr(elabftw_module, "Configuration", _StubConfiguration, raising=False) + monkeypatch.setattr(elabftw_module, "ApiClient", _StubApiClient, raising=False) + monkeypatch.setattr( + elabftw_module, "ApiException", elabapi_rest.ApiException, raising=False + ) + return hub diff --git a/tests/test_allocate.py b/tests/test_allocate.py new file mode 100644 index 0000000..417a805 --- /dev/null +++ b/tests/test_allocate.py @@ -0,0 +1,176 @@ +"""allocate.py — unit whitelist/conversion + allocation policies (plan §4, §7). + +Tested conversion pairs per the plan: mL↔L and the mass chain μg↔mg↔g↔kg; +anything outside the whitelist or across dimensions must be a clarification, +never a guess. +""" + +import pytest + +from mcp_server.allocate import are_compatible, choose_containers, convert +from mcp_server.errors import ClarificationNeededError, InsufficientStockError +from mcp_server.models import AllocationPolicy, ContainerStock + + +def stock(cid: int, available: float, unit: str = "mL") -> ContainerStock: + return ContainerStock(container_id=cid, amount=f"{available} {unit}", available=available, unit=unit) + + +# --- unit compatibility ----------------------------------------------------- + + +@pytest.mark.parametrize( + ("a", "b"), + [("mL", "L"), ("L", "mL"), ("mg", "g"), ("g", "kg"), ("μg", "mg"), ("ea", "ea")], +) +def test_compatible_within_dimension(a, b): + assert are_compatible(a, b) + + +@pytest.mark.parametrize( + ("a", "b"), + [("mL", "mg"), ("L", "ea"), ("ea", "mL"), ("g", "μL")], +) +def test_incompatible_across_dimensions(a, b): + assert not are_compatible(a, b) + + +@pytest.mark.parametrize("unit", ["fl-oz", "cups", "", "mmol"]) +def test_unknown_units_are_never_compatible(unit): + assert not are_compatible(unit, "mL") + assert not are_compatible("mL", unit) + + +# --- conversion ------------------------------------------------------------- + + +def test_volume_conversions(): + assert convert(1.0, "L", "mL") == pytest.approx(1000.0) + assert convert(500.0, "mL", "L") == pytest.approx(0.5) + + +def test_mass_conversions(): + assert convert(1.0, "g", "mg") == pytest.approx(1000.0) + assert convert(1.0, "kg", "g") == pytest.approx(1000.0) + assert convert(1000.0, "mg", "g") == pytest.approx(1.0) + assert convert(1000.0, "μg", "mg") == pytest.approx(1.0) + + +def test_count_is_identity(): + assert convert(3.0, "ea", "ea") == 3.0 + + +def test_cross_dimension_conversion_is_a_clarification(): + with pytest.raises(ClarificationNeededError): + convert(1.0, "mL", "mg") + + +def test_unknown_unit_conversion_is_a_clarification(): + with pytest.raises(ClarificationNeededError): + convert(1.0, "fl-oz", "mL") + + +# --- fifo allocation -------------------------------------------------------- + + +def test_fifo_takes_from_lowest_container_id_with_stock(): + allocations = choose_containers( + [stock(45, 5.0), stock(31, 50.0)], required=2.0, unit="mL", policy=AllocationPolicy.FIFO + ) + assert len(allocations) == 1 + assert allocations[0].container_id == 31 + assert allocations[0].take == pytest.approx(2.0) + assert allocations[0].remaining == "48.0 mL" + + +def test_fifo_splits_across_containers_when_first_is_short(): + allocations = choose_containers( + [stock(31, 1.5), stock(32, 10.0)], required=2.0, unit="mL", policy=AllocationPolicy.FIFO + ) + assert [a.container_id for a in allocations] == [31, 32] + assert allocations[0].take == pytest.approx(1.5) + assert allocations[1].take == pytest.approx(0.5) + assert allocations[1].remaining == "9.5 mL" + + +def test_fifo_skips_empty_containers(): + allocations = choose_containers( + [stock(31, 0.0), stock(32, 10.0)], required=2.0, unit="mL", policy=AllocationPolicy.FIFO + ) + assert [a.container_id for a in allocations] == [32] + + +def test_fifo_exact_fit_leaves_container_empty(): + allocations = choose_containers( + [stock(31, 2.0)], required=2.0, unit="mL", policy=AllocationPolicy.FIFO + ) + assert allocations[0].remaining == "0.0 mL" + + +def test_insufficient_stock_raises_with_shortfall(): + with pytest.raises(InsufficientStockError) as excinfo: + choose_containers( + [stock(31, 1.0), stock(32, 0.5)], required=2.0, unit="mL", policy=AllocationPolicy.FIFO + ) + message = str(excinfo.value) + assert "0.5" in message # 1.5 available vs 2.0 required → 0.5 short + + +def test_insufficient_stock_with_no_containers_at_all(): + with pytest.raises(InsufficientStockError): + choose_containers([], required=2.0, unit="mL", policy=AllocationPolicy.FIFO) + + +# --- unit conversion during allocation -------------------------------------- + + +def test_allocation_converts_between_compatible_units(): + """Required 0.5 L against a container stocked in mL.""" + allocations = choose_containers( + [stock(31, 1000.0, "mL")], required=0.5, unit="L", policy=AllocationPolicy.FIFO + ) + assert allocations[0].take == pytest.approx(500.0) + assert allocations[0].remaining == "500.0 mL" + + +def test_allocation_rejects_incompatible_container_units(): + containers = [stock(31, 10.0, "mg")] + with pytest.raises(ClarificationNeededError): + choose_containers(containers, required=2.0, unit="mL", policy=AllocationPolicy.FIFO) + + +# --- specific allocation ---------------------------------------------------- + + +def test_specific_takes_only_from_the_listed_container(): + """The caller pre-filters to the hinted container (consumable.container_id).""" + allocations = choose_containers( + [stock(32, 10.0)], required=2.0, unit="mL", policy=AllocationPolicy.SPECIFIC + ) + assert [a.container_id for a in allocations] == [32] + + +def test_specific_with_unavailable_container_is_a_clarification(): + with pytest.raises(ClarificationNeededError): + choose_containers([], required=2.0, unit="mL", policy=AllocationPolicy.SPECIFIC) + + +# --- nearest expiry (deferred per plan §15.2, kept as executable spec) ------ + + +@pytest.mark.xfail(reason="nearest_expiry deferred per plan §15.2; expiry_field config pending") +def test_nearest_expiry_picks_soonest_expiry_first(): + soon = ContainerStock.model_construct( + container_id=44, amount="5 mL", available=5.0, unit="mL", expires="2026-01-01" + ) + later = ContainerStock.model_construct( + container_id=31, amount="5 mL", available=5.0, unit="mL", expires="2027-01-01" + ) + allocations = choose_containers( + [later, soon], + required=2.0, + unit="mL", + policy=AllocationPolicy.NEAREST_EXPIRY, + expiry_field="Expiry date", + ) + assert allocations[0].container_id == 44 diff --git a/tests/test_annotate.py b/tests/test_annotate.py new file mode 100644 index 0000000..f0423a4 --- /dev/null +++ b/tests/test_annotate.py @@ -0,0 +1,159 @@ +"""annotate.py — labvoice:v1 parser rules (plan §4, §13).""" + +import json + +import pytest + +from mcp_server.annotate import extract_annotation_block, parse_annotation, validate_annotation +from mcp_server.errors import AnnotationError +from mcp_server.models import AllocationPolicy + + +def valid_block(consumables: list[dict], **extra) -> str: + payload = {"consumables": consumables, **extra} + return f"" + + +ETHANOL = { + "resource_key": "ethanol_absolute", + "quantity": 2.0, + "unit": "mL", + "allocation": "fifo", +} + + +# --- extraction ------------------------------------------------------------- + + +def test_extract_returns_block_when_present(): + body = f"Add ethanol to the tube\n{valid_block([ETHANOL])}" + block = extract_annotation_block(body) + assert block is not None + assert "labvoice:v1" in block + assert "ethanol_absolute" in block + + +def test_extract_returns_none_when_no_annotation(): + assert extract_annotation_block("Just a normal step.") is None + assert extract_annotation_block("") is None + + +def test_extract_ignores_other_html_comments(): + body = "Step text\n\nmore text" + assert extract_annotation_block(body) is None + + +def test_extract_takes_the_last_valid_block(): + first = valid_block([{**ETHANOL, "quantity": 1.0}]) + second = valid_block([{**ETHANOL, "quantity": 2.0}]) + body = f"Step text\n{first}\n{second}" + block = extract_annotation_block(body) + assert json.loads(block.split("labvoice:v1")[1].rsplit("-->")[0])["consumables"][0][ + "quantity" + ] == 2.0 + + +def test_extract_tolerates_multiline_and_whitespace(): + body = "text\n" + assert extract_annotation_block(body) is not None + + +# --- parsing ---------------------------------------------------------------- + + +def test_parse_valid_annotation(): + body = f"Add ethanol\n{valid_block([ETHANOL])}" + annotation = parse_annotation(body) + assert annotation is not None + assert len(annotation.consumables) == 1 + consumable = annotation.consumables[0] + assert consumable.resource_key == "ethanol_absolute" + assert consumable.quantity == 2.0 + assert consumable.unit == "mL" + assert consumable.allocation is AllocationPolicy.FIFO + assert annotation.prompt_quantity is False + + +def test_parse_returns_none_without_annotation(): + assert parse_annotation("Plain step body.") is None + + +def test_parse_defaults_allocation_to_fifo(): + body = f"x\n{valid_block([{k: ETHANOL[k] for k in ('resource_key', 'quantity', 'unit')}])}" + annotation = parse_annotation(body) + assert annotation.consumables[0].allocation is AllocationPolicy.FIFO + + +def test_parse_prompt_quantity_annotation(): + body = f"x\n{valid_block([{'resource_key': 'buffer', 'quantity': None, 'unit': 'mL'}], prompt_quantity=True)}" + annotation = parse_annotation(body) + assert annotation.prompt_quantity is True + assert annotation.consumables[0].quantity is None + + +def test_parse_malformed_json_raises_annotation_error(): + body = "text\n" + with pytest.raises(AnnotationError): + parse_annotation(body) + + +def test_parse_schema_violation_missing_required_field(): + body = f"x\n{valid_block([{'resource_key': 'ethanol_absolute', 'unit': 'mL'}])}" + with pytest.raises(AnnotationError): + parse_annotation(body) + + +def test_parse_schema_violation_unknown_allocation(): + body = f"x\n{valid_block([{**ETHANOL, 'allocation': 'magical'}])}" + with pytest.raises(AnnotationError): + parse_annotation(body) + + +def test_parse_schema_violation_negative_quantity(): + body = f"x\n{valid_block([{**ETHANOL, 'quantity': -2.0}])}" + with pytest.raises(AnnotationError): + parse_annotation(body) + + +def test_parse_schema_violation_null_quantity_requires_prompt_quantity(): + body = f"x\n{valid_block([{'resource_key': 'buffer', 'quantity': None, 'unit': 'mL'}])}" + with pytest.raises(AnnotationError): + parse_annotation(body) + + +def test_parse_schema_violation_container_id_outside_specific(): + body = f"x\n{valid_block([{**ETHANOL, 'container_id': 31}])}" + with pytest.raises(AnnotationError): + parse_annotation(body) + + +def test_parse_allows_container_id_with_specific_allocation(): + body = f"x\n{valid_block([{**ETHANOL, 'allocation': 'specific', 'container_id': 31}])}" + annotation = parse_annotation(body) + assert annotation.consumables[0].container_id == 31 + + +# --- validation ------------------------------------------------------------- + + +def test_validate_clean_annotation_returns_no_violations(): + body = f"Add ethanol\n{valid_block([ETHANOL])}" + assert validate_annotation(body) == [] + + +def test_validate_body_without_annotation_has_nothing_to_check(): + assert validate_annotation("No annotations here.") == [] + + +def test_validate_malformed_annotation_reports_violation(): + body = "text\n" + issues = validate_annotation(body) + assert issues, "malformed annotation must be reported, never silently ignored" + assert any("json" in issue.lower() or "parse" in issue.lower() for issue in issues) + + +def test_validate_missing_required_field_is_reported(): + body = f"x\n{valid_block([{'resource_key': 'ethanol_absolute'}])}" + issues = validate_annotation(body) + assert issues + assert any("unit" in issue.lower() or "quantity" in issue.lower() for issue in issues) diff --git a/tests/test_config.py b/tests/test_config.py new file mode 100644 index 0000000..f521d49 --- /dev/null +++ b/tests/test_config.py @@ -0,0 +1,50 @@ +"""config.py — env-driven settings (plan §11).""" + +from pathlib import Path + +from mcp_server.config import Settings, get_settings + + +def test_defaults(): + settings = Settings(_env_file=None) + assert settings.elabftw_timeout == 10.0 + assert settings.elabftw_retries == 2 + assert settings.labvoice_db_path == Path("~/.labvoice/journal.sqlite") + assert settings.labvoice_template_desc_limit == 200 + assert settings.labvoice_rest_token is None + assert settings.labvoice_embed_model is None + + +def test_default_unit_whitelist_matches_plan(): + settings = Settings(_env_file=None) + assert "μL" in settings.unit_whitelist + assert "mL" in settings.unit_whitelist + assert "ea" in settings.unit_whitelist + + +def test_unit_whitelist_parsing_ignores_blanks_and_spaces(): + settings = Settings(_env_file=None, labvoice_unit_whitelist=" mL , L , , ea ") + assert settings.unit_whitelist == ("mL", "L", "ea") + + +def test_api_base_url_strips_trailing_slash(): + settings = Settings(_env_file=None, elabftw_url="https://eln.example.org/") + assert settings.api_base_url == "https://eln.example.org/api/v2" + + +def test_env_overrides(monkeypatch): + monkeypatch.setenv("ELABFTW_URL", "https://eln2.example.org") + monkeypatch.setenv("ELABFTW_TIMEOUT", "3.5") + monkeypatch.setenv("LABVOICE_DB_PATH", "/tmp/other.sqlite") + settings = Settings(_env_file=None) + assert settings.elabftw_url == "https://eln2.example.org" + assert settings.elabftw_timeout == 3.5 + assert settings.labvoice_db_path == Path("/tmp/other.sqlite") + + +def test_get_settings_is_cached(monkeypatch): + monkeypatch.setenv("ELABFTW_URL", "https://a.example.org") + first = get_settings() + monkeypatch.setenv("ELABFTW_URL", "https://b.example.org") + assert get_settings() is first + get_settings.cache_clear() diff --git a/tests/test_elabftw_adapter.py b/tests/test_elabftw_adapter.py new file mode 100644 index 0000000..dee31bb --- /dev/null +++ b/tests/test_elabftw_adapter.py @@ -0,0 +1,138 @@ +"""elabftw.py — async adapter over vendored elabapi_python (plan §3, §12). + +Error normalization: ApiException status → typed error; network failures → +api_error; the API key must never leak into messages. Sync client calls run +off the event loop. + +Convention under test: the adapter resolves vendored API classes as module +globals of ``mcp_server.elabftw`` and instantiates them with an api_client; +tests stub those globals (see tests/fakes.stub_elabapi). Routes use the +``"*"`` wildcard method so the suite doesn't pin the generated method names. +""" + +import threading + +import pytest +from elabapi_python.rest import ApiException + +from fakes import StubElabapi, stub_elabapi +from mcp_server.errors import ApiError, AuthError, NotFoundError, PermissionDeniedError +from mcp_server.elabftw import ElabftwClient + + +@pytest.fixture +def hub() -> StubElabapi: + return StubElabapi() + + +@pytest.fixture +def adapter(settings, hub, monkeypatch) -> ElabftwClient: + stub_elabapi(monkeypatch, hub) + return ElabftwClient(settings) + + +INFO_PAYLOAD = {"elabftw_version": "5.0.0", "api": "2"} +EXPERIMENT_PAYLOAD = {"id": 123, "title": "Plasmid prep"} + + +async def test_get_info_returns_schema(adapter, hub): + hub.route("InfoApi", "*", lambda **kw: INFO_PAYLOAD) + info = await adapter.get_info() + assert info.elabftw_version == "5.0.0" + + +async def test_get_experiment_maps_payload(adapter, hub): + hub.route("ExperimentsApi", "*", lambda **kw: EXPERIMENT_PAYLOAD) + experiment = await adapter.get_experiment(123) + assert experiment.id == 123 + assert experiment.title == "Plasmid prep" + + +@pytest.mark.parametrize( + ("status", "expected"), + [(401, AuthError), (403, PermissionDeniedError), (404, NotFoundError), (500, ApiError)], +) +async def test_http_status_normalization(adapter, hub, status, expected): + def boom(**kw): + raise ApiException(status=status, reason="boom") + + hub.route("ExperimentsApi", "*", boom) + with pytest.raises(expected): + await adapter.get_experiment(123) + + +async def test_network_failure_becomes_api_error(adapter, hub): + def boom(**kw): + raise OSError("connection refused") + + hub.route("ExperimentsApi", "*", boom) + with pytest.raises(ApiError): + await adapter.get_experiment(123) + + +@pytest.mark.parametrize("status", [401, 403, 404, 500]) +async def test_api_key_never_leaks_into_error_messages(settings, hub, monkeypatch, status): + stub_elabapi(monkeypatch, hub) + + def boom(**kw): + raise ApiException( + status=status, reason="boom", body="key=labvoice-secret-key-do-not-leak" + ) + + hub.route("ExperimentsApi", "*", boom) + client = ElabftwClient(settings) + with pytest.raises(Exception) as excinfo: + await client.get_experiment(123) + assert "labvoice-secret-key-do-not-leak" not in str(excinfo.value) + assert "labvoice-secret-key-do-not-leak" not in repr(excinfo.value) + + +async def test_sync_calls_run_off_the_event_loop(adapter, hub): + main_thread = threading.get_ident() + + def whoami(**kw): + assert threading.get_ident() != main_thread + return EXPERIMENT_PAYLOAD + + hub.route("ExperimentsApi", "*", whoami) + await adapter.get_experiment(123) + + +async def test_steps_endpoint_returns_steps_schema(adapter, hub): + hub.route( + "StepsApi", + "*", + lambda **kw: [{"id": 9, "body": "Add ethanol", "finished": False, "ordering": 1}], + ) + steps = await adapter.get_steps("experiments", 123) + assert steps[0].id == 9 + + +async def test_containers_endpoint_returns_container_links(adapter, hub): + hub.route( + "ContainersApi", + "*", + lambda **kw: [{"id": 31, "qty_stored": 50.0, "unit": "mL"}], + ) + containers = await adapter.get_containers("items", 12) + assert containers[0].id == 31 + assert containers[0].qty_stored == 50.0 + + +async def test_search_normalizes_pagination(adapter, hub): + seen = {} + + def capture(**kwargs): + seen.update(kwargs) + return [EXPERIMENT_PAYLOAD] + + hub.route("ExperimentsApi", "*", capture) + results = await adapter.search_experiments(q="plasmid", limit=5, offset=10) + assert results[0].id == 123 + assert seen, "search must reach the client" + assert "q" in str(seen) or "query" in str(seen) + + +async def test_client_keeps_settings(settings): + client = ElabftwClient(settings) + assert client.settings is settings diff --git a/tests/test_errors.py b/tests/test_errors.py new file mode 100644 index 0000000..c5c3aa7 --- /dev/null +++ b/tests/test_errors.py @@ -0,0 +1,64 @@ +"""errors.py — typed errors with voice-friendly messages (plan §12).""" + +from mcp_server.errors import ( + AnnotationError, + ApiError, + AuthError, + ClarificationNeededError, + ErrorKind, + InsufficientStockError, + LabVoiceError, + NotFoundError, + PermissionDeniedError, +) + + +def test_every_error_kind_maps_to_its_class(): + assert AuthError.kind is ErrorKind.AUTH + assert PermissionDeniedError.kind is ErrorKind.PERMISSION + assert NotFoundError.kind is ErrorKind.NOT_FOUND + assert ApiError.kind is ErrorKind.API + assert AnnotationError.kind is ErrorKind.ANNOTATION + assert ClarificationNeededError.kind is ErrorKind.CLARIFICATION + assert InsufficientStockError.kind is ErrorKind.INSUFFICIENT_STOCK + assert LabVoiceError.kind is ErrorKind.API + + +def test_kind_values_are_the_wire_strings(): + assert ErrorKind.AUTH == "auth_error" + assert ErrorKind.PERMISSION == "permission_error" + assert ErrorKind.NOT_FOUND == "not_found" + assert ErrorKind.CLARIFICATION == "clarification" + assert ErrorKind.INSUFFICIENT_STOCK == "insufficient_stock" + + +def test_message_and_detail_are_preserved(): + err = NotFoundError("Experiment 123 not found.", detail="GET /experiments/123") + assert str(err) == "Experiment 123 not found." + assert err.message == "Experiment 123 not found." + assert err.detail == "GET /experiments/123" + + +def test_all_labvoice_errors_share_the_base(): + for cls in ( + AuthError, + PermissionDeniedError, + NotFoundError, + ApiError, + AnnotationError, + ClarificationNeededError, + InsufficientStockError, + ): + assert issubclass(cls, LabVoiceError) + + +def test_clarification_options_default_empty_and_are_preserved(): + err = ClarificationNeededError("Which ethanol?") + assert err.options == [] + err = ClarificationNeededError("Which ethanol?", options=["Absolute Ethanol", "96%"]) + assert err.options == ["Absolute Ethanol", "96%"] + + +def test_error_messages_are_voice_friendly_strings(): + err = PermissionDeniedError("This API key is read-only; I can't finish the step.") + assert isinstance(err.message, str) and err.message diff --git a/tests/test_journal.py b/tests/test_journal.py new file mode 100644 index 0000000..7db439a --- /dev/null +++ b/tests/test_journal.py @@ -0,0 +1,135 @@ +"""journal.py — SQLite saga journal: idempotency, statuses, durability (plan §10).""" + +import pytest + +from mcp_server.journal import ActionStatus, OperationStatus, SagaJournal + + +@pytest.fixture +async def fresh_journal(tmp_path): + journal = SagaJournal(tmp_path / "saga.sqlite") + await journal.connect() + yield journal + await journal.close() + + +async def test_connect_is_idempotent_safe_for_new_db(fresh_journal): + record = await fresh_journal.begin_operation("complete_step", "op-1") + assert record.status is OperationStatus.PLANNED + assert record.kind == "complete_step" + assert record.actions == [] + + +async def test_begin_generates_operation_id_when_none_given(fresh_journal): + record = await fresh_journal.begin_operation("complete_step") + assert record.operation_id + + +async def test_record_and_mark_actions(fresh_journal): + await fresh_journal.begin_operation("complete_step", "op-1") + action = await fresh_journal.record_action( + "op-1", "decrement_container", {"item_id": 12, "subitem_id": 31, "qty_stored": 48.0} + ) + assert action.status is ActionStatus.PLANNED + assert action.payload["subitem_id"] == 31 + + marked = await fresh_journal.mark_action( + "op-1", action.id, ActionStatus.DONE, response={"ok": True} + ) + assert marked.status is ActionStatus.DONE + assert marked.response == {"ok": True} + + +async def test_get_operation_returns_actions_in_order(fresh_journal): + await fresh_journal.begin_operation("complete_step", "op-1") + first = await fresh_journal.record_action("op-1", "decrement_container", {"subitem_id": 31}) + second = await fresh_journal.record_action("op-1", "finish_step", {"step_id": 9}) + third = await fresh_journal.record_action("op-1", "post_comment", {"body": "done"}) + + record = await fresh_journal.get_operation("op-1") + assert [a.id for a in record.actions] == [first.id, second.id, third.id] + assert [a.action for a in record.actions] == [ + "decrement_container", + "finish_step", + "post_comment", + ] + + +async def test_has_completed_only_after_finish(fresh_journal): + await fresh_journal.begin_operation("complete_step", "op-1") + action = await fresh_journal.record_action("op-1", "decrement_container", {}) + await fresh_journal.mark_action("op-1", action.id, ActionStatus.DONE) + assert await fresh_journal.has_completed("op-1") is False + + await fresh_journal.finish_operation("op-1", OperationStatus.COMPLETED) + assert await fresh_journal.has_completed("op-1") is True + + +async def test_begin_with_completed_operation_id_is_idempotent_replay(fresh_journal): + """Plan §13: double execution of the same operation_id is idempotent.""" + await fresh_journal.begin_operation("complete_step", "op-1") + await fresh_journal.record_action("op-1", "decrement_container", {"subitem_id": 31}) + await fresh_journal.finish_operation("op-1", OperationStatus.COMPLETED) + + replayed = await fresh_journal.begin_operation("complete_step", "op-1") + assert replayed.status is OperationStatus.COMPLETED + assert len(replayed.actions) == 1 + record = await fresh_journal.get_operation("op-1") + assert len(record.actions) == 1, "replay must not append new actions" + + +async def test_begin_with_inprogress_operation_id_resumes_it(fresh_journal): + await fresh_journal.begin_operation("complete_step", "op-1") + await fresh_journal.record_action("op-1", "decrement_container", {"subitem_id": 31}) + + resumed = await fresh_journal.begin_operation("complete_step", "op-1") + assert resumed.status is OperationStatus.PLANNED + assert len(resumed.actions) == 1 + + +async def test_failed_and_compensated_statuses_persist(fresh_journal): + await fresh_journal.begin_operation("complete_step", "op-1") + action = await fresh_journal.record_action("op-1", "finish_step", {"step_id": 9}) + await fresh_journal.mark_action("op-1", action.id, ActionStatus.FAILED) + await fresh_journal.finish_operation("op-1", OperationStatus.COMPENSATED) + + record = await fresh_journal.get_operation("op-1") + assert record.status is OperationStatus.COMPENSATED + assert record.actions[0].status is ActionStatus.FAILED + assert await fresh_journal.has_completed("op-1") is False + + +async def test_partial_failure_status_roundtrip(fresh_journal): + """Plan §10: compensation failure ⇒ partial_failure in the journal.""" + await fresh_journal.begin_operation("complete_step", "op-1") + await fresh_journal.finish_operation("op-1", OperationStatus.PARTIAL_FAILURE) + record = await fresh_journal.get_operation("op-1") + assert record.status is OperationStatus.PARTIAL_FAILURE + + +async def test_journal_persists_across_reconnect(tmp_path): + """The journal doubles as the audit log — it must survive restarts.""" + path = tmp_path / "saga.sqlite" + journal = SagaJournal(path) + await journal.connect() + await journal.begin_operation("complete_step", "op-1") + action = await journal.record_action("op-1", "decrement_container", {"subitem_id": 31}) + await journal.mark_action("op-1", action.id, ActionStatus.DONE, response={"qty": 48.0}) + await journal.finish_operation("op-1", OperationStatus.COMPLETED) + await journal.close() + + reopened = SagaJournal(path) + await reopened.connect() + try: + record = await reopened.get_operation("op-1") + assert record.kind == "complete_step" + assert record.status is OperationStatus.COMPLETED + assert record.actions[0].response == {"qty": 48.0} + assert await reopened.has_completed("op-1") is True + finally: + await reopened.close() + + +async def test_get_operation_of_unknown_id_raises(fresh_journal): + with pytest.raises(Exception): + await fresh_journal.get_operation("nope") diff --git a/tests/test_models.py b/tests/test_models.py new file mode 100644 index 0000000..ff5293e --- /dev/null +++ b/tests/test_models.py @@ -0,0 +1,72 @@ +"""models.py — compact result shapes (plan §6: ids, titles, quantities, statuses).""" + +import pytest +from pydantic import ValidationError + +from mcp_server.models import ( + AllocationPolicy, + CompleteStepResult, + Consumable, + HandoffContext, + NextStep, + ProtocolAnnotation, + StepInfo, +) + + +def test_consumable_defaults_to_fifo_and_required(): + consumable = Consumable(resource_key="ethanol_absolute", quantity=2.0, unit="mL") + assert consumable.allocation is AllocationPolicy.FIFO + assert consumable.optional is False + assert consumable.container_id is None + + +def test_consumable_quantity_may_be_null_for_prompted_steps(): + consumable = Consumable(resource_key="x", quantity=None, unit="mL") + assert consumable.quantity is None + + +def test_consumable_rejects_missing_required_fields(): + with pytest.raises(ValidationError): + Consumable(resource_key="x") # quantity and unit missing + + +def test_annotation_defaults(): + annotation = ProtocolAnnotation() + assert annotation.consumables == [] + assert annotation.prompt_quantity is False + + +def test_step_info_defaults_unfinished(): + step = StepInfo(id=9, body="Add ethanol") + assert step.finished is False + assert step.position is None + + +def test_complete_step_result_status_is_restricted(): + for status in ("completed", "protocol_complete", "reverted", "partial_failure"): + CompleteStepResult( + experiment_id=123, + status=status, + step=StepInfo(id=9, body="b"), + ) + with pytest.raises(ValidationError): + CompleteStepResult( + experiment_id=123, + status="exploded", + step=StepInfo(id=9, body="b"), + ) + + +def test_next_step_carries_consumables_and_stock(): + next_step = NextStep(experiment_id=123, step=StepInfo(id=9, body="Add ethanol")) + assert next_step.consumables == [] + assert next_step.stock == [] + + +def test_handoff_context_is_id_only_and_rest_optional(): + """Plan §8: the app forwards only ids; device/location are optional extras.""" + handoff = HandoffContext(experiment_id=123, user_id=2) + assert handoff.step_id is None + assert handoff.device_id is None + assert handoff.location_id is None diff --git a/tests/test_resolve.py b/tests/test_resolve.py new file mode 100644 index 0000000..e681b22 --- /dev/null +++ b/tests/test_resolve.py @@ -0,0 +1,89 @@ +"""resolve.py — resource_key → item id precedence and ambiguity (plan §5). + +Precedence: local mapping store (authoritative at execution) → resource marker +→ (setup-time-only matchers/title, never silently applied at runtime). +Ambiguous or missing ⇒ ClarificationNeededError listing candidates. +""" + +import pytest + +from fakes import make_item +from mcp_server.errors import ClarificationNeededError + + +async def test_resolve_via_marker_when_store_is_empty(client, real_resolver): + """Marker comment in the resource body is discovered without any mapping.""" + assert await real_resolver.resolve("ethanol_absolute") == 12 + + +async def test_mapping_store_is_authoritative_over_marker(client, real_resolver): + await real_resolver.upsert_mapping("ethanol_absolute", 12) + # Even if another item also carries the marker, the store binding wins. + client.items[13] = make_item(id=13, title="Ethanol bottle (old)", body="") + assert await real_resolver.resolve("ethanol_absolute") == 12 + + +async def test_resolve_unknown_key_raises_clarification(client, real_resolver): + with pytest.raises(ClarificationNeededError) as excinfo: + await real_resolver.resolve("sodium_azide") + assert "sodium_azide" in str(excinfo.value) + + +async def test_resolve_ambiguous_marker_raises_clarification_with_candidates(client, real_resolver): + client.items[13] = make_item(id=13, title="Ethanol bottle 2", body="") + with pytest.raises(ClarificationNeededError) as excinfo: + await real_resolver.resolve("ethanol_absolute") + assert excinfo.value.options, "clarification must list candidate resources" + + +async def test_upsert_mapping_is_idempotent(client, real_resolver): + await real_resolver.upsert_mapping("ethanol_absolute", 12) + await real_resolver.upsert_mapping("ethanol_absolute", 12) + mappings = await real_resolver.list_mappings() + assert [m.item_id for m in mappings if m.resource_key == "ethanol_absolute"] == [12] + + +async def test_upsert_mapping_updates_existing_binding(client, real_resolver): + await real_resolver.upsert_mapping("ethanol_absolute", 12) + await real_resolver.upsert_mapping("ethanol_absolute", 99) + assert await real_resolver.resolve("ethanol_absolute") == 99 + + +async def test_list_mappings_empty_store(real_resolver): + assert await real_resolver.list_mappings() == [] + + +async def test_export_mapping_produces_portable_json(client, real_resolver): + await real_resolver.upsert_mapping("ethanol_absolute", 12) + data = await real_resolver.export_mapping() + assert "ethanol_absolute" in data + entry = data["ethanol_absolute"] + assert entry.get("title") in (None, "Absolute Ethanol") + + +async def test_import_mapping_returns_proposals(client, real_resolver): + data = {"ethanol_absolute": {"cas": "64-17-5", "title": "Absolute Ethanol", "unit": "mL"}} + proposals = await real_resolver.import_mapping(data) + assert proposals + assert proposals[0].resource_key == "ethanol_absolute" + + +async def test_find_candidates_finds_marker_match(client, real_resolver): + proposals = await real_resolver.find_candidates("ethanol_absolute") + assert any(p.item_id == 12 for p in proposals) + + +async def test_find_candidates_finds_exact_title_match(client, real_resolver): + """Exact title match is a setup-time suggestion only — proposals carry scores.""" + client.items[14] = make_item(id=14, title="sodium_azide", body="") + proposals = await real_resolver.find_candidates("sodium_azide") + assert any(p.item_id == 14 for p in proposals) + proposal = next(p for p in proposals if p.item_id == 14) + assert proposal.score is not None + + +async def test_exact_title_never_applies_silently_at_runtime(client, real_resolver): + """An exact title match alone must not create a runtime binding (plan §5.4).""" + client.items[14] = make_item(id=14, title="sodium_azide", body="") + with pytest.raises(ClarificationNeededError): + await real_resolver.resolve("sodium_azide") diff --git a/tests/test_rest_api.py b/tests/test_rest_api.py new file mode 100644 index 0000000..a106c8a --- /dev/null +++ b/tests/test_rest_api.py @@ -0,0 +1,184 @@ +"""rest.py — read-only REST mirror for the mobile app (plan §8, §13). + +Bearer-token protected, mutations never exposed, same compact shapes and typed +errors as the MCP tools. Tests use Starlette's TestClient (ASGI, no network). + +Convention under test: the app resolves its read services via +``mcp_server.server.build_services`` — monkeypatched here (see conftest). +""" + +import pytest +from fastapi import FastAPI +from starlette.testclient import TestClient + +from mcp_server.errors import LabVoiceError + +TOKEN = "app-bearer-token-123" +AUTH = {"Authorization": f"Bearer {TOKEN}"} + + +@pytest.fixture +def rest_settings(settings): + settings.labvoice_rest_token = TOKEN + return settings + + +@pytest.fixture +def rest_app(rest_settings, patch_build_services) -> FastAPI: + patch_build_services() + from mcp_server.rest import create_rest_app + + return create_rest_app(rest_settings) + + +@pytest.fixture +def api(rest_app) -> TestClient: + return TestClient(rest_app) + + +# --- auth -------------------------------------------------------------------- + + +def test_missing_token_is_rejected(api): + assert api.get("/api/experiments").status_code == 401 + assert api.get("/api/experiments/123/state").status_code == 401 + assert api.get("/api/experiments/123/next-step").status_code == 401 + assert api.get("/api/templates").status_code == 401 + + +def test_wrong_token_is_rejected(api): + response = api.get("/api/experiments", headers={"Authorization": "Bearer nope"}) + assert response.status_code == 401 + + +def test_correct_token_passes(api): + response = api.get("/api/experiments", headers=AUTH) + assert response.status_code == 200 + + +def test_rest_app_requires_token_configured(settings, patch_build_services): + patch_build_services() + from mcp_server.rest import create_rest_app + + settings.labvoice_rest_token = None + with pytest.raises(Exception) as excinfo: + create_rest_app(settings) + assert not isinstance(excinfo.value, NotImplementedError) + + +# --- endpoints ---------------------------------------------------------------- + + +def test_find_experiments_returns_compact_summaries(api): + response = api.get("/api/experiments", params={"q": "plasmid"}, headers=AUTH) + assert response.status_code == 200 + payload = response.json() + assert isinstance(payload, list) and payload + summary = payload[0] + assert summary["id"] == 123 + assert summary["title"] == "Plasmid prep" + + +def test_next_step_is_the_hot_path(api): + """Plan §8: GET /api/experiments/{id}/next-step returns the parsed step + stock.""" + response = api.get("/api/experiments/123/next-step", headers=AUTH) + assert response.status_code == 200 + payload = response.json() + assert payload["experiment_id"] == 123 + assert payload["step"]["id"] == 9 + assert payload["step"]["finished"] is False + assert payload["consumables"][0]["resource_key"] == "ethanol_absolute" + assert payload["consumables"][0]["quantity"] == 2.0 + assert payload["stock"][0]["container_id"] == 31 + assert payload["stock"][0]["available"] == 50.0 + + +def test_next_step_null_when_protocol_complete(api, client): + for step in client.experiments[123].steps: + step.finished = True + response = api.get("/api/experiments/123/next-step", headers=AUTH) + assert response.status_code == 200 + assert response.json() is None + + +def test_state_snapshot_shape(api): + """Plan §8: `state` is what the app renders: title, steps, stock, next step.""" + response = api.get("/api/experiments/123/state", headers=AUTH) + assert response.status_code == 200 + state = response.json() + assert state["experiment_id"] == 123 + assert state["title"] == "Plasmid prep" + assert state["unfinished_steps"] == [9, 10] + next_step = state["next_step"] + assert set(next_step) == {"experiment_id", "step", "consumables", "stock"} + assert next_step["step"]["id"] == 9 + assert len(next_step["consumables"]) == 1 + assert {c["container_id"] for c in next_step["stock"]} == {31, 32} + + +def test_state_of_unknown_experiment_is_typed_error(api): + response = api.get("/api/experiments/9999/state", headers=AUTH) + assert response.status_code == 404 + payload = response.json() + assert payload["error"] == "not_found" + assert "message" in payload + + +def test_templates_endpoint_lists_summaries(api, client): + from fakes import make_template + + client.templates[7] = make_template() + response = api.get("/api/templates", headers=AUTH) + assert response.status_code == 200 + templates = response.json() + summary = templates[0] + assert summary["id"] == 7 + assert summary["title"] == "PCR cleanup" + assert "short_description" in summary + assert summary["tags"] == ["dna", "cleanup"] + + +def test_templates_search_ranks(api, client): + from fakes import make_template + + client.templates[7] = make_template() + response = api.get("/api/templates", params={"q": "pcr"}, headers=AUTH) + assert response.status_code == 200 + assert response.json()[0]["id"] == 7 + + +# --- mutations are never exposed ---------------------------------------------- + + +def test_no_mutation_routes_exist(rest_app): + """Plan §8: mutations exist only as MCP tools so every mutation is journaled.""" + paths = rest_app.openapi().get("paths", {}) + assert paths, "REST app must document its endpoints" + for path, operations in paths.items(): + for method in operations: + assert method.lower() == "get", f"{method.upper()} {path} must not exist" + + +# --- unit-level helpers -------------------------------------------------------- + + +def test_error_payload_shape(): + from mcp_server.rest import error_payload + + assert error_payload("clarification", "Which ethanol?") == { + "error": "clarification", + "message": "Which ethanol?", + } + + +def test_verify_token_accepts_configured_token(rest_settings): + from mcp_server.rest import verify_token + + assert verify_token(TOKEN) is None + + +def test_verify_token_rejects_wrong_token(rest_settings): + from mcp_server.rest import verify_token + + with pytest.raises(LabVoiceError): + verify_token("wrong") diff --git a/tests/test_safety.py b/tests/test_safety.py new file mode 100644 index 0000000..02c74df --- /dev/null +++ b/tests/test_safety.py @@ -0,0 +1,97 @@ +"""Safety checks as tests (plan §13). + +* a read-only API key must fail cleanly on every mutating tool +* failed workflows leave no partial state (no comment, no finished step) +* the API key never appears in any tool result +""" + +import json + +import pytest +from mcp.client import Client + +from fakes import make_template +from mcp_server.tools import register_tools + +TOKEN_SAFE_MESSAGE = "labvoice-secret-key-do-not-leak" + +MUTATING_TOOLS = { + "complete_next_protocol_step": {"experiment_id": 123}, + "complete_protocol_step": {"experiment_id": 123, "step_id": 9}, + "record_protocol_observation": {"experiment_id": 123, "comment": "note"}, + "create_experiment_from_template": {"template_id": 7}, + "adjust_inventory": {"amount": 5.0, "unit": "mL", "container_id": 31}, +} + + +@pytest.fixture +async def mcp_client(patch_build_services, client): + from mcp.server.fastmcp import FastMCP + + patch_build_services() + client.templates[7] = make_template() + mcp = FastMCP("labvoice-safety") + register_tools(mcp) + async with Client(mcp, raise_exceptions=False) as c: + yield c + + +def _state_fingerprint(client): + experiment = client.experiments[123] + return { + "steps": [(s.id, s.finished) for s in experiment.steps], + "comments": [c.body for c in experiment.comments], + "containers": [ + (i.id, c.sub_id, c.qty_stored) + for i in client.items.values() + for c in i.containers + ], + } + + +@pytest.mark.parametrize("tool", sorted(MUTATING_TOOLS)) +async def test_read_only_key_fails_cleanly_on_every_mutating_tool( + mcp_client, client, tool +): + """Plan §13: read-only key ⇒ every mutation fails with a clear message.""" + client.read_only = True + before = _state_fingerprint(client) + + result = await mcp_client.call_tool(tool, MUTATING_TOOLS[tool]) + payload = None + structured = getattr(result, "structured_content", None) + texts = " ".join(getattr(b, "text", "") for b in getattr(result, "content", [])) + if structured is not None: + payload = structured + assert getattr(result, "is_error", False) or ( + payload is not None and payload.get("ok") is False + ) or "permission" in texts.lower() or "read-only" in texts.lower(), ( + f"{tool} must not silently succeed with a read-only key" + ) + + assert _state_fingerprint(client) == before, f"{tool} must not mutate anything" + + +async def test_aborted_workflow_leaves_no_partial_state(mcp_client, client, resolver_stub): + """Unresolvable resource ⇒ no finished step, no comment, no stock change.""" + resolver_stub.mappings.clear() + before = _state_fingerprint(client) + + result = await mcp_client.call_tool( + "complete_next_protocol_step", {"experiment_id": 123} + ) + texts = " ".join(getattr(b, "text", "") for b in getattr(result, "content", [])) + assert result.is_error or "clarification" in texts.lower() or "not know" in texts.lower() + + assert _state_fingerprint(client) == before + + +async def test_error_results_never_contain_the_api_key(mcp_client, client, resolver_stub): + client.read_only = True + resolver_stub.mappings.clear() + for tool, args in MUTATING_TOOLS.items(): + result = await mcp_client.call_tool(tool, dict(args)) + texts = " ".join(getattr(b, "text", "") for b in getattr(result, "content", [])) + structured = getattr(result, "structured_content", None) + blob = texts + json.dumps(structured, default=str) + assert TOKEN_SAFE_MESSAGE not in blob diff --git a/tests/test_templates.py b/tests/test_templates.py new file mode 100644 index 0000000..fafd2a8 --- /dev/null +++ b/tests/test_templates.py @@ -0,0 +1,132 @@ +"""templates.py — template search/ranking and creation flow (plan §9, §13).""" + +import pytest + +from fakes import FakeElabftwClient, FakeTemplate, make_template +from mcp_server.errors import NotFoundError + +def ranking_client() -> FakeElabftwClient: + return FakeElabftwClient( + templates=[ + FakeTemplate(id=1, title="Cell culture", description="Maintain adherent lines."), + FakeTemplate( + id=2, + title="Protein extraction", + description="Lyse cells; collect supernatant in pcr tubes.", + ), + FakeTemplate(id=3, title="Ethanol precipitation", description="Precipitate DNA.", tags=["pcr"]), + FakeTemplate(id=4, title="PCR cleanup", description="Purify an amplicon."), + ] + ) + + +# --- short description ------------------------------------------------------ + + +async def test_short_description_is_first_paragraph(templates_service, client): + client.templates[7] = make_template() + result = await templates_service.list_templates() + assert result[0].short_description == "Purify an amplicon after PCR." + + +async def test_short_description_truncated_to_limit(templates_service, settings, client): + settings.labvoice_template_desc_limit = 20 + client.templates[7] = make_template( + description="P" * 100 + "\n\nSecond paragraph that must not appear." + ) + result = await templates_service.list_templates() + summary = result[0] + assert len(summary.short_description) <= 20 + assert "Second paragraph" not in summary.short_description + + +async def test_short_description_empty_when_no_description(templates_service, client): + client.templates[7] = make_template(description="") + result = await templates_service.list_templates() + assert result[0].short_description == "" + + +async def test_summary_carries_id_title_tags(templates_service, client): + client.templates[7] = make_template() + result = await templates_service.list_templates() + summary = result[0] + assert summary.id == 7 + assert summary.title == "PCR cleanup" + assert summary.tags == ["dna", "cleanup"] + + +# --- ranking ---------------------------------------------------------------- + + +async def test_no_query_preserves_listing_order(templates_service, client): + client.templates.update({t.id: t for t in ranking_client().templates.values()}) + result = await templates_service.list_templates() + assert [t.id for t in result] == [1, 2, 3, 4] + + +async def test_title_match_ranks_above_tag_and_description_match(templates_service, client): + client.templates.update({t.id: t for t in ranking_client().templates.values()}) + result = await templates_service.list_templates(query="pcr") + ids = [t.id for t in result] + assert ids.index(4) < ids.index(3) < ids.index(2), ( + "expected title(4) > tags(3) > description(2) per plan §9 weights" + ) + + +async def test_non_matching_templates_rank_below_matches(templates_service, client): + client.templates.update({t.id: t for t in ranking_client().templates.values()}) + result = await templates_service.list_templates(query="pcr") + assert result[-1].id == 1 + + +async def test_limit_is_respected(templates_service, client): + client.templates.update({t.id: t for t in ranking_client().templates.values()}) + result = await templates_service.list_templates(query="pcr", limit=2) + assert len(result) == 2 + assert result[0].id == 4 + + +# --- creation ---------------------------------------------------------------- + + +async def test_create_from_template_returns_experiment_and_first_step(templates_service, client): + client.templates[7] = make_template() + result = await templates_service.create_experiment_from_template(7) + assert result.ok is True + assert result.experiment_id == 1000 + assert result.title == "PCR cleanup" + assert result.first_step is not None + assert result.first_step.id == 41 + assert result.first_step.finished is False + + +async def test_create_with_explicit_title(templates_service, client): + client.templates[7] = make_template() + result = await templates_service.create_experiment_from_template(7, title="My amplicon run") + assert result.title == "My amplicon run" + + +async def test_created_experiment_copies_template_steps_and_annotations( + templates_service, client +): + """eLabFTW copies template steps — annotations must come along (plan §9).""" + from fakes import ANNOTATION_ETHANOL_FIFO, FakeStep + + client.templates[7] = make_template( + steps=[FakeStep(id=41, body=f"Add ethanol\n{ANNOTATION_ETHANOL_FIFO}", ordering=1)] + ) + result = await templates_service.create_experiment_from_template(7) + created = client.experiments[result.experiment_id] + assert "labvoice:v1" in created.steps[0].body + + +async def test_create_from_unknown_template_fails_cleanly(templates_service, client): + with pytest.raises((NotFoundError, KeyError)): + await templates_service.create_experiment_from_template(9999) + + +async def test_search_index_build_is_optional(templates_service, client): + """Lexical fallback works without an explicitly built index (plan §9 fallback).""" + client.templates.update({t.id: t for t in ranking_client().templates.values()}) + result = await templates_service.list_templates(query="pcr") + assert result[0].id == 4 diff --git a/tests/test_tools_mcp.py b/tests/test_tools_mcp.py new file mode 100644 index 0000000..2615aa1 --- /dev/null +++ b/tests/test_tools_mcp.py @@ -0,0 +1,169 @@ +"""tools.py + MCP surface — small-model-friendly tool schemas (plan §6, §13). + +Checks the tool *surface* (names, short descriptions, small input schemas) +over the real FastMCP server using the in-process client, plus a golden +result for the headline workflow. + +Note: the plan's "ten tools" are the reads + aggregates; the scaffold adds +four admin/setup tools (scan/map/export/import), so the registered surface +is fourteen functions. +""" + +import json + +import pytest +from mcp.client import Client + +from mcp_server.tools import TOOL_FUNCTIONS, register_tools + +EXPECTED_TOOLS = { + "find_experiments", + "get_experiment_context", + "get_next_protocol_step", + "list_experiment_templates", + "validate_protocol_template", + "complete_next_protocol_step", + "complete_protocol_step", + "record_protocol_observation", + "create_experiment_from_template", + "adjust_inventory", + "scan_instance", + "map_resource", + "export_mapping", + "import_mapping", +} + + +def result_json(call_result): + """Extract the JSON payload from a CallToolResult (structured or text).""" + structured = getattr(call_result, "structured_content", None) + if structured is not None: + return structured + for block in call_result.content: + text = getattr(block, "text", None) + if text: + return json.loads(text) + raise AssertionError(f"No usable content in tool result: {call_result!r}") + + +@pytest.fixture +async def mcp_server(patch_build_services): + from mcp.server.fastmcp import FastMCP + + patch_build_services() + mcp = FastMCP("labvoice-test") + register_tools(mcp) + return mcp + + +@pytest.fixture +async def mcp_client(mcp_server): + async with Client(mcp_server, raise_exceptions=True) as client: + yield client + + +# --- tool surface ------------------------------------------------------------ + + +async def test_all_tools_registered_and_listed(mcp_client): + tools = await mcp_client.list_tools() + names = {t.name for t in tools} + assert names == EXPECTED_TOOLS + assert len(TOOL_FUNCTIONS) == len(EXPECTED_TOOLS) + + +async def test_every_tool_has_a_short_description(mcp_client): + """Plan §6: tool descriptions are one or two short sentences.""" + for tool in await mcp_client.list_tools(): + assert tool.description, f"{tool.name} needs a description" + assert len(tool.description) <= 300, f"{tool.name} description too long for a small model" + + +async def test_input_schemas_are_small(mcp_client): + """Plan §13 lint: small input schemas — no kitchen-sink parameter lists.""" + for tool in await mcp_client.list_tools(): + properties = tool.inputSchema.get("properties", {}) + assert len(properties) <= 5, f"{tool.name} takes {len(properties)} parameters" + assert tool.inputSchema.get("type") == "object" + + +async def test_input_schemas_match_function_signatures(mcp_client): + import inspect + + for tool in await mcp_client.list_tools(): + fn = next(f for f in TOOL_FUNCTIONS if f.__name__ == tool.name) + params = inspect.signature(fn).parameters + properties = tool.inputSchema.get("properties", {}) + assert set(properties) == set(params), f"{tool.name}: schema/args mismatch" + required = set(tool.inputSchema.get("required", [])) + expected_required = { + name for name, p in params.items() if p.default is inspect.Parameter.empty + } + assert required == expected_required, f"{tool.name}: required set mismatch" + + +async def test_mutating_tools_are_clearly_named(mcp_client): + """A small model must not confuse reads with mutations (plan §2).""" + mutating = { + "complete_next_protocol_step", + "complete_protocol_step", + "record_protocol_observation", + "create_experiment_from_template", + "adjust_inventory", + "map_resource", + "scan_instance", + "import_mapping", + } + tools = {t.name: t for t in await mcp_client.list_tools()} + for name in mutating: + assert name in tools + + +# --- golden workflow result over the MCP transport ----------------------------- + + +async def test_headline_workflow_golden_result_over_mcp(mcp_client, client): + """Plan §13: golden result for complete_next_protocol_step (§7).""" + call_result = await mcp_client.call_tool( + "complete_next_protocol_step", + {"experiment_id": 123, "comment": "Done at the bench"}, + ) + payload = result_json(call_result) + + assert payload["ok"] is True + assert payload["status"] == "completed" + assert payload["experiment_id"] == 123 + assert payload["step"]["id"] == 9 + assert payload["step"]["finished"] is True + assert payload["consumed"][0]["resource_key"] == "ethanol_absolute" + assert payload["consumed"][0]["container_id"] == 31 + assert payload["consumed"][0]["amount"] == "2.0 mL" + assert payload["consumed"][0]["remaining"] == "48.0 mL" + assert payload["next_step"]["id"] == 10 + # stock really moved in eLabFTW + assert client.items[12].containers[0].qty_stored == 48.0 + + +async def test_read_tool_over_mcp_returns_compact_json(mcp_client): + call_result = await mcp_client.call_tool("get_next_protocol_step", {"experiment_id": 123}) + payload = result_json(call_result) + assert payload["step"]["id"] == 9 + assert payload["consumables"][0]["resource_key"] == "ethanol_absolute" + + +async def test_clarification_over_mcp_is_a_typed_error(mcp_client, resolver_stub): + resolver_stub.mappings.clear() + call_result = await mcp_client.call_tool( + "complete_next_protocol_step", {"experiment_id": 123} + ) + payload = result_json(call_result) + # Either the transport surfaces the error or the payload carries it — + # both are acceptable, but it must be the clarification kind either way. + if getattr(call_result, "is_error", False): + text = " ".join(getattr(b, "text", "") for b in call_result.content) + assert "clarification" in text or "ethanol" in text + else: + assert payload.get("error") == "clarification" or payload.get("status") in ( + "clarification", + "reverted", + ) diff --git a/tests/test_workflows_inventory.py b/tests/test_workflows_inventory.py new file mode 100644 index 0000000..c129371 --- /dev/null +++ b/tests/test_workflows_inventory.py @@ -0,0 +1,92 @@ +"""workflows/inventory.py — stock reads + adjust_inventory (plan §6, §10).""" + +import pytest + +from mcp_server.errors import ClarificationNeededError, NotFoundError + + +# --- stock reads ------------------------------------------------------------ + + +async def test_stock_for_resource_lists_containers(inventory): + stock = await inventory.stock_for_resource("ethanol_absolute") + assert [s.container_id for s in stock] == [31, 32] + assert stock[0].available == 50.0 + assert stock[0].unit == "mL" + assert stock[0].amount == "50.0 mL" + + +async def test_stock_for_unknown_resource_raises_clarification(inventory, resolver_stub): + resolver_stub.mappings.clear() + with pytest.raises(ClarificationNeededError): + await inventory.stock_for_resource("unobtainium") + + +# --- adjust_inventory ------------------------------------------------------- + + +async def test_adjust_adds_to_container_by_id(inventory, client): + result = await inventory.adjust_inventory(amount=500.0, unit="mL", container_id=31) + assert result.ok is True + assert result.container_id == 31 + assert result.amount == "500.0 mL" + assert result.remaining == "550.0 mL" + assert client.items[12].containers[0].qty_stored == 550.0 + + +async def test_adjust_supports_correction_negative_delta(inventory, client): + await inventory.adjust_inventory(amount=-2.0, unit="mL", container_id=31) + assert client.items[12].containers[0].qty_stored == 48.0 + + +async def test_adjust_by_resource_key_uses_allocable_container(inventory, client): + result = await inventory.adjust_inventory( + amount=100.0, unit="mL", resource_key="ethanol_absolute" + ) + assert result.resource_key == "ethanol_absolute" + assert result.container_id == 31 + assert result.remaining == "150.0 mL" + + +async def test_adjust_converts_units(inventory, client): + """“Add half a litre” against an mL-stocked container.""" + await inventory.adjust_inventory(amount=0.5, unit="L", container_id=31) + assert client.items[12].containers[0].qty_stored == 550.0 + + +async def test_adjust_rejects_non_whitelisted_unit(inventory): + with pytest.raises(ClarificationNeededError): + await inventory.adjust_inventory(amount=1.0, unit="fl-oz", container_id=31) + + +async def test_adjust_rejects_cross_dimension_unit(inventory): + with pytest.raises(ClarificationNeededError): + await inventory.adjust_inventory(amount=5.0, unit="g", container_id=31) + + +async def test_adjust_unknown_container_fails_cleanly(inventory): + with pytest.raises(NotFoundError): + await inventory.adjust_inventory(amount=1.0, unit="mL", container_id=9999) + + +async def test_adjust_requires_container_or_resource(inventory): + with pytest.raises(ClarificationNeededError): + await inventory.adjust_inventory(amount=1.0, unit="mL") + + +async def test_adjust_is_journaled(inventory, journal): + await inventory.adjust_inventory(amount=500.0, unit="mL", container_id=31) + assert journal.db_path.exists() + + +async def test_adjust_failure_does_not_silently_lose_data(inventory, client, monkeypatch): + """If the write fails, the workflow surfaces the error (journaled saga).""" + from mcp_server.errors import ApiError + + async def fail_write(entity_type, entity_id, subitem_id, qty_stored): + raise ApiError("write refused") + + monkeypatch.setattr(inventory.client, "set_container_quantity", fail_write) + with pytest.raises(ApiError): + await inventory.adjust_inventory(amount=500.0, unit="mL", container_id=31) + assert client.items[12].containers[0].qty_stored == 50.0 diff --git a/tests/test_workflows_protocol.py b/tests/test_workflows_protocol.py new file mode 100644 index 0000000..b89ba80 --- /dev/null +++ b/tests/test_workflows_protocol.py @@ -0,0 +1,338 @@ +"""workflows/protocol.py — the step-completion saga (plan §7, §10). + +Golden path: select next step → parse annotation → resolve keys → allocate → +validate stock → decrement containers → finish step → post comment → verify. +Failure semantics: clarifications abort before any mutation; journal failures +compensate (reverted) or escalate (partial_failure + audit comment). +""" + +import pytest + +from fakes import ANNOTATION_ETHANOL_FIFO, FakeContainer, FakeStep +from mcp_server.errors import ( + ApiError, + ClarificationNeededError, + InsufficientStockError, + NotFoundError, + PermissionDeniedError, +) + + +# --- get_next_step ---------------------------------------------------------- + + +async def test_next_step_is_lowest_ordering_unfinished(protocol): + next_step = await protocol.get_next_step(123) + assert next_step is not None + assert next_step.experiment_id == 123 + assert next_step.step.id == 9 + assert next_step.step.body.startswith("Add ethanol") + + +async def test_next_step_includes_parsed_consumables(protocol): + next_step = await protocol.get_next_step(123) + assert len(next_step.consumables) == 1 + assert next_step.consumables[0].resource_key == "ethanol_absolute" + assert next_step.consumables[0].quantity == 2.0 + + +async def test_next_step_includes_stock_preview(protocol): + next_step = await protocol.get_next_step(123) + assert [s.container_id for s in next_step.stock] == [31, 32] + assert next_step.stock[0].available == 50.0 + assert next_step.stock[0].unit == "mL" + + +async def test_next_step_none_when_protocol_complete(protocol, client): + for step in client.experiments[123].steps: + step.finished = True + assert await protocol.get_next_step(123) is None + + +async def test_next_step_skips_finished_steps(protocol, client): + client.experiments[123].steps[0].finished = True + next_step = await protocol.get_next_step(123) + assert next_step.step.id == 10 + + +async def test_next_step_unknown_experiment_fails_cleanly(protocol): + with pytest.raises(NotFoundError): + await protocol.get_next_step(9999) + + +# --- complete_next_step: golden path ---------------------------------------- + + +async def test_golden_path_completes_step_and_consumes_stock(protocol, client): + result = await protocol.complete_next_step(123, comment="Done at the bench") + + assert result.ok is True + assert result.status == "completed" + assert result.experiment_id == 123 + assert result.step.id == 9 + assert result.step.finished is True + assert result.next_step is not None + assert result.next_step.id == 10 + + # stock decremented (fifo: container 31 first) + assert client.items[12].containers[0].qty_stored == 48.0 + assert client.items[12].containers[1].qty_stored == 10.0 + + # compact consumed record with TTS-ready amounts (plan §6) + assert len(result.consumed) == 1 + consumed = result.consumed[0] + assert consumed.resource_key == "ethanol_absolute" + assert consumed.container_id == 31 + assert consumed.amount == "2.0 mL" + assert consumed.remaining == "48.0 mL" + + # comment posted + assert result.comment_id is not None + comments = client.experiments[123].comments + assert any("Done at the bench" in c.body for c in comments) + + +async def test_step_is_marked_finished_in_elabftw(protocol, client): + await protocol.complete_next_step(123) + assert client.experiments[123].steps[0].finished is True + + +async def test_saga_journals_a_completed_operation(protocol, journal): + await protocol.complete_next_step(123) + # The journal must have recorded a completed operation for this run; the + # audit trail lives in the SQLite file (plan §10). + assert journal.db_path.exists() + assert journal.db_path.stat().st_size > 0 + + +# --- step selection variants ------------------------------------------------ + + +async def test_complete_with_explicit_step_id(protocol, client): + result = await protocol.complete_step(123, 10, comment="redo") + assert result.step.id == 10 + assert result.step.finished is True + assert client.experiments[123].steps[1].finished is True + + +async def test_complete_next_skips_finished_steps(protocol, client): + client.experiments[123].steps[0].finished = True + result = await protocol.complete_next_step(123) + assert result.step.id == 10 + + +# --- no-annotation steps ---------------------------------------------------- + + +async def test_step_without_annotation_completes_and_posts_comment(protocol, client): + """Plan §7.2: no annotation ⇒ complete step + comment, skip inventory.""" + client.experiments[123].steps[0].body = "Plain step, no annotation" + result = await protocol.complete_next_step(123, comment="ok") + assert result.status == "completed" + assert result.consumed == [] + assert result.comment_id is not None + assert client.calls_of("set_container_quantity") == [] + + +# --- clarification before mutation ------------------------------------------ + + +async def test_unresolvable_resource_key_aborts_without_mutation(protocol, client, resolver_stub): + resolver_stub.mappings.clear() + client.experiments[123].steps[0] = FakeStep( + id=9, body=f"Add mystery reagent\n{ANNOTATION_ETHANOL_FIFO}", ordering=1 + ) + with pytest.raises(ClarificationNeededError): + await protocol.complete_next_step(123) + + assert client.calls_of("set_container_quantity") == [] + assert client.calls_of("finish_step") == [] + assert client.calls_of("post_comment") == [] + assert client.experiments[123].steps[0].finished is False + + +async def test_insufficient_stock_aborts_without_mutation(protocol, client): + client.items[12].containers = [FakeContainer(sub_id=31, qty_stored=1.0, unit="mL")] + with pytest.raises(InsufficientStockError) as excinfo: + await protocol.complete_next_step(123) + assert "1.0" in str(excinfo.value) + assert client.calls_of("set_container_quantity") == [] + assert client.calls_of("finish_step") == [] + + +# --- optional consumables --------------------------------------------------- + + +async def test_optional_consumable_missing_stock_is_skipped_with_warning(protocol, client): + """Plan §7.5: optional consumables are skipped with a warning, step completes.""" + annotated = ( + "" + ) + client.experiments[123].steps[0] = FakeStep(id=9, body=f"Mix\n{annotated}", ordering=1) + + result = await protocol.complete_next_step(123) + assert result.status == "completed" + assert [c.resource_key for c in result.consumed] == ["ethanol_absolute"] + + +# --- prompt_quantity -------------------------------------------------------- + + +def _prompt_annotation_body() -> str: + return ( + "" + ) + + +async def test_prompt_quantity_without_quantities_asks_for_clarification(protocol, client): + client.experiments[123].steps[0] = FakeStep( + id=9, body=f"How much did you use?\n{_prompt_annotation_body()}", ordering=1 + ) + with pytest.raises(ClarificationNeededError) as excinfo: + await protocol.complete_next_step(123) + assert excinfo.value.options, "clarification should name the resources needing amounts" + assert client.calls_of("set_container_quantity") == [] + + +async def test_prompt_quantity_with_supplied_quantities_completes(protocol, client): + client.experiments[123].steps[0] = FakeStep( + id=9, body=f"How much did you use?\n{_prompt_annotation_body()}", ordering=1 + ) + result = await protocol.complete_next_step(123, quantities={"ethanol_absolute": 5.0}) + assert result.status == "completed" + assert result.consumed[0].amount == "5.0 mL" + assert client.items[12].containers[0].qty_stored == 45.0 + + +# --- allocation behaviour in the saga --------------------------------------- + + +async def test_fifo_split_across_containers(protocol, client): + client.items[12].containers[0].qty_stored = 1.0 + result = await protocol.complete_next_step(123) + assert [(c.container_id, c.amount) for c in result.consumed] == [ + (31, "1.0 mL"), + (32, "1.0 mL"), + ] + assert client.items[12].containers[0].qty_stored == 0.0 + assert client.items[12].containers[1].qty_stored == 9.0 + + +async def test_specific_allocation_uses_the_hinted_container(protocol, client): + annotated = ( + "" + ) + client.experiments[123].steps[0] = FakeStep(id=9, body=f"x\n{annotated}", ordering=1) + result = await protocol.complete_next_step(123) + assert result.consumed[0].container_id == 32 + assert client.items[12].containers[1].qty_stored == 8.0 + + +async def test_unit_conversion_between_compatible_units(protocol, client): + """Required 0.02 L (= 20 mL) against mL-stocked containers.""" + annotated = ( + "" + ) + client.experiments[123].steps[0] = FakeStep(id=9, body=f"x\n{annotated}", ordering=1) + result = await protocol.complete_next_step(123) + assert client.items[12].containers[0].qty_stored == 30.0 + assert result.consumed[0].amount == "20.0 mL" + + +# --- failure & compensation (plan §10) --------------------------------------- + + +async def test_failure_during_finish_step_returns_reverted_and_restores_stock( + protocol, client, monkeypatch +): + """Plan §10: compensate by restoring decremented quantities, then `reverted`.""" + + async def fail_finish(entity_type, entity_id, step_id): + raise ApiError("eLabFTW is unhappy.") + + monkeypatch.setattr(protocol.client, "finish_step", fail_finish) + + result = await protocol.complete_next_step(123) + + assert result.status == "reverted" + assert client.items[12].containers[0].qty_stored == 50.0 + assert client.experiments[123].steps[0].finished is False + assert client.calls_of("post_comment") == [] + + +async def test_comment_failure_after_finish_compensates_stock(protocol, client, monkeypatch): + async def fail_comment(entity_type, entity_id, body): + raise ApiError("comment refused.") + + monkeypatch.setattr(protocol.client, "post_comment", fail_comment) + + result = await protocol.complete_next_step(123) + assert result.status == "reverted" + assert client.items[12].containers[0].qty_stored == 50.0 + + +async def test_failed_compensation_marks_partial_failure_and_posts_audit_comment( + protocol, client, monkeypatch +): + async def fail_finish(entity_type, entity_id, step_id): + raise ApiError("eLabFTW is unhappy.") + + async def fail_restore(entity_type, entity_id, subitem_id, qty_stored): + raise ApiError("restore also failed.") + + monkeypatch.setattr(protocol.client, "finish_step", fail_finish) + monkeypatch.setattr(protocol.client, "set_container_quantity", fail_restore) + + result = await protocol.complete_next_step(123) + + assert result is not None, "workflow must report partial_failure, not raise" + assert result.status == "partial_failure" + comments = client.experiments[123].comments + assert any("31" in c.body or "ethanol" in c.body.lower() for c in comments), ( + "partial_failure must post an audit comment naming the inconsistent container" + ) + + +# --- protocol_complete edge case (plan §7.1) --------------------------------- + + +async def test_complete_next_with_no_steps_left_returns_protocol_complete(protocol, client): + for step in client.experiments[123].steps: + step.finished = True + result = await protocol.complete_next_step(123) + assert result.status == "protocol_complete" + assert result.consumed == [] + assert client.calls_of("set_container_quantity") == [] + assert client.calls_of("post_comment") == [] + + +# --- guard rails ------------------------------------------------------------- + + +async def test_completing_an_already_finished_explicit_step_errors(protocol, client): + """Plan §13 safety: immutable (already finished) step ⇒ explicit error.""" + client.experiments[123].steps[0].finished = True + with pytest.raises(Exception) as excinfo: + await protocol.complete_step(123, 9) + assert not isinstance(excinfo.value, NotImplementedError), "scaffold not implemented yet" + + +async def test_read_only_key_surfaces_permission_error(protocol, client): + client.read_only = True + with pytest.raises(PermissionDeniedError): + await protocol.complete_next_step(123) diff --git a/tests/test_workflows_setup.py b/tests/test_workflows_setup.py new file mode 100644 index 0000000..c98b35b --- /dev/null +++ b/tests/test_workflows_setup.py @@ -0,0 +1,135 @@ +"""workflows/setup.py — scan_instance, map_resource, validate_protocol_template (plan §5).""" + +import pytest + +from fakes import FakeItem, make_item + + +# --- scan_instance ---------------------------------------------------------- + + +async def test_scan_counts_containers_and_markers(setup, client): + client.items[13] = make_item(id=13, title="Water bottle", body="plain", containers=[]) + result = await setup.scan_instance() + assert result.containers_seen == 2 # containers on item 12 + assert result.markers_found == 1 # marker on item 12 + + +async def test_scan_proposes_marker_matches(setup, client): + result = await setup.scan_instance() + proposal = next(p for p in result.proposals if p.resource_key == "ethanol_absolute") + assert proposal.item_id == 12 + assert proposal.reason is not None + + +async def test_scan_proposes_exact_title_match_as_suggestion(setup, client): + """Exact title matches are setup-time suggestions with scores (plan §5.4).""" + client.items[14] = FakeItem(id=14, title="sodium_azide", body="") + result = await setup.scan_instance() + proposal = next((p for p in result.proposals if p.item_id == 14), None) + assert proposal is not None + assert proposal.resource_key == "sodium_azide" + + +# --- map_resource ----------------------------------------------------------- + + +async def test_map_resource_binds_key(setup, client, resolver_stub): + entry = await setup.map_resource("ethanol_absolute", 12) + assert entry.resource_key == "ethanol_absolute" + assert entry.item_id == 12 + assert resolver_stub.mappings["ethanol_absolute"] == 12 + + +async def test_map_resource_is_idempotent_upsert(setup, resolver_stub): + await setup.map_resource("ethanol_absolute", 12) + await setup.map_resource("ethanol_absolute", 12) + assert resolver_stub.mappings["ethanol_absolute"] == 12 + entries = await resolver_stub.list_mappings() + assert len([e for e in entries if e.resource_key == "ethanol_absolute"]) == 1 + + +async def test_map_resource_rebinding_updates(setup, resolver_stub): + await setup.map_resource("ethanol_absolute", 12) + await setup.map_resource("ethanol_absolute", 13) + assert resolver_stub.mappings["ethanol_absolute"] == 13 + + +# --- validate_protocol_template --------------------------------------------- + + +def _annotated_template_client(): + from fakes import FakeElabftwClient, FakeStep, make_experiment, make_item, make_template + + annotated_step = FakeStep( + id=41, + body=( + "Add ethanol\n" + "" + ), + ordering=1, + ) + broken_step = FakeStep( + id=42, body="Broken\n", ordering=2 + ) + templates = [ + make_template( + id=7, + steps=[annotated_step, broken_step], + ) + ] + return FakeElabftwClient( + templates=templates, experiments=[make_experiment()], items=[make_item()] + ) + + +async def test_validate_flags_unmapped_resource_key(setup, client, resolver_stub): + """Annotation ok, but the mapping store lacks the key → blocking error.""" + client.templates[7] = _annotated_template_client().templates[7] + resolver_stub.mappings.clear() + report = await setup.validate_protocol_template("experiments_templates", 7) + assert report.ok is False + errors = [i for i in report.issues if i.severity == "error"] + assert any(i.resource_key == "ethanol_absolute" for i in errors) + + +async def test_validate_ok_when_annotation_and_mapping_are_fine(setup, client, resolver_stub): + client.templates[7] = _annotated_template_client().templates[7] + report = await setup.validate_protocol_template("experiments_templates", 7) + assert report.ok is False # the broken json step must block + # fix the broken step, then expect a clean report + client.templates[7].steps[1].body = "Clean step without annotation" + report = await setup.validate_protocol_template("experiments_templates", 7) + assert report.ok is True + assert report.issues == [] + + +async def test_validate_reports_annotation_error_with_step_id(setup, client): + client.templates[7] = _annotated_template_client().templates[7] + report = await setup.validate_protocol_template("experiments_templates", 7) + issues = [i for i in report.issues if i.step_id == 42] + assert issues and issues[0].severity == "error" + + +async def test_validate_entity_type_is_mirrored_in_report(setup, client): + client.templates[7] = _annotated_template_client().templates[7] + report = await setup.validate_protocol_template("experiments_templates", 7) + assert report.entity_type == "experiments_templates" + assert report.entity_id == 7 + + +async def test_validate_experiment_steps_too(setup, client, resolver_stub): + """validate works on live experiments, not only templates.""" + resolver_stub.mappings.clear() + report = await setup.validate_protocol_template("experiments", 123) + assert report.entity_type == "experiments" + assert report.ok is False + + +async def test_validate_unknown_entity_fails_cleanly(setup): + with pytest.raises(Exception) as excinfo: + await setup.validate_protocol_template("experiments", 9999) + assert not isinstance(excinfo.value, NotImplementedError) diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..a5c6183 --- /dev/null +++ b/uv.lock @@ -0,0 +1,1563 @@ +version = 1 +revision = 3 +requires-python = ">=3.12" +resolution-markers = [ + "python_full_version >= '3.14'", + "python_full_version == '3.13.*'", + "python_full_version < '3.13'", +] + +[[package]] +name = "aiosqlite" +version = "0.22.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4e/8a/64761f4005f17809769d23e518d915db74e6310474e733e3593cfc854ef1/aiosqlite-0.22.1.tar.gz", hash = "sha256:043e0bd78d32888c0a9ca90fc788b38796843360c855a7262a532813133a0650", size = 14821, upload-time = "2025-12-23T19:25:43.997Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/b7/e3bf5133d697a08128598c8d0abc5e16377b51465a33756de24fa7dee953/aiosqlite-0.22.1-py3-none-any.whl", hash = "sha256:21c002eb13823fad740196c5a2e9d8e62f6243bd9e7e4a1f87fb5e44ecb4fceb", size = 17405, upload-time = "2025-12-23T19:25:42.139Z" }, +] + +[[package]] +name = "annotated-doc" +version = "0.0.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/8e/38aa427ed5402449e226975b649c5dc73ccadfefeb95e6aecb8f8ea4b6b6/annotated_doc-0.0.5.tar.gz", hash = "sha256:c7e58ce09192557605d8bbd92836d7e1d520ac9580096042c0bfd197efacf1bb", size = 10758, upload-time = "2026-07-28T13:50:58.129Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3e/30/e900b21425a860e195f32e37657aa1f7c7f2b1bfb26f03ca209b90933c06/annotated_doc-0.0.5-py3-none-any.whl", hash = "sha256:117bac03a25ede5df5440e855b32d556049ca169ead221505badf432fed4b101", size = 5302, upload-time = "2026-07-28T13:50:57.239Z" }, +] + +[[package]] +name = "annotated-types" +version = "0.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5f/56/a8120250d128bed162cd73c76d45f6ef9991f3e068f62a8ee060afa3104a/annotated_types-0.8.0.tar.gz", hash = "sha256:13b2beaad985e05e2d6407ee4c4f35590b11f8d693a258a561055cac8f64cab7", size = 15893, upload-time = "2026-07-23T20:16:13.995Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/91/8acff4f5e50511b911bbccb72b8628a49c68ce14148cd9f6431094859a90/annotated_types-0.8.0-py3-none-any.whl", hash = "sha256:f072f4d804ea359e4eaf198b1af7a8b0943881a87f31bb764f8bf219bb9419e0", size = 13427, upload-time = "2026-07-23T20:16:12.938Z" }, +] + +[[package]] +name = "anyio" +version = "4.14.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/61/cc/a381afa6efea9f496eff839d4a6a1aed3bfafc7b3ab4b0d1b243a12573dd/anyio-4.14.2.tar.gz", hash = "sha256:cfa139f3ed1a23ee8f88a145ddb5ac7605b8bbfd8592baacd7ce3d8bb4313c7f", size = 260176, upload-time = "2026-07-12T20:29:07.082Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/da/35/f2287558c17e29fafc8ef3daf819bb9834061cfa43bff8014f7df7f63bdc/anyio-4.14.2-py3-none-any.whl", hash = "sha256:9f505dda5ac9f0c8309b5e8bd445a8c2bf7246f3ce950121e45ea15bc41d1494", size = 125813, upload-time = "2026-07-12T20:29:05.763Z" }, +] + +[[package]] +name = "attrs" +version = "26.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" }, +] + +[[package]] +name = "certifi" +version = "2026.7.22" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a3/c2/24167ea9858356b47a87a50d39908bfdb72ceeefe0041586e704e5376b3a/certifi-2026.7.22.tar.gz", hash = "sha256:741e2c3b351ddf169a738da9f2c048608ff7f2c5cc02f1ebc6b118bb090d5d55", size = 138112, upload-time = "2026-07-22T03:35:12.644Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl", hash = "sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775", size = 136983, upload-time = "2026-07-22T03:35:11.276Z" }, +] + +[[package]] +name = "cffi" +version = "2.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9e/ef/008a1939e372c06329a3fce4279c02f328488f3526744906eeec3da7ad5f/cffi-2.1.1.tar.gz", hash = "sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be", size = 530807, upload-time = "2026-08-03T21:21:18.939Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/69/43965eccfdead3b9220015fd1320e117be8c6ed01a62ffab76eeb752f5d5/cffi-2.1.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:c8c69575568085ba0b1b10c0249d779a214aea6f6522e949a0fc9fb0fcb449d0", size = 184821, upload-time = "2026-08-03T21:19:44.887Z" }, + { url = "https://files.pythonhosted.org/packages/54/7d/16e5a096677b5e313ca80cd5e5170efa3ea44624a82bb111925522da64b1/cffi-2.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f81b3b8f3d4e343550fa4baa0e479bba9f2d29ce9c2e9b51d1ce1718d7442fcf", size = 184719, upload-time = "2026-08-03T21:19:46.129Z" }, + { url = "https://files.pythonhosted.org/packages/56/e6/8941622732edec876dd17d0453dce07317ae96db34f2ec1436c9d3785986/cffi-2.1.1-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:811bd1e21d32de12efca32393a0ab3f5133b54fce9bd44b8bd77ab07da14bf6a", size = 214799, upload-time = "2026-08-03T21:19:47.218Z" }, + { url = "https://files.pythonhosted.org/packages/44/de/f98430906df1545ffde0d543dd124a7a439bc2cd32b36b9c53f805df7333/cffi-2.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:68e62fe11f30d5ca8289242866f0a5291402d8529ca2178ab8afc5c9694ae890", size = 222389, upload-time = "2026-08-03T21:19:48.331Z" }, + { url = "https://files.pythonhosted.org/packages/6a/5b/717f1526b9957b34456313c31645c5b82b8fb5c3fe9e4752999be7128bfc/cffi-2.1.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:4a7c934f7360e8cd64fe9efadcbd10c7c6364f531e432b9a4bf5ccbc9e0e8b50", size = 210249, upload-time = "2026-08-03T21:19:49.543Z" }, + { url = "https://files.pythonhosted.org/packages/64/b3/f8aa4f3e34986c7e4ec45072d1b1b9dd295b6b18007b45518d79726dd725/cffi-2.1.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:3143d81e29e1e20a9ce10901ec369012947876596f75a222235965f2b7ae832e", size = 208775, upload-time = "2026-08-03T21:19:50.918Z" }, + { url = "https://files.pythonhosted.org/packages/b1/db/dceb9dd5b231e1da801793f8acc9f3c52a7e1afe40bb1aae37e02b0faad5/cffi-2.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c1453022f490d2459a11819d83ad1d586e9ff65a12ac3e705ffebd46d3685dcf", size = 221822, upload-time = "2026-08-03T21:19:52.054Z" }, + { url = "https://files.pythonhosted.org/packages/a0/d2/6cd24ae3be000a634109c247d1475d62e5616d0dc78c82770942ec384248/cffi-2.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:208f941bb9d18e768138677f0a6d2ce01f590df56043dda1df1535ac57c88517", size = 225232, upload-time = "2026-08-03T21:19:53.109Z" }, + { url = "https://files.pythonhosted.org/packages/cb/52/3fa190537004dd7f0ab860a6dc7c0175b8667f68d1e618a46f5498d30250/cffi-2.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:210019b6c7cf07f081b4c54635c8cf744377001350e29cc0f81c4377b4797735", size = 223597, upload-time = "2026-08-03T21:19:54.515Z" }, + { url = "https://files.pythonhosted.org/packages/80/fb/0bb75b7039588c074b37ae99f40d9bfddf990ecb2fbc346ebccd2e56b9be/cffi-2.1.1-cp312-cp312-win32.whl", hash = "sha256:046bfc24911b37851ee1b51aab8bffe713d89c68c6a057b09484ce9fd5f69b4e", size = 175292, upload-time = "2026-08-03T21:19:55.566Z" }, + { url = "https://files.pythonhosted.org/packages/d9/79/615cc094e2fb508cade7de88d3b4f6c4ec2bab695c97bce9153dc65aadf5/cffi-2.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:f53e442b08449d42821fa4a4fba000095af9f62742a500f978a9f557ec44339a", size = 185919, upload-time = "2026-08-03T21:19:56.89Z" }, + { url = "https://files.pythonhosted.org/packages/70/c6/d0ea84713fe46b243a436a18fcd47d639732747e21635c8a27191b06dc30/cffi-2.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:7bde5e4cc5c10140859842b9d383af292b22639a4dffb725314baf45968cef80", size = 180093, upload-time = "2026-08-03T21:19:58.155Z" }, + { url = "https://files.pythonhosted.org/packages/9d/f4/035513d4117049066b4779dc3b7c0c0fdad175fa13731c9f4003f1cd1478/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:b5bdfd1c873d4e093aabc0ca84c4ca6dbc4f752afb5c86f146d9742580c9da2e", size = 194248, upload-time = "2026-08-03T21:19:59.399Z" }, + { url = "https://files.pythonhosted.org/packages/76/af/2aeb4dbb5fc41a04161ae9ff1518de7cec08e164f44a8ce6a4cf7fd2cd1d/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:31348097ff5bbe827ccc41795d4dd099d9f0625e7def00ee653c137a490c2a6c", size = 196908, upload-time = "2026-08-03T21:20:00.746Z" }, + { url = "https://files.pythonhosted.org/packages/a7/46/2e5fdde8555706dd98139a910ca11be02809f3f605ce956f655d0214e100/cffi-2.1.1-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:9d2055050ea716bd38b7f7f1579c275386646b4894c155a3e2f3cd62ed41b7c6", size = 184805, upload-time = "2026-08-03T21:20:02.02Z" }, + { url = "https://files.pythonhosted.org/packages/55/41/4c7042f317b9217502988f0873af87e16ad606dc20f84e546e3e6ce9764c/cffi-2.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:19ee6127ee34de7d83ce3d371ebc5ed91addbdcc39f9ab15ce4eb35a4e534971", size = 184764, upload-time = "2026-08-03T21:20:03.141Z" }, + { url = "https://files.pythonhosted.org/packages/43/1f/1c3d90d91811c8f86ced9ed637956c54bfe5b79ca98fe976d7f8c8979f6b/cffi-2.1.1-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:6a8dddef476fab96d066d578fc88526767b836ab5ab21754e1d5bf3879c31c7c", size = 214722, upload-time = "2026-08-03T21:20:04.377Z" }, + { url = "https://files.pythonhosted.org/packages/37/6f/3b5ce4c3b2192d250f04908f2bfd91ef34552ec8f7716a5d4abdb8d67bb2/cffi-2.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f16c709686a78c727bbbf059f92b0bf41c6fc60deec706d2dc19f529175a6125", size = 222369, upload-time = "2026-08-03T21:20:05.544Z" }, + { url = "https://files.pythonhosted.org/packages/02/10/4b3c75dde3d9663c9e02ba05c2668b954f671d4bbe346413ca8c696b295a/cffi-2.1.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:fcd22650c908d7b7da162bbfaab594a1227a15d1643a98c68b122ac642fa2264", size = 210175, upload-time = "2026-08-03T21:20:06.75Z" }, + { url = "https://files.pythonhosted.org/packages/df/62/14f74b9543e605d17701dc797b815958b8bb70b7624ce1b832ddad48ed6c/cffi-2.1.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:aa9511c62d14da7aacc9b4bf51f3f697a621e83b2d6919008243c3aad168eea3", size = 208670, upload-time = "2026-08-03T21:20:08.04Z" }, + { url = "https://files.pythonhosted.org/packages/95/95/86342356ff5953b3fb06f7ef7c5bee212d45e770abc7218d451b9148313c/cffi-2.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a931079504ecc49efed7744c476a5c343a92fabf66dec2db95edb1b2fdc770e2", size = 221824, upload-time = "2026-08-03T21:20:09.274Z" }, + { url = "https://files.pythonhosted.org/packages/eb/ff/7b3429ff53aafe931ed8a5fc69f481bbef7ba6de87ddcbb63d08f483f613/cffi-2.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a2d7755bef5a12ed488f4ef1f1b69ee9191d7396083b755a5d2295f6edb4768b", size = 225148, upload-time = "2026-08-03T21:20:10.7Z" }, + { url = "https://files.pythonhosted.org/packages/34/34/a95870b9221e09cf4f2ce3178b1a210abdfe63a1bd357da940418d7b8d15/cffi-2.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e0bcb7e0f677f543555d2adff3bf19c05f66cdb4796e5ff602442ab2fe3c4ef7", size = 223564, upload-time = "2026-08-03T21:20:12.165Z" }, + { url = "https://files.pythonhosted.org/packages/70/ea/839b50531021a647fb5e929f72cf97bc1ff702b5472166164b5b6e76b851/cffi-2.1.1-cp313-cp313-win32.whl", hash = "sha256:334644fbac4eff73d985a17a91226df55d0f394160c4cfb880e084c8f7161cac", size = 175263, upload-time = "2026-08-03T21:20:13.559Z" }, + { url = "https://files.pythonhosted.org/packages/60/a6/8b149b2c3f2e11aaa1618ef64500b45f50f22c57a977a4dff1aff1f91042/cffi-2.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:1aa5645c30469b09530c4ebca77ebf8f17618293c58f8549cb1a543a50236e7d", size = 185688, upload-time = "2026-08-03T21:20:14.69Z" }, + { url = "https://files.pythonhosted.org/packages/01/9a/11f687cb39d6a3504060d5242f04f48c735afb4d3d533958a20594890cb2/cffi-2.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:63bbfd5ded17c4840ac07cd8f1c21ba9d9708141f840b324f422f41b207e3973", size = 180078, upload-time = "2026-08-03T21:20:15.917Z" }, + { url = "https://files.pythonhosted.org/packages/d3/7b/d6bbf82b8b96e7391438898c42f5bd96dd02030fd5b64937d248220003e2/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:7dbb61fe3a7699468030f71bbe5f8a0e326a151daa91beb11a6fc1f980c55e1c", size = 194064, upload-time = "2026-08-03T21:20:17.148Z" }, + { url = "https://files.pythonhosted.org/packages/94/e6/bcc91b283be94735e268487a054004f0aa19947b6348fa367db53230abc8/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:f24fb43132a4c6b4cb4eb029492919b2db645be6808d738f244fd146c03c32cb", size = 196720, upload-time = "2026-08-03T21:20:18.268Z" }, + { url = "https://files.pythonhosted.org/packages/d9/99/c4b0c17cacdc9c3b8f280026286a9826d6a208c0f047591a3c3ce99b91fd/cffi-2.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d28630f5854ab07ab1fd4aba756de52326c82e6be15d414b12793f1975048b54", size = 184964, upload-time = "2026-08-03T21:20:19.708Z" }, + { url = "https://files.pythonhosted.org/packages/b3/a9/9db617d05d7367c1ad0ab00b3aa6e6f9281edd689b4ee9ea0e5a84e89c97/cffi-2.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:661c298b4821edebead0c91edd2b00374d67ad7c5a1f7a91d4442633b79d6a72", size = 184962, upload-time = "2026-08-03T21:20:20.833Z" }, + { url = "https://files.pythonhosted.org/packages/67/b8/b42132ca113dc567d37684437b46ca1dafc885902b02a110a02d5b511857/cffi-2.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:58acb8ab8e295e6c5ea12f888cbb13cf21511ef2a3303a23f4325c29d17fe5c1", size = 222328, upload-time = "2026-08-03T21:20:22.118Z" }, + { url = "https://files.pythonhosted.org/packages/80/10/c5c0cbf0a657aecf59ef511409734230bf556f05a0d6c9eed7aa5c0a0166/cffi-2.1.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:456a61fa52d579ebf9df2e9552ead5129855dbaff6c1e5a9b1bc408809bdc062", size = 209985, upload-time = "2026-08-03T21:20:23.401Z" }, + { url = "https://files.pythonhosted.org/packages/d5/6c/bfa0b87b03b9238148beca990292843c9396ba069b54496596594173de7b/cffi-2.1.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a4f00aa42f75d6e4595e8866e748cc1705adc0cddfeb2ca86d0d03993d63ba03", size = 208530, upload-time = "2026-08-03T21:20:24.628Z" }, + { url = "https://files.pythonhosted.org/packages/e9/02/4e7d553a7ac4b4238b38b3c1b80d486e9d4436f8d2acbf87a0997fe3f402/cffi-2.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b0431303acaea1089ad4b3e9ce4e6518193def1118d4073ca848635ee4ea2e96", size = 221525, upload-time = "2026-08-03T21:20:25.758Z" }, + { url = "https://files.pythonhosted.org/packages/82/1d/a4aaf9babd75acb4d5f223bff71533bee748dd770a382619a798960ee9ba/cffi-2.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:64faea20f4e2613363a1a9b9c7dd73058f3ecd00133a511e72ad7c511658f527", size = 225053, upload-time = "2026-08-03T21:20:26.985Z" }, + { url = "https://files.pythonhosted.org/packages/81/10/5dc0e7bdd18e22107054288283380fc97a06ae3f1656a106908d666a3c88/cffi-2.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5c58fe613dc5e5336357eff555824a314d8e43282600435c8d1cb6a7a2fedd13", size = 223213, upload-time = "2026-08-03T21:20:28.277Z" }, + { url = "https://files.pythonhosted.org/packages/0b/e9/d0061c364cde06ee43168a0d076ac1da512cbc380d44767b844ba34fe2b6/cffi-2.1.1-cp314-cp314-win32.whl", hash = "sha256:1a18a57b58cfb21fc28d72e876acf10eaed67a1ed96226f92af4df681d571c4c", size = 177682, upload-time = "2026-08-03T21:20:44.288Z" }, + { url = "https://files.pythonhosted.org/packages/a7/06/1c3e01e3ba14c39f6d10bfbac52753b7e22259e38088e5cfe1d704918690/cffi-2.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:3222ba5d678f80a030e6afbcc33dc1ae5cb45facabb61cee2c7016b8432fde48", size = 187949, upload-time = "2026-08-03T21:20:45.623Z" }, + { url = "https://files.pythonhosted.org/packages/87/5b/da4e39efe18eeb89cf580ea9cfc66b6a7c3eadb808fc0cc1d3a295cb5a5d/cffi-2.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:ab36d55f9ed2d067327667c2fea18dda018eb628dd6347aa01dda6cf1f5d3836", size = 182947, upload-time = "2026-08-03T21:20:46.955Z" }, + { url = "https://files.pythonhosted.org/packages/23/59/40338bf421c5accea1d45158170c87006ef1cd371b05c077e76476949728/cffi-2.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7750c6449dff7864bb9bb27ddfb0267756189201a3afc911d82b3caacd70dfc3", size = 188504, upload-time = "2026-08-03T21:20:29.495Z" }, + { url = "https://files.pythonhosted.org/packages/7d/47/5ecf1023850036e674c77ec4de86182d309ae344e39e7cba984b7df5d647/cffi-2.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0beceaabe56af686895136a2de78db54ecd8e4046b236b8fd6d6cb61389e9bf2", size = 188259, upload-time = "2026-08-03T21:20:31.291Z" }, + { url = "https://files.pythonhosted.org/packages/2a/9c/92934c3bea9f785b23eba304538c0b4d37a2a96d2431eb3a1bc87a11aa19/cffi-2.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:49cbc70e6542d4ccccb936558d1064a8012541e78f821f955cff24e357776c94", size = 223864, upload-time = "2026-08-03T21:20:32.571Z" }, + { url = "https://files.pythonhosted.org/packages/4d/45/ba4c93527bc38616a8bd36488acb69a2212d60486794f0c1f318949bbb76/cffi-2.1.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:e2d65b31f36619cda3999b78b2aa9632e76b78448e7a56fc4240824200e7c4fc", size = 211538, upload-time = "2026-08-03T21:20:33.808Z" }, + { url = "https://files.pythonhosted.org/packages/80/e9/b6ef565e452acb932fb0cb5443f44a78efbd1233e566f02b5a83855e9115/cffi-2.1.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:28907ab9bfb6aa13184cfc17c6b8e1023c5ab6fd7076d8c20a35e59fe04f8f29", size = 210688, upload-time = "2026-08-03T21:20:34.974Z" }, + { url = "https://files.pythonhosted.org/packages/9a/95/eff5f0cee78d2eabc7eebffec40d3fc1876b5f3c95582e018bb4b99601f2/cffi-2.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51b31d1c98274844cfd7838ce00bfc27c7423a4dc00fc0772fc3331c2cc90676", size = 223803, upload-time = "2026-08-03T21:20:36.564Z" }, + { url = "https://files.pythonhosted.org/packages/fa/01/579d39fb8bef00a335a23d83757b44feb24cd6345a2c451b64cb67b9c362/cffi-2.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5e7cecbaadb83884793e05828cee59b210b24583b9c7425d0ba6a754fe22eb4e", size = 226763, upload-time = "2026-08-03T21:20:37.816Z" }, + { url = "https://files.pythonhosted.org/packages/8d/b0/0b44f47c60b01b57b6e2bbd92343f13a85a1d93bc46ccf6e47e244acd99c/cffi-2.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:25792eac27877609e7bb06d42ff88278a6624fff2ba9bbb523c09616b117e80f", size = 225688, upload-time = "2026-08-03T21:20:38.959Z" }, + { url = "https://files.pythonhosted.org/packages/eb/d2/3b7176cb570a1d3e27faf67b72f591af508036e0d8b2be2ef9af9e8c84bb/cffi-2.1.1-cp314-cp314t-win32.whl", hash = "sha256:8ef53b2de9bcb9197d31854256575d59dbac0cba72ac627bb291ef5eceb74be4", size = 182868, upload-time = "2026-08-03T21:20:40.388Z" }, + { url = "https://files.pythonhosted.org/packages/56/78/31f00c1bcd97c9bbf55f1bfdf5bc809a5de8887473e90bb9960dca825e80/cffi-2.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:616f097f2fe415bc92a247f02e11f634e1f9e9a83d327e3c915c15089c87869e", size = 194104, upload-time = "2026-08-03T21:20:41.725Z" }, + { url = "https://files.pythonhosted.org/packages/7b/1b/58496f2ed0a35de575250c02a43ab3cc2c04d494a88fed31c1cabc0fd176/cffi-2.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ad2c86c495b899d862ea0f4b42891b8713a3bd45dd4105c7fd51c2a72f39f3a5", size = 186402, upload-time = "2026-08-03T21:20:43.042Z" }, + { url = "https://files.pythonhosted.org/packages/c1/8f/9ebe220eab48a093d1a5a5e339ab0dc7316eef3bb04d63c42f0251b61f50/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:dddad92b554513a31f272570678ba307fb9f618f05e3d4a5eacafff9eae03e1d", size = 194043, upload-time = "2026-08-03T21:20:48.179Z" }, + { url = "https://files.pythonhosted.org/packages/ff/69/844bad3ece306c4782c2ecb93597035b6690d48704b803914c199da1e8b3/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:da0e573f9f97159390c89d9f1a9e41908b66d408cc5b58d08cf3847d844c531b", size = 196737, upload-time = "2026-08-03T21:20:49.457Z" }, + { url = "https://files.pythonhosted.org/packages/1b/8a/af668013284634733f02d683458a0728739c7d6ddb5e14cb0c20832266fe/cffi-2.1.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:fb92203a88b3d3053034db775110081c49d28be6551923805e039924093761e4", size = 184933, upload-time = "2026-08-03T21:20:50.639Z" }, + { url = "https://files.pythonhosted.org/packages/0c/75/2f5207ff6d1a613133b23a5203cc0c2a628313b5eb3974d7956ae3c57950/cffi-2.1.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2ae64be792b8966f2c69538199728b290e34726562896df1e5dc8ffd8d8188e8", size = 185002, upload-time = "2026-08-03T21:20:52.173Z" }, + { url = "https://files.pythonhosted.org/packages/e2/31/9e1313b0a6e30e91b3b3d3fff51ae99c857c07738e3afcce1f7334e1b7ab/cffi-2.1.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:507a24c282e0f42f8ed737cf048572cbf580468da5555764a8331735e9c736b6", size = 222271, upload-time = "2026-08-03T21:20:53.462Z" }, + { url = "https://files.pythonhosted.org/packages/50/e3/f6234a833e6e08c7007003074723c406559eecf9b48dfc97471e5a8eb7a0/cffi-2.1.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:246fa40ce8645a614ff682e0b70f37134e460eaf93a775e0cbe3cca585a67a80", size = 209919, upload-time = "2026-08-03T21:20:54.783Z" }, + { url = "https://files.pythonhosted.org/packages/0d/fc/5f74e293fced6edb51af3a46c4ccf6c23c9943774ecb375ddbd522c76add/cffi-2.1.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:471cee653ae88de62096552e6d24ccb4a5adb8c8c9f10b5054d0122c15bf2779", size = 208529, upload-time = "2026-08-03T21:20:56.066Z" }, + { url = "https://files.pythonhosted.org/packages/44/16/29e6d01b388bef055ecd6ca8244b3f4d336bd09e92d5d892187b9601084e/cffi-2.1.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aeae0e330c9f6acd681f647d46cefd30c29f93e3392882e792e82080c9691399", size = 221630, upload-time = "2026-08-03T21:20:57.336Z" }, + { url = "https://files.pythonhosted.org/packages/a4/18/fa7f1f6857d5eb88a4ca99ffcbfb7c387a287ccc154c64a73e86314745d7/cffi-2.1.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:42a494cee34437f05546455144f2b5d9ac09b1face62bcfce597d2e521066688", size = 225134, upload-time = "2026-08-03T21:20:58.675Z" }, + { url = "https://files.pythonhosted.org/packages/e0/9f/e8e3dfa04a1b4c241f8c91faacad872b4d4efd051d49764ad4e2fd4b9fea/cffi-2.1.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:cc572dace3f60ef98d7b12ff411d20f5362feb31a0439eab0085bbfd349982d7", size = 223197, upload-time = "2026-08-03T21:20:59.968Z" }, + { url = "https://files.pythonhosted.org/packages/f8/7e/8debeb04f1ab9fe2a6963964cd6f1aaf7192627b83926586a6a4e089c9fa/cffi-2.1.1-cp315-cp315-win32.whl", hash = "sha256:4f42141fc14250de6dde5ee7ea4432be017252d91f19c5ad043c084cea629cac", size = 177683, upload-time = "2026-08-03T21:21:14.901Z" }, + { url = "https://files.pythonhosted.org/packages/e0/31/5158704cc474ab65c1647932e88be78dc0873f47130e253be38bcaf13d01/cffi-2.1.1-cp315-cp315-win_amd64.whl", hash = "sha256:e6e8cff14d6fb0be70a09c0bdc58096f501952d04624ebf867e0e56da2df8960", size = 187897, upload-time = "2026-08-03T21:21:16.108Z" }, + { url = "https://files.pythonhosted.org/packages/cc/4b/b3a2da8570c704ffc0f9762cdc3ec0f02c8573798e0b5cf7f11c82bbb70f/cffi-2.1.1-cp315-cp315-win_arm64.whl", hash = "sha256:27350daa11d4f10c540e6e89dada4c54feb7256ad03e9a4dc075ebad7ba360d1", size = 182935, upload-time = "2026-08-03T21:21:17.271Z" }, + { url = "https://files.pythonhosted.org/packages/d0/ef/5443574510a1207e6f6bc38ba6e1f1de36cb48fef07b2728bb896a21f430/cffi-2.1.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:c26608d2222fb1e94487e4a387d85f13eb55d5ed725cb25a0c589ac4ee60e7bc", size = 188464, upload-time = "2026-08-03T21:21:01.163Z" }, + { url = "https://files.pythonhosted.org/packages/7e/ae/a56fa8c4686ad50e148fcbc8d3ae0d03915ff5c30d795058988c24118cef/cffi-2.1.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:4be96343e422f2dfcd12ab5c9f5aebe03f82f737c6bffeca6830b3875cb44aab", size = 188262, upload-time = "2026-08-03T21:21:02.382Z" }, + { url = "https://files.pythonhosted.org/packages/53/b2/6187f46f2912276a3ae284076109cc5c8680482f11f766ccf26db4a86427/cffi-2.1.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:937c0052c05a31ca1daf18de3158eed4dbfcb9cc107adbea227728d647be701e", size = 223779, upload-time = "2026-08-03T21:21:03.553Z" }, + { url = "https://files.pythonhosted.org/packages/8a/f6/c3ad28bd19f77047a03084424fbd4cbe997303267c14423737324be0385d/cffi-2.1.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:df423d40ee8654634421812bc3b196da3f9bd7d32929da813f8394c4348a5358", size = 211520, upload-time = "2026-08-03T21:21:04.863Z" }, + { url = "https://files.pythonhosted.org/packages/a0/cd/ccac9013a5bd9fd764de118674ab9c805b5ca10c19270d90ee273f8b2240/cffi-2.1.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a730a083190634c65cca36ba5f489531576ebd79bcd5c8e172130f6453127231", size = 210673, upload-time = "2026-08-03T21:21:06.223Z" }, + { url = "https://files.pythonhosted.org/packages/52/86/2976131c639aead931c5bee5aba67e4b09fbeb8018b6f282f70803f923a7/cffi-2.1.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:363e05fa78e15116c3c32c210ee36884fd6b9afa6d440e47112c3bd511d64cb6", size = 223835, upload-time = "2026-08-03T21:21:07.539Z" }, + { url = "https://files.pythonhosted.org/packages/ac/0c/33a7aeab2f9c76918c52e084beb39c570db3588133412929e8ec06fab90b/cffi-2.1.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:770de9db11e84213beec501cfcaa013b019820ca881e03344dea5844f7876d94", size = 226705, upload-time = "2026-08-03T21:21:08.774Z" }, + { url = "https://files.pythonhosted.org/packages/e3/26/2cde30fdde421130bfc18f70395731a6e6b2053c6a1978a5258ff04e72fa/cffi-2.1.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:7da0c5eff80f0197f3b3d1232ec5a682a9325f4ae9016a78f5f5ca35f9ced1f5", size = 225539, upload-time = "2026-08-03T21:21:09.911Z" }, + { url = "https://files.pythonhosted.org/packages/6d/cd/a361394c94b2129d604bb846f624a8e88255a3ee33129c434a00d715e64f/cffi-2.1.1-cp315-cp315t-win32.whl", hash = "sha256:06c72bb76605a4b0cd0aad6930b69d4baf7dd5d806cfc409b824191099700e66", size = 182707, upload-time = "2026-08-03T21:21:11.226Z" }, + { url = "https://files.pythonhosted.org/packages/9b/b5/ba2b299993c26577d529b6ae29841f9e15b9fcf004d65f423f4fcf94ade9/cffi-2.1.1-cp315-cp315t-win_amd64.whl", hash = "sha256:d9c275eaacd24aa73f94ffd6de08fc3f932424d8b6c376f4bed7cde376fe7bc3", size = 193772, upload-time = "2026-08-03T21:21:12.39Z" }, + { url = "https://files.pythonhosted.org/packages/aa/29/35e016098c814cd93de9cd320c66b5bfba14dc6ecedd3cb518fa7c408c69/cffi-2.1.1-cp315-cp315t-win_arm64.whl", hash = "sha256:d18e5ac0f2f03f4f518d3e23db0f0cad7faa1da8620e9c09461d443bbf6e6692", size = 186360, upload-time = "2026-08-03T21:21:13.636Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e5/3f/143b048436775b0f76ac3eec145c019e8173ccc2885c8f20319b996d5e83/charset_normalizer-3.5.1.tar.gz", hash = "sha256:6117b84ea48435e5356dc737f5121485c30920ba43375fa7b434fd753df0eac3", size = 171764, upload-time = "2026-08-15T08:20:44.807Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/30/27/78873dc8b6a56357517b74b6bb9568b80450e7bb4f6ef7e3fa9d22aa0bd7/charset_normalizer-3.5.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:5b6d1386bf0096d26d3a863dc0a487a5b4eb9aa93cf5ba69683d29dde6b9d60f", size = 344456, upload-time = "2026-08-15T08:17:10.072Z" }, + { url = "https://files.pythonhosted.org/packages/9a/4c/be49ada26b1f0232d57aa89bbebf997a5cc2332a5616b6eca26ff680044d/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4582c27e8c889d64811987b5967fbd3ae0c823fe1fd933b543d55ac20bb475fa", size = 238530, upload-time = "2026-08-15T08:17:11.563Z" }, + { url = "https://files.pythonhosted.org/packages/76/84/6f1290fa07ae6978d3960caa3eb1b8019bf9284ab7c2297b00c099ef4250/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1d1c7a53a6c2103925cdd6d7229f8c567379f211c869793df679f2e9f738c369", size = 230200, upload-time = "2026-08-15T08:17:12.919Z" }, + { url = "https://files.pythonhosted.org/packages/e7/a0/47b18adeed31c8f16ba9700f32c1b18594cfa09f47eb672a488c273c22bf/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e6621fb2a4988d6e53eedc455e5903e2679f3967b8acb3d639f1b63c14a2e893", size = 262222, upload-time = "2026-08-15T08:17:14.571Z" }, + { url = "https://files.pythonhosted.org/packages/38/fe/341861ac118dae06f3ec0eb487488af52128f2ef2faf0b11003944d22259/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7c0c10730342b0c9b35dd1d619beb8214e520bd96a1f870f452680b238aab3e0", size = 258951, upload-time = "2026-08-15T08:17:16.158Z" }, + { url = "https://files.pythonhosted.org/packages/6f/89/bb5108dc6c3651dca963f2b0a3ba19bbcb370c94e1b6d3e0e844a58e6dca/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b9af956078716df40d985fb0dfeb2c2120c5ca92ba4ff4b388acfd01cdc14d08", size = 248801, upload-time = "2026-08-15T08:17:17.683Z" }, + { url = "https://files.pythonhosted.org/packages/b1/ba/ef83ae3aca816393decfa3530976f38a79812d707b80b580ac33b83f9877/charset_normalizer-3.5.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f9f8405c2c758532c74fed975dbee57be1f31a6e865c031870c79a6ed3212ada", size = 244070, upload-time = "2026-08-15T08:17:19.191Z" }, + { url = "https://files.pythonhosted.org/packages/f6/0b/c5292a2462d69b7378ea89793bbb5b2b6fcf6f7dd6d1667f9619094ad553/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:96fef3e886d6a9874b14f27fc193fbdc69d5d8035783d86aa4e1cea594e695f9", size = 240110, upload-time = "2026-08-15T08:17:20.547Z" }, + { url = "https://files.pythonhosted.org/packages/46/22/111e5be3b740d5c2a5bfcedb3d237b6591e5c2e82ae9d6ffcb121fe0909c/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5d8531a6569d025f68e2321e7638fb7978f23db58e5f69f56913837aae03816e", size = 232836, upload-time = "2026-08-15T08:17:21.895Z" }, + { url = "https://files.pythonhosted.org/packages/f9/d2/d2aad6fe0dbb44b194bf3becb60f5a0ac48446ade999a47fe7bb41eb09a7/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:aae2ee51122d3ae968a3837d97dc24a0aeebb0dea23694422cd172bd30017cd6", size = 262712, upload-time = "2026-08-15T08:17:23.727Z" }, + { url = "https://files.pythonhosted.org/packages/35/5a/337e4663a5eae6de99db940ee8066d4145caafb61327db62deda15313cce/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7235dc28fc6dd9d832ac7c7bce95367dedb85929f17368a0c2bee1e080b9acbf", size = 242977, upload-time = "2026-08-15T08:17:25.157Z" }, + { url = "https://files.pythonhosted.org/packages/ca/85/f82f8a92e31c7519410e2e1afdc630f28ec47490ce2c09a11c1a43cbb459/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4abdc5f9ad448c1ecbfae2974b820535d6bc6e7eef63babbab3d81cf46968c71", size = 260207, upload-time = "2026-08-15T08:17:26.602Z" }, + { url = "https://files.pythonhosted.org/packages/b7/52/643d11ffd60e9ac2fd1fb87e167a19285b9eefeff4a40e63c87cbfbeab36/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ba501e667c17d8411f98e67a022d9604ef179aff0e459b7e292c796837c13573", size = 250562, upload-time = "2026-08-15T08:17:27.971Z" }, + { url = "https://files.pythonhosted.org/packages/62/16/46556278c2168d12df9da7fede5dc6fc70e60301b26a82bbeec238c9cfe3/charset_normalizer-3.5.1-cp312-cp312-win32.whl", hash = "sha256:cfa1c0cc3a8f9f53f1243a5a99ac36fd003880199383b37672e86ddda9cb07e2", size = 178507, upload-time = "2026-08-15T08:17:29.277Z" }, + { url = "https://files.pythonhosted.org/packages/9d/7a/4c6c298171e6b3e745633180ff59350fc0ca0db1ffd28df1e369e0579f71/charset_normalizer-3.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:3617ac3cfd8b9888f145ad89dd6e692285834b0201c6074a5eeaad3fd4d668c2", size = 200551, upload-time = "2026-08-15T08:17:30.668Z" }, + { url = "https://files.pythonhosted.org/packages/cd/d7/eb95a042f0dd22e304b0b6472b154f3546a1a039a9ee89ccb2a7f61591fc/charset_normalizer-3.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:88e85ab89cb822c1e635f51d6d32e488f94e002e70e2f492bdb8b945543f345a", size = 180700, upload-time = "2026-08-15T08:17:32.028Z" }, + { url = "https://files.pythonhosted.org/packages/bc/61/2cb6ad133dbbb449fa2d37ccae973232f4827e799af258d15e589a3d1e9e/charset_normalizer-3.5.1-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:4f298bdadb8f0b9e5672877f647d1be9373ef5320c9e2f049795e26cad28b6a9", size = 211584, upload-time = "2026-08-15T08:17:33.597Z" }, + { url = "https://files.pythonhosted.org/packages/18/57/a305c968be1ca13f3dd1b32f445877e97addf55d80b65c7cb35fac82b777/charset_normalizer-3.5.1-cp313-cp313-android_24_x86_64.whl", hash = "sha256:88ca277405c2d3b71c4e1c2ee0e7966e807bcba86a69d11e19ba199d18ae4491", size = 223359, upload-time = "2026-08-15T08:17:35.022Z" }, + { url = "https://files.pythonhosted.org/packages/09/0a/d3646670292ce8d8f8cc11ac067d44885e697a5591f57a9221128da5e7b3/charset_normalizer-3.5.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:9362dd90aa7dab48c0054a21187791ccf05473f7dba5d92b8033ae62164675e7", size = 194464, upload-time = "2026-08-15T08:17:36.452Z" }, + { url = "https://files.pythonhosted.org/packages/de/93/d51ec556e01042fed6f993ea859311bc7917b466684182fbbceb6ca24762/charset_normalizer-3.5.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:977cdbd483a9cff38179bea4fd754289a6f2195c7abd414aba85410b3e66cc5e", size = 197676, upload-time = "2026-08-15T08:17:37.819Z" }, + { url = "https://files.pythonhosted.org/packages/a4/a0/562247944386f7d4ef94467e84876600cc1e0f1b93239aaa9213d2bc3cbd/charset_normalizer-3.5.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e90251c0c7bdd54a100a0dce3c07b7e637278c93af29dbf78ebb89a58c4bac7d", size = 340473, upload-time = "2026-08-15T08:17:39.303Z" }, + { url = "https://files.pythonhosted.org/packages/31/e7/1d994be1b93d41e9502b8b0460eaa88a1dd8df335df415db87d6c3e91ab2/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:94d78ecec2605a8d0398b0f365d5f12a63248438516f5dac536a5eff7337df4a", size = 240156, upload-time = "2026-08-15T08:17:40.66Z" }, + { url = "https://files.pythonhosted.org/packages/09/53/27923ce5cc6cbccb832037b27dca98882d9c53e9b69e866bbbef4aae7fc8/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d59b75732e9b6f27388e10c14b0259cc5f2e48c78627d185e6a177b58ad3cffe", size = 228246, upload-time = "2026-08-15T08:17:42.003Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/5a97e84d63af1d55c07439cb80e56d99a8efb4295700eb4e18c0d1615d2c/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0d929fc574b4d6fd9e7c0f5c2ede8716a41911923aa7fa5fce38e0818aa4a1ac", size = 263660, upload-time = "2026-08-15T08:17:43.627Z" }, + { url = "https://files.pythonhosted.org/packages/7a/c2/071575791dcc88316c0a9a65ce38897a82e4cfe4a325f0f7fe1b1ac47bcf/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:394fea06235c8543390050ed5f529187074b029fb027213f6c46ac11ab5d950e", size = 260354, upload-time = "2026-08-15T08:17:45.094Z" }, + { url = "https://files.pythonhosted.org/packages/fb/af/63240b0c0248c075c2535a1f1bd992821d8251b9f173abc13329661d09e4/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62b55f6722735a6c472f88361cde6640608773d9443cebdbb51abf436a1fcdd3", size = 250638, upload-time = "2026-08-15T08:17:46.496Z" }, + { url = "https://files.pythonhosted.org/packages/4d/66/70dfad64f15be09c15ccfee81330a7e515895dbe296dd23114e9a231268a/charset_normalizer-3.5.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fa48b1b63d639f9483e0633e092f5851e2348c352f1f9bb6c8182f87884ef876", size = 244583, upload-time = "2026-08-15T08:17:47.963Z" }, + { url = "https://files.pythonhosted.org/packages/c0/24/ef36367d38b9ddd4bccbf72888c342e8de1f5ae506fa0b2dcf970e2732a1/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c71fb0d56c920c269cd3e2e3fe7c610e3f1fdb21a6ce60efa6430ff63676cea6", size = 242038, upload-time = "2026-08-15T08:17:49.481Z" }, + { url = "https://files.pythonhosted.org/packages/db/ab/55e683ba0fff2e43adafc10daa3001eac90fdaa419a97227d5a7067eedde/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:485a0d363cafefcd2538a73c7c838daa2035f09b2c9f9b5e3133f80c6aeb84c2", size = 233677, upload-time = "2026-08-15T08:17:50.845Z" }, + { url = "https://files.pythonhosted.org/packages/bd/67/0f40eaf8d1b6e7cf15e82382a2965efaca787fc1c2794b7021d37aaf5036/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c0ea61a470e070686aa30892fed79e297d2c8d0ab46b8bcdf027d38c51da591", size = 264491, upload-time = "2026-08-15T08:17:52.61Z" }, + { url = "https://files.pythonhosted.org/packages/5c/64/12b4c2a11ee8df4fcc518c78b0d93e3a92bd3d5253d1617ce74ff0e8c7ef/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:90b7481fb62fbe172c558bc6fd1c4c98d82004a54a7551f20e11ac9bf0b8708c", size = 245196, upload-time = "2026-08-15T08:17:54.023Z" }, + { url = "https://files.pythonhosted.org/packages/37/2e/651d910af6d0fba325eee1cda37ec5443462ed25360e666c144166eb6091/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:35fe081843b35aad20ffeccec3eeffbe637b15d14f3fb22cc1b59cd8ec17e93c", size = 261660, upload-time = "2026-08-15T08:17:55.491Z" }, + { url = "https://files.pythonhosted.org/packages/90/c6/b09e05e6db7f64338e0dc067c79577b1138da86c1e38369096851d96be88/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fd0350afdc3aabd5576f60ea109228bd5538139713c7b094c5cd27c73a98bc6f", size = 252618, upload-time = "2026-08-15T08:17:57.025Z" }, + { url = "https://files.pythonhosted.org/packages/76/4e/362d4f9fdcdf5556fb2aa3ce7d4a58ebce03ed1ff03aa1d9aca8d02f13f3/charset_normalizer-3.5.1-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:9d9a0dc7cbe9bec24c3f767c9122c41fe5a1bc43f47cd099d00d393e09769de4", size = 140362, upload-time = "2026-08-15T08:17:58.425Z" }, + { url = "https://files.pythonhosted.org/packages/b4/d4/703be739b26acce318bd29eb3b25b7209e1b1f527f9eae3d1f1f01fdde2b/charset_normalizer-3.5.1-cp313-cp313-win32.whl", hash = "sha256:d63600d620ad0064c3a748b950ac5ea38a80190e5498532efefa4b7b3f1da1f3", size = 177755, upload-time = "2026-08-15T08:18:00.037Z" }, + { url = "https://files.pythonhosted.org/packages/8a/33/56d97ade41c8db611e727168c52ae46c9224c362ec28d4b65d7e9869e8da/charset_normalizer-3.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:aea996a6aba25260827c9ea511d1addfde2da9eb686ac961838509086188b7e6", size = 199295, upload-time = "2026-08-15T08:18:01.506Z" }, + { url = "https://files.pythonhosted.org/packages/5b/75/5b20dd1e6573a01a08158fe104104fa2c8abf941745596954185726cd46c/charset_normalizer-3.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:fd0a274c0e5f9a21565cd9d3dd749b61f96b7aa1e20a93aa1ba4029518f2e5c0", size = 179856, upload-time = "2026-08-15T08:18:02.929Z" }, + { url = "https://files.pythonhosted.org/packages/29/cd/2b812ce5e888f1ce69a5350281e58aab07ae64a958ecae8912f30865718e/charset_normalizer-3.5.1-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:774d157f112367ff4abd29019f38f023c24e00e56edc7829c20e358a5a913ad8", size = 212318, upload-time = "2026-08-15T08:18:04.403Z" }, + { url = "https://files.pythonhosted.org/packages/9e/4a/a6ee107430768a5334e6d63f31f148a04a1a491ef161a1ac9415a73f2fa8/charset_normalizer-3.5.1-cp314-cp314-android_24_x86_64.whl", hash = "sha256:26422d45fd13551cf564c58932f7d72b4f58b93b0fcf18c35ba6be12b46bb102", size = 224897, upload-time = "2026-08-15T08:18:05.997Z" }, + { url = "https://files.pythonhosted.org/packages/c3/d9/35ae3f64f29d0179c35c3baefe575904df2913dde519129c7f75995a2b1d/charset_normalizer-3.5.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:09a7bba9f739468c8e78c36a75c33768e53cb1959fc638f510454c14683f00d5", size = 194848, upload-time = "2026-08-15T08:18:07.397Z" }, + { url = "https://files.pythonhosted.org/packages/74/76/f2fc7380f056cc273a53af37f50d08ad54b2c59f61078f31432edcf1c2bd/charset_normalizer-3.5.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4c9548dc78002099910abaebc0a72ac58b7d30931869e0351c09b507dff4ece3", size = 198163, upload-time = "2026-08-15T08:18:08.989Z" }, + { url = "https://files.pythonhosted.org/packages/e9/40/095ce62fa078483cccc1fa2b36e6bc9580b85422a20ee9f925341c50e44f/charset_normalizer-3.5.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:c428c6c31eb5f4277d7f8eccaf767fbd548ddd5ce3c8b4f4cbbfab3d96b5904c", size = 341823, upload-time = "2026-08-15T08:18:10.458Z" }, + { url = "https://files.pythonhosted.org/packages/f1/5a/0e58b1c04a1596e0256f407274a92d5fb2ee21324409d1fab1da48a65b5b/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2f06b7eae9dbe77fe1d644ca244dad508de8d302870a43f3c559b521270938a0", size = 242458, upload-time = "2026-08-15T08:18:11.989Z" }, + { url = "https://files.pythonhosted.org/packages/22/95/b4618ce912e6db0b1aae89ba788e38e8a7eba0f3025cc66e8c0699f977b2/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b7430cf5728e68f6c462254009a6ef4086e1bea43cf2f57aa9c55fb4f50ff96", size = 226717, upload-time = "2026-08-15T08:18:13.401Z" }, + { url = "https://files.pythonhosted.org/packages/8a/76/c681192bbda3d55356db5dadd64381d5202b37c6b598fcda5282e88b5d3d/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab743e9bc90c1f73552ec33e10e3331315acd2c397b36065b591b0181de533cc", size = 266111, upload-time = "2026-08-15T08:18:14.961Z" }, + { url = "https://files.pythonhosted.org/packages/88/be/55127bfca72c0cff6c022488d140d7c5b04c771e3b72e9bdb4836d54979d/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6f7deae3feb4edfa2efaf7c574fe88cbf055038a6abdb40188e4fff66d5699f", size = 263128, upload-time = "2026-08-15T08:18:16.515Z" }, + { url = "https://files.pythonhosted.org/packages/e0/91/39c3af510b0aa32bbda03374259200f28430febfd1bf5e511fe765282ce5/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15f024313246a4ed976c60f440bb8d257815513a681d212ff74fd46f7d715a90", size = 251240, upload-time = "2026-08-15T08:18:18.127Z" }, + { url = "https://files.pythonhosted.org/packages/1c/a5/cbe418bbc6ecdfc3e05a0116002897c4b403a5e838d697e64c78e9f0190d/charset_normalizer-3.5.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:823f82903d189af463d7df250ef1f7f696f3cee08cc8d91deb565e8d425f6506", size = 245282, upload-time = "2026-08-15T08:18:19.625Z" }, + { url = "https://files.pythonhosted.org/packages/cc/a4/689bb42e8e7cd492f3cb64907c6bc00ad247ec9a3628cd3f8eed126e8ae1/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:01e93745f7f219b703b60ba7afead36cfc4242782be5af484673fc500df12da5", size = 244597, upload-time = "2026-08-15T08:18:21.121Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ce/9962938e179cf9f699d3f1e7b3114b5d7642dee6a893745229f9dd04f274/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:329fc3ccb63ad22d867d84c2adea759a64079a37ba4a343433b02c7a2816871e", size = 231376, upload-time = "2026-08-15T08:18:22.57Z" }, + { url = "https://files.pythonhosted.org/packages/85/54/46000450ada53bd9eac5429a2c8c54cd2d9b39c0c255f229aea9af0948a5/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:bb57753e36e4855b8ca375069482250a6246372331a3e4f3407eaebb007443f5", size = 266715, upload-time = "2026-08-15T08:18:24.235Z" }, + { url = "https://files.pythonhosted.org/packages/3d/bb/618749d70f792b44252a777bf89bfb86823b9bbc1ea13fe8ce759b07f38a/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:fce8cbd4997efeb450bd298b54f755dcdff18d496f7a5ddbb4867c6d7c88fdc3", size = 245848, upload-time = "2026-08-15T08:18:25.726Z" }, + { url = "https://files.pythonhosted.org/packages/7e/3f/ffb64458527c7668031d5eb095d978de561958dc9f5b53f8e488a533e603/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:6c9cdde8becb25a7fde49924511aa2644d6f8081cc8df8e9452724303348d8e3", size = 264521, upload-time = "2026-08-15T08:18:27.193Z" }, + { url = "https://files.pythonhosted.org/packages/4f/ab/74a55fd803916a35ac461daf002708191aac19b546b80dc8cabfedc63d98/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9ac4444d8d4fd4c4bd08bf451ed3167aa9e7ec6cdb41b648794f1d1103652e36", size = 253054, upload-time = "2026-08-15T08:18:28.568Z" }, + { url = "https://files.pythonhosted.org/packages/a0/2a/6a9034b7d3c60b17499afb482df5878bf9fa20b50cc3887d5ef017a833db/charset_normalizer-3.5.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:f03ac127268b43ef4fe9e6ab6794a6794b49485a0cc0c1db79876d2f33f75bc7", size = 140580, upload-time = "2026-08-15T08:18:30.214Z" }, + { url = "https://files.pythonhosted.org/packages/f3/46/1d362e1a00d035d66b9869e1281eee115907f7e390a16a07824ab5737360/charset_normalizer-3.5.1-cp314-cp314-win32.whl", hash = "sha256:1f5883d77fd409a261abb5dc8ccbe335720d798b1de4abb3b1d47ccbbc76b53b", size = 180325, upload-time = "2026-08-15T08:18:31.877Z" }, + { url = "https://files.pythonhosted.org/packages/7a/7c/4938c329b6a9d446f6a59aa2092ff7118f274209b5ed0e26893d1d30a63c/charset_normalizer-3.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:c658c50ac0c98cd755a2dd50b7977d3bca7df401dcc47fbdfa87db53ef7d4e8b", size = 204175, upload-time = "2026-08-15T08:18:33.466Z" }, + { url = "https://files.pythonhosted.org/packages/ac/33/eeb384dbd8dec570661354592f4f2e1b2fcc92585624d146a000caf53841/charset_normalizer-3.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:4bea7f8ebe90bbd7f0e4a2de42ca6924ba23e3e76418c408ff82f1d46fabd687", size = 184123, upload-time = "2026-08-15T08:18:34.913Z" }, + { url = "https://files.pythonhosted.org/packages/1c/6c/c73fa9d5a85f6ab05395de61c5f6984e0a9ff40bb5ff888d46dff02526c6/charset_normalizer-3.5.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:fbc597639158fd7c14d55e808718848319540f51b0e6746e3eefa59723a4a348", size = 381682, upload-time = "2026-08-15T08:18:36.349Z" }, + { url = "https://files.pythonhosted.org/packages/30/c7/63565f860921457feba93bae6c86fb7746deb4cffeed2f375cb845318146/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e71c909f353863b2b89c83de2ebed71ea6d0df8a6ef65a128193c5e650766bef", size = 240826, upload-time = "2026-08-15T08:18:37.887Z" }, + { url = "https://files.pythonhosted.org/packages/06/ae/7ae8807410dfa33f8e6f1715740adeaafa8a816cc4cb33508f54b1f7c896/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7ac76cf9afd34929d76eb7fcb63be476a4853d8a96f0dcf2d0db68a0cbdf9885", size = 227861, upload-time = "2026-08-15T08:18:39.315Z" }, + { url = "https://files.pythonhosted.org/packages/e9/a3/887c1642f0da26000b0e0652d91071113c0e72cea33952e225cf589f49a9/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a3a370082ce34d0612f421e15fe011c53bb1feff21a26d06ad4fb244dab5a375", size = 260758, upload-time = "2026-08-15T08:18:40.88Z" }, + { url = "https://files.pythonhosted.org/packages/3e/11/e6f5b9a3d0e55b0ef7505cd3765cdd48f22db89994c947b316f52f801fd8/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:256dd4d85d9e4dc595e2bc983c980e73f62ddeb3165c58b4c3dfe78c5c8548c1", size = 259950, upload-time = "2026-08-15T08:18:42.351Z" }, + { url = "https://files.pythonhosted.org/packages/1b/ee/e4e10a94d51cd1ee638aa7e00b65399e6b2a4e8376ab6d2eac9f95586671/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:58d4aa13a59c969dbfdf9e6a9560e242cbfd9e8a8f50c2747714df1a423adf65", size = 249329, upload-time = "2026-08-15T08:18:43.914Z" }, + { url = "https://files.pythonhosted.org/packages/c4/25/d5f4198819e6059735a84e8d0bfb72dc33976da67b97adcd3fb5a5e07ec6/charset_normalizer-3.5.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0c6dfb5ca6723eeed15aa8e564a014d69fcb8812f94eef11fe3631e0508199f5", size = 243137, upload-time = "2026-08-15T08:18:45.368Z" }, + { url = "https://files.pythonhosted.org/packages/a5/e9/e925ca7569cf9fb9701fd82503fee73eea5268fdb856bdd64947092d3daa/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c010f5581d9c612804cc59fcf7b524b707fbcb72828551237ab545bb5c7034af", size = 242820, upload-time = "2026-08-15T08:18:46.842Z" }, + { url = "https://files.pythonhosted.org/packages/34/17/672c251a888ed2aebcdd2fe830ad0104e25ff83c43f5c4f9c15e9fc6853c/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:52ec005752a56ae79547a05c0139ca2501a0c866390b6115008456b9f0e7cde1", size = 230504, upload-time = "2026-08-15T08:18:48.353Z" }, + { url = "https://files.pythonhosted.org/packages/3f/fc/f6a85abebd42ce4da2f1db0aa56cc6a0df1995e318b3875d14401b8381d1/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:2bced4061f000f7187254a02ad3433ae17eaf991747ceea2f478422590a5bba9", size = 263087, upload-time = "2026-08-15T08:18:49.859Z" }, + { url = "https://files.pythonhosted.org/packages/98/66/7c42677e739ba66746b297e2046918d793078094dc239e1e72768cffccc6/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:9eea3ab2597a5e65fe65296e2d6a84570845a6b55532d90333d740d48bbc850a", size = 243269, upload-time = "2026-08-15T08:18:51.601Z" }, + { url = "https://files.pythonhosted.org/packages/de/d8/a50b79237f417af10f8c2a501ce8d1ca87829a22e69117891ca4ba20a69e/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:496846868fea80e479324862fa877f02411f2fd0f83b79ccee2607aa68b2a032", size = 258766, upload-time = "2026-08-15T08:18:53.23Z" }, + { url = "https://files.pythonhosted.org/packages/2e/1d/0fc91aeaeb3c83b748f532399ce67cf84604b48297405d740000f7a9e786/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:85d5855daafc240cc045c026d7a15fd198a09b0fc8ff6f5ecbb5297b509cb11e", size = 250814, upload-time = "2026-08-15T08:18:54.768Z" }, + { url = "https://files.pythonhosted.org/packages/ae/10/3d8c777cf9024615295aa1b808324ad5b4a77855869c00824bad74ffaf8a/charset_normalizer-3.5.1-cp314-cp314t-win32.whl", hash = "sha256:58d3e12c88e0950bca850ae1f7c256055c097639c2edb9eb123af9807d8b15e4", size = 191074, upload-time = "2026-08-15T08:18:56.305Z" }, + { url = "https://files.pythonhosted.org/packages/4d/81/ae557d3c44d1a1d688696d60563413a0866a91b7ebc50f20df838be3d8c8/charset_normalizer-3.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:acaf604462bf330b0d07e7a07c1d6e4adac79e5fb13e9c5140590542cafacc00", size = 216476, upload-time = "2026-08-15T08:18:57.889Z" }, + { url = "https://files.pythonhosted.org/packages/27/e9/61c01fb8b804692569c036b3fc50495814502dcf13a60649c6055390b02c/charset_normalizer-3.5.1-cp314-cp314t-win_arm64.whl", hash = "sha256:fdb8a068947befafba9952162645dc2fecaeb400e64584829ed5e9b2fbe21a7f", size = 194115, upload-time = "2026-08-15T08:18:59.418Z" }, + { url = "https://files.pythonhosted.org/packages/4a/4e/8544831ef59d8f27ce92c80871380fdacc8076a8a56ed62f82e54f991333/charset_normalizer-3.5.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:9085f87b0e38a2b92b8923059b4e8789fe40d9279712d15dcc670048d77079af", size = 342048, upload-time = "2026-08-15T08:19:01.054Z" }, + { url = "https://files.pythonhosted.org/packages/7f/a6/e3b46852424246065355644f4fb6dbccc0239a42a2eee27ecfc8957f0bcd/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2679de311c7946dde5d3b6f44941844133ff5c7cb86099c0061ab1e8901c20a8", size = 242997, upload-time = "2026-08-15T08:19:02.492Z" }, + { url = "https://files.pythonhosted.org/packages/03/3b/0cc9a26777334ab2f2e3089b948bbf4e4fe72ea70b897715ef6415043ec8/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:baf3775a2635e5a11fbd5e4e64ee69c7e86875d224a5c72aca4c141064589a90", size = 237014, upload-time = "2026-08-15T08:19:03.943Z" }, + { url = "https://files.pythonhosted.org/packages/8c/c2/027335f0aa337a2a2e121bac1ad88c4f02ba6053ea0926802784f3db11af/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ac8c94b6539074e0f40899301273ac8402b9b3e01c7b7ba269ff30340aaaf20", size = 266174, upload-time = "2026-08-15T08:19:05.598Z" }, + { url = "https://files.pythonhosted.org/packages/86/d3/e367787febe4e74769dec0f406f2c3c8d1b955fce5aee1fd0f94e8367a45/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8fe532b3c966d1fb794e0698e4589d0444017ae77fc0b31edea13c0e35bcc449", size = 263361, upload-time = "2026-08-15T08:19:07.251Z" }, + { url = "https://files.pythonhosted.org/packages/af/3d/391b193eb9f3e84b02f9314088c386debdc0debee843535aaea2e2c6715d/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5c84bec0ab5ae0c64bfe73a7d2adcb5ce73b467523fc27fd6a28ab2aa6cbe35a", size = 252143, upload-time = "2026-08-15T08:19:08.816Z" }, + { url = "https://files.pythonhosted.org/packages/2e/57/de221f1745a90d418199761967e2776bfe2c275a1194220985e8c1d37833/charset_normalizer-3.5.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:854066be00447fa8de2ccbbe893e2ffc4b123ef16d897af794c1e18bd4a714b0", size = 252086, upload-time = "2026-08-15T08:19:10.255Z" }, + { url = "https://files.pythonhosted.org/packages/c8/e3/d119f86a01f9331e8186175f24873b1d74a7ee9e2e4b4d68f9947dae5afd/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:21b82d8082f6f5e7f456ef0bd16323d08de1266efbfeb476e64b2a91d1471a4e", size = 245231, upload-time = "2026-08-15T08:19:11.807Z" }, + { url = "https://files.pythonhosted.org/packages/26/de/d8e48c135ae480879539cdb179c8d3b50c7879497d75dd899b5763b69cee/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:838648accb3a7fd9803fd45c87bce8509648eb0c11bc34e216141300977244f2", size = 241546, upload-time = "2026-08-15T08:19:13.416Z" }, + { url = "https://files.pythonhosted.org/packages/67/c4/217755fd1abc50d326c252922cd642002758095a81ff45010337b8b3ef65/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:195ce897c6153c0700078142cf8efe3e6454ca4cf4357499e4078dfd83396626", size = 267033, upload-time = "2026-08-15T08:19:14.981Z" }, + { url = "https://files.pythonhosted.org/packages/b8/d7/34d8e404e358d2adcc5a228c2134643af00104c8fb0bf525f3688d756f05/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:978eab16f55b4ab2c2a745be9a0a840bf8f09a7f227d9c76eb30214d078865a5", size = 252045, upload-time = "2026-08-15T08:19:16.618Z" }, + { url = "https://files.pythonhosted.org/packages/5e/fa/40414471acf0aa0692ca77305aa00e434fcd8288f0941c93c30e9a5f8f2f/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:cc0329df4caaceb950d2f580b5ac716a377f7059624a0bafaeaf8a218c6ed774", size = 264866, upload-time = "2026-08-15T08:19:18.101Z" }, + { url = "https://files.pythonhosted.org/packages/32/90/fcc850bae791abd2e0c041847f13e270aa08692a79f3e00de6d2dce1cb50/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:687c9ca3035544b113bea2055e180af96fb63c0c476e22a9180f51925186e7b7", size = 253932, upload-time = "2026-08-15T08:19:19.734Z" }, + { url = "https://files.pythonhosted.org/packages/af/af/53afe99068b3c10b4cbae592a52ef72a7c92c0188440e83ee3a078fd8f75/charset_normalizer-3.5.1-cp315-cp315-win32.whl", hash = "sha256:706bfd38730a5ac7a365793269a00f4e988178cec121391f4248d84ad8c972e9", size = 180320, upload-time = "2026-08-15T08:19:21.37Z" }, + { url = "https://files.pythonhosted.org/packages/c9/bc/f46a132041b29e4a8779ed712d3df1bf112e94ca8de58b66d7ec2c0cf8b9/charset_normalizer-3.5.1-cp315-cp315-win_amd64.whl", hash = "sha256:92caef967d287a407085d61176fce4012b1dd62daed4eb6d5ceb26d3d2538712", size = 204174, upload-time = "2026-08-15T08:19:23.088Z" }, + { url = "https://files.pythonhosted.org/packages/a1/5d/9ed554480eda8e447b673648628fdc29574d23dbad01fe11837adedd1cae/charset_normalizer-3.5.1-cp315-cp315-win_arm64.whl", hash = "sha256:5fc45d653ea8c9a20479167e11d4a0f8cb2fa3470737ab6f9c827532313187b7", size = 184126, upload-time = "2026-08-15T08:19:24.471Z" }, + { url = "https://files.pythonhosted.org/packages/3b/32/9b8929bf384061ee1fe5d9c27c6f9776d3d824039ad4e14c88ec00c7808e/charset_normalizer-3.5.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:59171c6e45bf07d0d5cab3b0bf81d945035530f6873398b3b531c31184d46663", size = 381441, upload-time = "2026-08-15T08:19:26.038Z" }, + { url = "https://files.pythonhosted.org/packages/96/10/e9aa7923d3ddac652c99a1c5f7be494e737e151566a44abe018daf757f2c/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9dbdd9205662134957cf0c324f639bdc5031c0ca056e2369e238db75187c0f11", size = 241742, upload-time = "2026-08-15T08:19:27.532Z" }, + { url = "https://files.pythonhosted.org/packages/28/53/a2d249ebddf47b889a100c0bdcb61a2f9dbb8bc24ef325cc062e4f476877/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e4b018dc5a0eee4676e38fe84a47a427816c590b93b55d9025274ec4d6ffc2dc", size = 235298, upload-time = "2026-08-15T08:19:29.274Z" }, + { url = "https://files.pythonhosted.org/packages/7d/07/469f78af590f7d5cd48e20d8dbfa3d66deeff9ba37768c04d886b5afd45c/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ced3fdd71aaa83ce593746c2edb42b7a59cb4c19c8b5c407781c72e493aae55a", size = 262500, upload-time = "2026-08-15T08:19:30.955Z" }, + { url = "https://files.pythonhosted.org/packages/55/66/3bb56a47f7dcba014055b1a1d33c6f08bbe9c1e74dba154cfa25f90ae885/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:19a3dd5aa73cef1c99687c4fc57db016a9c17104ae1185da88ba566a5d3bebe4", size = 258888, upload-time = "2026-08-15T08:19:32.458Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c1/2adc2800903fb013210349313b710a5376856578d9e33e6b9a1d8b36714a/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cc5d36d96478aa9c60654bd932525bf32964c62a7281eafdf16d85003a8d6004", size = 250243, upload-time = "2026-08-15T08:19:33.94Z" }, + { url = "https://files.pythonhosted.org/packages/95/b5/a18d0dd1157ab655cc2cb14a545f4a4784bbad70ab3502412e36097502d9/charset_normalizer-3.5.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:04368edf83514385ffc3e1cfd4546e595f4f1272dd23ba437a93a9cc3741d47b", size = 249871, upload-time = "2026-08-15T08:19:35.413Z" }, + { url = "https://files.pythonhosted.org/packages/ad/c3/525f508cd1e58d0450ac55ed40ac75bc3a97482c59def5278456a5fbf03c/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:9b5db6052055d34d41230fb78d7c439c23dc536a9896f6cb039e8dd92cfc1263", size = 243580, upload-time = "2026-08-15T08:19:36.886Z" }, + { url = "https://files.pythonhosted.org/packages/7c/c1/49a91fe7e97c8140094ca5c64161ab623a70d9f636bf834eace14048acb5/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:252d099029bcbea642f2a06c4ed5046bdf8b5a8150b64afa5e027e88b106e5ee", size = 239807, upload-time = "2026-08-15T08:19:38.392Z" }, + { url = "https://files.pythonhosted.org/packages/d3/58/56a48c296601274c4689b864a8e2dfb209b81dfcb39472753ce95eea662b/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:6199d5606e2bbf2b096cf64d03f8b6790c91081d5ac866b8e7bb6422738cc60c", size = 264083, upload-time = "2026-08-15T08:19:39.856Z" }, + { url = "https://files.pythonhosted.org/packages/10/4c/dc48409274a1817ff349711d26c62aa0c597df865d4d69ef79160c859193/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:77efcff2b23071c349402ac1066667a3d011f62398d81408c9b88ad991747c9e", size = 250317, upload-time = "2026-08-15T08:19:41.53Z" }, + { url = "https://files.pythonhosted.org/packages/81/58/d325912115caec62d6bdd77bbab5e0b7da5d234a9f20affdffcbcb530d0b/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:a5cbd90ecf0fc62e64726917ad083b73001f0563657a87ec3c0b504e277dc90d", size = 258173, upload-time = "2026-08-15T08:19:43.07Z" }, + { url = "https://files.pythonhosted.org/packages/34/f7/b13b1ccae2c8ec63980d13be1890eb73f8aeabbfce02a24aabc0908788f5/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:4d26f14f041e83dd8edfd61f4cd4fa7285d31798b5bf1f28e70c367ba6c41d61", size = 251960, upload-time = "2026-08-15T08:19:44.587Z" }, + { url = "https://files.pythonhosted.org/packages/1e/25/ed3f9919c5aef8cc818be1f972f565f7610d7b2076b8ebb98839516ffc3c/charset_normalizer-3.5.1-cp315-cp315t-win32.whl", hash = "sha256:ac13b004224fb341e1e25a1ed5e19d32f57cdb2a403e01f003b46f051a550f6f", size = 191186, upload-time = "2026-08-15T08:19:46.293Z" }, + { url = "https://files.pythonhosted.org/packages/69/d5/43c2b3e9d8267092b913eb8b0603f0f71993c395632886bd37a7223f96cf/charset_normalizer-3.5.1-cp315-cp315t-win_amd64.whl", hash = "sha256:35aea775dc2bd5f54cd84a1cd2696cc3207c479cb9cf0bd346f0d343e4300ddb", size = 215947, upload-time = "2026-08-15T08:19:47.853Z" }, + { url = "https://files.pythonhosted.org/packages/a8/76/9aad3e9c8865e5e0efa9a7f6f81c37a67635a985145ecd44528a81e088ee/charset_normalizer-3.5.1-cp315-cp315t-win_arm64.whl", hash = "sha256:fb78f6e7fcd8ad785d28cd577168bc1aaee827b25bb8755638f694794ea98f0a", size = 193909, upload-time = "2026-08-15T08:19:49.383Z" }, + { url = "https://files.pythonhosted.org/packages/5b/97/fb4e82231aba271ffd775a1b4993b0defc4e3059f286ae41d9433409fe85/charset_normalizer-3.5.1-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:41876ee62a3dddf48ff1121ad8f0798032aa03f2fd35f21f34a4cab14f18d8d2", size = 331467, upload-time = "2026-08-15T08:19:50.959Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2f/fe3f187327aac18e2d54e9d2b08e15d27bf9b642d9e51c219f130fc34d1a/charset_normalizer-3.5.1-cp37-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a6dac12ff6b846103483683f60c5f8fee205121adc58ffd87e90a90a3af69e99", size = 253057, upload-time = "2026-08-15T08:19:52.654Z" }, + { url = "https://files.pythonhosted.org/packages/d7/c7/9e48cee5c161fe24da823b61bf381921d77cb994a0a4de148e95018c1984/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cee5dd7c6fb5dd52a0fe2a740f9bc6e3593f5f8b1788bde49de02086f30182b2", size = 240930, upload-time = "2026-08-15T08:19:54.163Z" }, + { url = "https://files.pythonhosted.org/packages/49/e0/716601f3cc69be7b198951150c75ead1ece33c3c8036ff6ffa46029659a0/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:343fb4f2821043bd87095f7b08a1a181febc8e36ac64212143bbfd0a0e1bc235", size = 230822, upload-time = "2026-08-15T08:19:55.807Z" }, + { url = "https://files.pythonhosted.org/packages/d3/05/71bfc5caa0abcc45aea1f6a4d50ac68e59605ddc7666fe8494f4cd229665/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ae4a097991662cd4fff0ddc74e0fe7874f82e00042fa0ea00855645ed0c79598", size = 260037, upload-time = "2026-08-15T08:19:57.312Z" }, + { url = "https://files.pythonhosted.org/packages/c3/92/de7e32ed05341e7a9c4c877c318418197b7f2d66a3b68d561bf2ac57ca3e/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b599739b93b2cbeded49645ae3c8d1405c29ddfbceac1545c87a3f9580a9e96", size = 255097, upload-time = "2026-08-15T08:19:59.056Z" }, + { url = "https://files.pythonhosted.org/packages/f5/7b/ade0a122600319dfa0b1000ab0f9731c94a817904cf3c5de408c73a4ede7/charset_normalizer-3.5.1-cp37-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b39b69b347e5e47a3b5b8cfc005c68c1ba347474e3960236c4944a8ecd174962", size = 250166, upload-time = "2026-08-15T08:20:00.612Z" }, + { url = "https://files.pythonhosted.org/packages/75/9c/019fbb9f4834491a160951349b1a3714439376f66e5f7cf18b4f18f0c7aa/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:a2028475ba855475b8b4d3cfeb4994269c967aea8b9892dfba907f4263a863a3", size = 241821, upload-time = "2026-08-15T08:20:02.321Z" }, + { url = "https://files.pythonhosted.org/packages/2b/b8/11d4840bfc99330cc7fbcc2681ee5a044553a6e77655508d8f9b2bff7b34/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:36047af20e17097c3bb9476c2b7655f2f7aa51322c0ba58c07695bedf755a950", size = 232529, upload-time = "2026-08-15T08:20:04.008Z" }, + { url = "https://files.pythonhosted.org/packages/18/96/2b3a21492d9f65171ac75d872f5018260013d00bfa0ff70ec9f179148cbd/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:4c4fb141a727957c93edfe5c32a26ceb6b5f6461d67146e2d39f51e16170bea8", size = 260348, upload-time = "2026-08-15T08:20:05.877Z" }, + { url = "https://files.pythonhosted.org/packages/d6/aa/a69a2028e8bd052476c245460ab19d7de595de084dd968f2d75cd50c3e25/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:2f293479cce755c75f1697e87c409b7ae4c555c7dfecb6e988ad13abba943031", size = 247234, upload-time = "2026-08-15T08:20:07.487Z" }, + { url = "https://files.pythonhosted.org/packages/35/8a/3d130aeabcaf3d2466af76b7b141c08d9e89c9016ab4b7cdd0f7dc2d1c62/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_s390x.whl", hash = "sha256:3588e376b3ea2eea84976f67273d679f229e24c66dce7b82ae45aef04ff6e072", size = 256917, upload-time = "2026-08-15T08:20:09.142Z" }, + { url = "https://files.pythonhosted.org/packages/80/c2/a7379b840292d0c1ab9fbd17d1f3967aa81794dc95bc74be8999d7fedcf7/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e199fb99720074809a7720f1c0b4d919eea8b87e88713e0f8f602f7bef543d9d", size = 254846, upload-time = "2026-08-15T08:20:10.727Z" }, + { url = "https://files.pythonhosted.org/packages/01/65/d43b714731bb2f40d4053dfa00ecfc1c5a301f8e3316c5db3a09af59fe94/charset_normalizer-3.5.1-cp37-abi3-win32.whl", hash = "sha256:dd732602a7009217f658d5863d12d79d373a4de0eebc111094bcdd3bb8e0a6cc", size = 174216, upload-time = "2026-08-15T08:20:12.334Z" }, + { url = "https://files.pythonhosted.org/packages/35/4f/b911ed898b26a09789eba9c9200c999aff6c61b4bafaf4838e56d1a1e1a3/charset_normalizer-3.5.1-cp37-abi3-win_amd64.whl", hash = "sha256:70055ff39b97c99e7ae40ea3e393fb62aa2e44dbd9b29f8d14f42fb0025c3959", size = 199764, upload-time = "2026-08-15T08:20:13.908Z" }, + { url = "https://files.pythonhosted.org/packages/f0/a7/920baf467bfd9bf689f3b318340f37aee4572a71f162bd8db51da55ba4fa/charset_normalizer-3.5.1-cp37-abi3-win_arm64.whl", hash = "sha256:87e4f41d375c0b9be2fb5251aee4b8a689169e134535aed81bf085c3b647451e", size = 287318, upload-time = "2026-08-15T08:20:15.551Z" }, + { url = "https://files.pythonhosted.org/packages/cc/61/d01fc49b8dea277640b55a9e15960dbca9fdc8c9fde18e572d39c59f4019/charset_normalizer-3.5.1-py3-none-any.whl", hash = "sha256:6df0ec430f9a831772c23ca5a224cba36517a58a84bb32c32bb59a9fa67c47f6", size = 68658, upload-time = "2026-08-15T08:20:43.306Z" }, +] + +[[package]] +name = "click" +version = "8.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c7/0e/7fa0ef50764b67090eca4114772a2abf8b6148198475e54c660b97caeee6/click-8.5.0.tar.gz", hash = "sha256:ba0d2089de75ea0310e2dde03160e6ca10009947fb95a182f9b54021bb272e34", size = 382235, upload-time = "2026-08-26T13:33:14.56Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/50/6c0d534c5f134586a8e1ba4e330569e32f057e33372ae556463212fb4cd3/click-8.5.0-py3-none-any.whl", hash = "sha256:255bc9599cf7748b4b1a446ccc735421bd08a2ae529a8b88597d3de5664ee360", size = 125251, upload-time = "2026-08-26T13:33:12.928Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "cryptography" +version = "50.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bb/ad/5d6702db60b1e40b41ef513b6967ff5848f307d50f8449baf1634f5908f1/cryptography-50.0.1.tar.gz", hash = "sha256:5dd9bda1c12b4162f6ff568eeb5e0ff956c28d14406e875cfe8a63a2d414ff20", size = 880381, upload-time = "2026-08-25T19:45:45.499Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ba/19/797e2aaac9df6a66f1550f49979dc1b1e39ecd2077501c30efa81e8d5d67/cryptography-50.0.1-cp311-abi3-macosx_11_0_arm64.whl", hash = "sha256:b8f852c65863251b9e3a1b8c150ce21e59b522dbb6a7d4bc80e680d38388e986", size = 4010153, upload-time = "2026-08-25T19:44:03.155Z" }, + { url = "https://files.pythonhosted.org/packages/90/34/9ce9a62ed9dc82ca9fd6a34445b6904af56e5f38b3eae2ed32e49c36053d/cryptography-50.0.1-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:53e279950892dc102c6b4e52af03ae5ea92fac572a1ddab78ca73a997f62b69f", size = 4723133, upload-time = "2026-08-25T19:44:05.461Z" }, + { url = "https://files.pythonhosted.org/packages/57/26/e6d4fc8512a51a5f9ee7bfdbfb853bce1197087df40c9ad993ad370b846f/cryptography-50.0.1-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ff838d62ec1bfce4f9ba7fa16f4a7b554cd8d0c299e6be37502161a660c84eef", size = 4712478, upload-time = "2026-08-25T19:44:07.375Z" }, + { url = "https://files.pythonhosted.org/packages/e6/de/d3cdc2815697aae84126cbd6a030ca7b6b452e28a88b501b836bd3aa7a86/cryptography-50.0.1-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:e74591e283fe6eb956416c929eb58262a719fe0311fd9054c62c3350ed8760d8", size = 4730726, upload-time = "2026-08-25T19:44:09.294Z" }, + { url = "https://files.pythonhosted.org/packages/55/32/38c0d344b98c06d34b5df8946565a9c0d6dbf32c8e0730a7f05f0a3c6cab/cryptography-50.0.1-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:5fe002589592ed749ce77fe0695fcbd3500dd61d7d6db5858a7544c612fa8e45", size = 5353524, upload-time = "2026-08-25T19:44:11.96Z" }, + { url = "https://files.pythonhosted.org/packages/e1/1b/82f0f0d8858d4432be1af790477edf62aef90324041aa07c57e57bef1af7/cryptography-50.0.1-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:51593d180cf6d179bde5c5d065bed81386b1f381656ae7d042b7ffc87a9895ad", size = 4746720, upload-time = "2026-08-25T19:44:14.051Z" }, + { url = "https://files.pythonhosted.org/packages/29/ba/042ca458b8c64348c768284b5d23e69b92ed53d057ab779fee628564676d/cryptography-50.0.1-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:359e62deae718bce96170e223fdcb6357e4fbd3bb7a3a75f4430763532560e49", size = 4361866, upload-time = "2026-08-25T19:44:16.167Z" }, + { url = "https://files.pythonhosted.org/packages/39/3b/e96c1ef71edef71057c7e3c3d982ce8fda554e0c52d0cc19c18845cde3eb/cryptography-50.0.1-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:e2ca8fd1b6b4b82a1c4cb02841d0837e3c12336c2e24b520ab8ab3b969733d8f", size = 4730028, upload-time = "2026-08-25T19:44:18.085Z" }, + { url = "https://files.pythonhosted.org/packages/e3/38/45abd72ef63f2e7d0754a6cacf97bd8b69512ace7f6130d24c39ece65da2/cryptography-50.0.1-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:76de83fbd91ac49c0feaaa983d0748fd7a53176afac5fb3bf7478d244f0eb527", size = 5308405, upload-time = "2026-08-25T19:44:20.197Z" }, + { url = "https://files.pythonhosted.org/packages/85/66/6ccca4722987ddedaa7fc9c3f4708af7431f5535666c174350830888c6b7/cryptography-50.0.1-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:51afcfceb15597cf2635068e4ac9a56b2abde622edde17f37d85fd7b5306497a", size = 4746230, upload-time = "2026-08-25T19:44:22.376Z" }, + { url = "https://files.pythonhosted.org/packages/13/0e/b1f92e013228111413f2e6743948b80bc24dfd3c1b87ba98ceea16f5df89/cryptography-50.0.1-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:be224a65493ec5b74a158ff22a5522ce4a5ca1e543c647a3a4730d4a09e5f959", size = 4862596, upload-time = "2026-08-25T19:44:24.472Z" }, + { url = "https://files.pythonhosted.org/packages/7e/22/c3654cccc856e9d682817b04ac3ee79731cb09ca6f95996a95c904de2883/cryptography-50.0.1-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9ebcdd5519be9b652a46f507817a74591774fc3d6923ac364e4dfa64e36b291b", size = 5014082, upload-time = "2026-08-25T19:44:26.709Z" }, + { url = "https://files.pythonhosted.org/packages/42/8b/cb12b1b60c91b074ca6bf0fdd59aa8f10d8bc5f73af8faece86ef0421b37/cryptography-50.0.1-cp311-abi3-win_amd64.whl", hash = "sha256:aed8db4f6d71c51efb89530e12d9464e7bf2923d46c3205dc794a2a93f8c0648", size = 3842826, upload-time = "2026-08-25T19:44:28.784Z" }, + { url = "https://files.pythonhosted.org/packages/5b/f0/424cb557d99aa86ac55da5e2add02e2882e44047b6264f93ade1b975a993/cryptography-50.0.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:30a125032e5642a21ff816e021152bd4e7e94f03eff3f4b7fca41cd22bc3110f", size = 3973525, upload-time = "2026-08-25T19:44:30.7Z" }, + { url = "https://files.pythonhosted.org/packages/4d/72/3a2711d967977ab5fc80b782837c7e8d1ac7445e764c20c381a265c57ef3/cryptography-50.0.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a0b1a59e3a089064a0ec309e9428c8e3ae4e161419d20ac33600767e83fc658a", size = 4708817, upload-time = "2026-08-25T19:44:32.773Z" }, + { url = "https://files.pythonhosted.org/packages/b4/f2/bb1f56e10815b789df0b409a69fa4992ff3d3fef9c72747f4a6b26fed38e/cryptography-50.0.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8921d58f426793c5f1b47f0b59575780de9a095214958d0eb37d909593db8367", size = 4697300, upload-time = "2026-08-25T19:44:35.144Z" }, + { url = "https://files.pythonhosted.org/packages/08/bd/ed5396be499ffcf8807a585bfe38b71a1fbdd1c342b4f9b6d0ef5162a946/cryptography-50.0.1-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:a8f40ea47330e71b594a7e246898f93177c259490c63183dbaf9e571d71ed9a5", size = 4716039, upload-time = "2026-08-25T19:44:37.192Z" }, + { url = "https://files.pythonhosted.org/packages/f6/6e/1cf405c5c8e8df7545378048e954792f00b7f2367af8863ce8b8f3e10607/cryptography-50.0.1-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:a255449073358275b64b67d3f595f268bbef70e72b6edb65e0c70c735bf739c9", size = 5332388, upload-time = "2026-08-25T19:44:39.16Z" }, + { url = "https://files.pythonhosted.org/packages/47/92/b4317e8c32c4f47b062f5398bd79106b220a124546f42be83bf32b761e2a/cryptography-50.0.1-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:8df2de9102026855887e4587084f6eabd80ed0f345b8ad8a7ac27ab9bf4723e0", size = 4730293, upload-time = "2026-08-25T19:44:41.298Z" }, + { url = "https://files.pythonhosted.org/packages/39/0d/a1e7633e2c744d0f2983320a27e924ef2264c79c56e1a58d5fb0a1cfd413/cryptography-50.0.1-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:ac02b07824d4d1001bd4367599f839c19cb171924c796e52c23508ac14c2c0cc", size = 4346031, upload-time = "2026-08-25T19:44:43.245Z" }, + { url = "https://files.pythonhosted.org/packages/88/dd/b215616f9bab3fc18510c78a4e5c9f362d77838503c363dc747c7d4f5c6f/cryptography-50.0.1-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:cbf74a81765ee67413503ca6e26dcc4f6f5a519822436cc0a1b97aab6c1b8a17", size = 4715344, upload-time = "2026-08-25T19:44:45.291Z" }, + { url = "https://files.pythonhosted.org/packages/b1/1b/ec3ebd31741d0e963612c4fe43caa39341b9b1e031e469820e42e4c83918/cryptography-50.0.1-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:16c5ecd954b3330ebfb6605eca4fd952da8bef376551d5cc264534e3770a9ee6", size = 5287201, upload-time = "2026-08-25T19:44:47.297Z" }, + { url = "https://files.pythonhosted.org/packages/1a/01/0127d11a762b31a9ee0221894f540318761783f3fdc4bc5d057698caebd5/cryptography-50.0.1-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:79bf008d1f9af6071c797ad133e39915dfee7614f18f18f4db9072eb715064a3", size = 4730023, upload-time = "2026-08-25T19:44:49.435Z" }, + { url = "https://files.pythonhosted.org/packages/9e/b9/e7425ebfb599241a0c1d7000f1b466c3062da66c19d9525031315dff7213/cryptography-50.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:330fbb252391c596f1ae42c5754449dc924e6ad012dca8efe0d703f9f2d12ec6", size = 4847362, upload-time = "2026-08-25T19:44:51.94Z" }, + { url = "https://files.pythonhosted.org/packages/2d/fd/60d0ddf4defa12e482c9d5e0f554384d6e8ab25341fd15f060028fd92e6a/cryptography-50.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:42be3bb70596b3abe4ac097b75be223e8b3ab614a0e5de068e3dcc54d71d6149", size = 4999247, upload-time = "2026-08-25T19:44:53.876Z" }, + { url = "https://files.pythonhosted.org/packages/4d/56/bc4f2b209e766c93372cfcd59b781a0b2b59700f62a969580415b699c2b2/cryptography-50.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:f74455bb086a85d5e81246412602aaa97ed095e504cd40dd261ef50be42205bf", size = 3825806, upload-time = "2026-08-25T19:44:56.209Z" }, + { url = "https://files.pythonhosted.org/packages/84/a9/ee16a903f13755e914d1eecc482fe64d1f10761c3960e5d8fa6837377aff/cryptography-50.0.1-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:ca83d00d9e69cd5eb63f2e69c3a5a59e0cecae5ae14c6ae0b35830fe3b37bad0", size = 4035307, upload-time = "2026-08-25T19:44:58.305Z" }, + { url = "https://files.pythonhosted.org/packages/5e/a5/9ec7e81e8526c0d7a387d73386b2daed3f39e10d81a85930bd1b6bfba65c/cryptography-50.0.1-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:05ba322c4da95b262a212c345af888ef2c37c88c0509756ea00a0e6d68850f23", size = 4751900, upload-time = "2026-08-25T19:45:00.401Z" }, + { url = "https://files.pythonhosted.org/packages/7e/3c/0e77bd5ffcf078e9dd27d3074aad6c030d9b10d0bf69329d573c927a188c/cryptography-50.0.1-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e22dfed744bd4002e909464cb23d2f0b05c6f3113a79ef2e9864a53db737c733", size = 4738357, upload-time = "2026-08-25T19:45:02.786Z" }, + { url = "https://files.pythonhosted.org/packages/27/3a/3c5f80daa4dcd47323c7af8a2fcb90de27a33564d4fcac69846c0972691a/cryptography-50.0.1-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:4c4188f7c0cf655be5c06342b817ed0f9595b69ffa2b12026e5353eed29dea88", size = 4758474, upload-time = "2026-08-25T19:45:04.889Z" }, + { url = "https://files.pythonhosted.org/packages/6e/2b/214cf0cf93db9628c3c20c896b229f327f6fb1b20e4b3743d8ad3f00af8b/cryptography-50.0.1-cp39-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:2ebbfb0f1fed745e91796e3e1080a1440423fdae8ece1b995a1d80883a409054", size = 5375862, upload-time = "2026-08-25T19:45:07.163Z" }, + { url = "https://files.pythonhosted.org/packages/d6/51/3f9701867a46b6c1740c9b52fc4d3bed6cbdcfedcc9b6e64305c07f39cff/cryptography-50.0.1-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:407fe2b6db00939c05c0e945e9914238f2f0a430974839429dafc82b1ee6bee5", size = 4772942, upload-time = "2026-08-25T19:45:09.396Z" }, + { url = "https://files.pythonhosted.org/packages/0d/5c/13ea642e08e2544d0f5396122055f4820cfacb3203562197b5967125ea97/cryptography-50.0.1-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:2b34d76a652ea2b6faf777c35df230c5637842cd904e04f16230c3f9f03e4361", size = 4383347, upload-time = "2026-08-25T19:45:11.659Z" }, + { url = "https://files.pythonhosted.org/packages/84/d5/7d1fe1cb93f91c428093ff234e128c89ba8ea61a6f26aab406081f9b996e/cryptography-50.0.1-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:01f41478cf33fc605a6a089cd56d28b45c6c0b45a1928b61797f2621a04bac71", size = 4758050, upload-time = "2026-08-25T19:45:13.745Z" }, + { url = "https://files.pythonhosted.org/packages/dd/04/557fc5ead96a829e0bc812a3b9dc4a52a2f27e4f7f5950da7ff27653a805/cryptography-50.0.1-cp39-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:fc3ed7ebd2a8c96f5b166de0ab9b624996bef3b07bbeb19364dfb78222c22c80", size = 5332955, upload-time = "2026-08-25T19:45:16.193Z" }, + { url = "https://files.pythonhosted.org/packages/8c/eb/5d7124083e8d8cda8f5b348f544b71ad6f707ad63193758ef4d8e569da02/cryptography-50.0.1-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:9dde0a357190eb3b1da1bb9ab750e9c85cba82ca5977aa0836cbb94e92611239", size = 4772694, upload-time = "2026-08-25T19:45:18.315Z" }, + { url = "https://files.pythonhosted.org/packages/63/8e/f1f955e0921dd2b6d22eae7e8d24a4c4b638d10735ffbf6a71f99eb0fcb8/cryptography-50.0.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd3718b960d0b5dd213cdf03f3bcb7000e69dda0de8b956061947ff6bcff5558", size = 4888413, upload-time = "2026-08-25T19:45:20.4Z" }, + { url = "https://files.pythonhosted.org/packages/1f/ab/89e2b798d2c3925f82e2bb72d5979f3d2f6da2dd22ef4a8cd8b70d920039/cryptography-50.0.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:2a93d05e34d5f67fba6f891fe85d929999baa7195e853923ea6d7576c9e68c5e", size = 5044355, upload-time = "2026-08-25T19:45:22.353Z" }, + { url = "https://files.pythonhosted.org/packages/99/89/87ef49ffe383ef4e147d27b7bf2088fb0b54ea409dd87b5a89442e5828a5/cryptography-50.0.1-cp39-abi3-win_amd64.whl", hash = "sha256:55d16b1ef3ee0958d893a977b19777887e546c9954ea81b200c3301a864013f2", size = 3875429, upload-time = "2026-08-25T19:45:24.418Z" }, +] + +[[package]] +name = "fastapi" +version = "0.141.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-doc" }, + { name = "pydantic" }, + { name = "starlette" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8a/02/91e3416a8fdd715abb903a952a6bec7cdd8d14eed55d415fc8595524c319/fastapi-0.141.1.tar.gz", hash = "sha256:e8822fc40db1e1858054d7a949a888695bc9bdce70139178e33bd2871a453ca1", size = 425799, upload-time = "2026-07-29T17:18:05.568Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/03/10388a42375ee7e4ac9b94eb2c5c569c8b5795e377e701c9ac3ad63de890/fastapi-0.141.1-py3-none-any.whl", hash = "sha256:bfb91aa2d334c61cb35ba9a116fc123b3d3df31640b801cf57a7a78ec3f603b3", size = 131954, upload-time = "2026-07-29T17:18:04.364Z" }, +] + +[[package]] +name = "fastembed" +version = "0.8.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "huggingface-hub" }, + { name = "loguru" }, + { name = "mmh3" }, + { name = "numpy" }, + { name = "onnxruntime" }, + { name = "pillow" }, + { name = "py-rust-stemmers" }, + { name = "requests" }, + { name = "tokenizers" }, + { name = "tqdm" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/26/25/58865e36b6e8a9a0d0ff905b5601aa30db97956327c0df42ec4ed6accc21/fastembed-0.8.0.tar.gz", hash = "sha256:75966edfa8b006ee78514c726bd7f6a50721dadc89305279052be9db72fd53e8", size = 75115, upload-time = "2026-03-23T16:34:41.699Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/e8/26b7d78bb8972498c467ca34cb12ee2e60d26ba5eae6d8443189a1af37a5/fastembed-0.8.0-py3-none-any.whl", hash = "sha256:40bee672657574a1009e35ec50030a55f2b426842cb011845379817641bbbbd0", size = 116572, upload-time = "2026-03-23T16:34:40.69Z" }, +] + +[[package]] +name = "filelock" +version = "3.32.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6d/30/03b03951873a1a0ffc7e8ca0e10c15597b59e8d0e39260704cd2ea087bc4/filelock-3.32.4.tar.gz", hash = "sha256:2bde2e4cf732e0153406d8a7bc80620ecf5e621fe0d25e41143c4e3b4733ff30", size = 222126, upload-time = "2026-08-23T17:37:55.363Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/01/a4/9b63d595d748e3aff8812b65eacc1a2c4bd90b7c2012e08e72373b4835eb/filelock-3.32.4-py3-none-any.whl", hash = "sha256:22e58ca3b1ae3b98993b762d7338367ae64fe50252bf78d59da3bfebcdf1cedd", size = 99864, upload-time = "2026-08-23T17:37:53.913Z" }, +] + +[[package]] +name = "flatbuffers" +version = "25.12.19" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/2d/d2a548598be01649e2d46231d151a6c56d10b964d94043a335ae56ea2d92/flatbuffers-25.12.19-py2.py3-none-any.whl", hash = "sha256:7634f50c427838bb021c2d66a3d1168e9d199b0607e6329399f04846d42e20b4", size = 26661, upload-time = "2025-12-19T23:16:13.622Z" }, +] + +[[package]] +name = "fsspec" +version = "2026.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/00/78/f34251dadb8f3921264a1d9b8946f5e542014ee2614b285261b4e40e6775/fsspec-2026.7.0.tar.gz", hash = "sha256:c803c40f4cf860b49dea58ee3e1c33cb9c790520e233537e1340049f89b82a88", size = 317040, upload-time = "2026-07-28T16:34:51.052Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/3c/6a2bf344106328fd04963664a60b9bb6496fc25df8e962fcdc1367285fb9/fsspec-2026.7.0-py3-none-any.whl", hash = "sha256:b57ddbafedfaef7018c1ecab32aa200a9d7ca26b77965f64e48b70061249d279", size = 206583, upload-time = "2026-07-28T16:34:49.538Z" }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, +] + +[[package]] +name = "hf-xet" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/ab/522a2ab67f27971a9d48ca666d4fca85ef7d5282d142e31fd087e27b1bbe/hf_xet-1.6.0.tar.gz", hash = "sha256:2e58454a340b3556dfa4972d5451aff4fba8dd42a236600ba1a1d2b1514f0fef", size = 920527, upload-time = "2026-08-03T22:33:13.243Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/62/3c062f593bd92ef4e77a0ef39541e3d82a0a1d3947c8a777a02a13a27828/hf_xet-1.6.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:70cbb9c896901600128cb9b6f06e132954fbede1db30f31f7c6c63f84cb7c31d", size = 4074584, upload-time = "2026-08-03T22:32:47.364Z" }, + { url = "https://files.pythonhosted.org/packages/bb/1e/c0ad437dd267a8e435bef594acf781bbc3874ff0b6435b4962d03ecf7cc4/hf_xet-1.6.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:23379c2f9ec8696d952b16414a2bae72cad86a52df869b050698ba60f538c675", size = 3867381, upload-time = "2026-08-03T22:32:49.049Z" }, + { url = "https://files.pythonhosted.org/packages/d5/ee/7c0d7b6ab336167531b1c30af2af003f054af4c749becbd7209ae33a77c3/hf_xet-1.6.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f2f7278c05c22fd60cb436cda1269649b3e81db65ecdc8496e5e164aa4143e7b", size = 4453982, upload-time = "2026-08-03T22:32:50.568Z" }, + { url = "https://files.pythonhosted.org/packages/63/06/ad8eab1c9525246650cbaa821caa3cdbaca734ab1a5b8c91bea09cbd8d69/hf_xet-1.6.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:948f15d3a9545cfe5932f6bd8b440f6ae630aee108f14b7bd6c561f7c2dcc522", size = 4249445, upload-time = "2026-08-03T22:32:52.391Z" }, + { url = "https://files.pythonhosted.org/packages/d8/26/1eee8aedb0dafc1ab9717dc9ac602cde33361b232dc06803f1f6ed18b58c/hf_xet-1.6.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5153e6bb103ad49d6ea9f1b2e230db5a2ea32551ad09a706d2f61d7c7c80d80e", size = 4451099, upload-time = "2026-08-03T22:32:54.114Z" }, + { url = "https://files.pythonhosted.org/packages/67/57/0b88af1f194ab6c9c650547d9cc06bfeaab836ae4dcdb331676bfb8be95a/hf_xet-1.6.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:35cec30d75c6f9eb9c16a77cef68e85a103b72e24d4b473714ec9ff06428bab9", size = 4664712, upload-time = "2026-08-03T22:32:55.547Z" }, + { url = "https://files.pythonhosted.org/packages/53/a0/26b717a9d1840e8abf48dcec64b5ed8fbe472671d38ad28d30e147132b33/hf_xet-1.6.0-cp314-cp314t-win_amd64.whl", hash = "sha256:5789835d7c6bc9436962853192082374297fb72d7eff7e7762ec25ceb7e25338", size = 4025906, upload-time = "2026-08-03T22:32:57.391Z" }, + { url = "https://files.pythonhosted.org/packages/49/f6/4a9966633c6fef83af997e2cff68ec1963676d412bdfd096df2a93b8e185/hf_xet-1.6.0-cp314-cp314t-win_arm64.whl", hash = "sha256:75765820ce4700db3750c94acc8fe27c5fae4c9ec000a0dbac3ca082acf97765", size = 3849221, upload-time = "2026-08-03T22:32:59.123Z" }, + { url = "https://files.pythonhosted.org/packages/a2/50/7afa2c9c787405864fc47a0d1bbc02c62e9101947ed43c1f43899fc7d91d/hf_xet-1.6.0-cp38-abi3-macosx_10_12_x86_64.whl", hash = "sha256:633dc0cd71d32da58ab8c03ad38e2fac452c15c2b0a2866ebf6ededfe0a5061d", size = 4071729, upload-time = "2026-08-03T22:33:00.721Z" }, + { url = "https://files.pythonhosted.org/packages/4b/69/55b8dcf636142ae660fec1869fcac14c4da2e8412e14d6eee1523be77e9f/hf_xet-1.6.0-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:f0906082d9932ae0c0057fa194041c22b4e2cdb46b2592ef3b91f020d62a081a", size = 3876287, upload-time = "2026-08-03T22:33:02.251Z" }, + { url = "https://files.pythonhosted.org/packages/67/4e/a28359bf1c1ecf11eba22123168c138698f7cb576ac678f5a2e16cd5da08/hf_xet-1.6.0-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d62671bb130879cef0ee4c9ebe47a14af6c66ec53e6d84dc15936e5ffdfac82f", size = 4464663, upload-time = "2026-08-03T22:33:03.802Z" }, + { url = "https://files.pythonhosted.org/packages/9a/69/1f0cbc2fb22ae6082d094f743d1b8945a3f36f6089cb95f42b7ee348cda7/hf_xet-1.6.0-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:0e6e21fa3cdfcdcd76748564bf593870a5e013f47d97cf10aed63aa222cff5b7", size = 4262538, upload-time = "2026-08-03T22:33:05.287Z" }, + { url = "https://files.pythonhosted.org/packages/d1/3a/4f4f2301ade26e404462d3336fa11f7958d914cabbabdd6e03c3c5d5658c/hf_xet-1.6.0-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:4fc74352a17015bd0ee90038bc9efe38db894cde45f268b6712b04fce8cd0acb", size = 4460520, upload-time = "2026-08-03T22:33:06.81Z" }, + { url = "https://files.pythonhosted.org/packages/ab/5f/311725e2a905534dfee2dcb5b08414f249147f1f12252bfc2bd24caa075c/hf_xet-1.6.0-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:8fb4f71cba6129110c3374a33f919001ff130488fc23553698e34cc1c2a1198c", size = 4675937, upload-time = "2026-08-03T22:33:08.616Z" }, + { url = "https://files.pythonhosted.org/packages/98/b7/8c59a66d15205024662f1d66968136f13893f96df1ddc5087e2e281fc95f/hf_xet-1.6.0-cp38-abi3-win_amd64.whl", hash = "sha256:fb4fadde1b2b70bf4c0c14a6dccbe7194b1c28947fefd5bbe3fed9d940676c3b", size = 4033128, upload-time = "2026-08-03T22:33:10.171Z" }, + { url = "https://files.pythonhosted.org/packages/73/63/ca511b6f802f28cf3489b280fe77475bcca8de85e81a6299d7916b5b5555/hf_xet-1.6.0-cp38-abi3-win_arm64.whl", hash = "sha256:3dc3e35441ba395006af5aaacc40ef2e603c51ef46c3530b9156185f00935ea3", size = 3859359, upload-time = "2026-08-03T22:33:11.725Z" }, +] + +[[package]] +name = "httpcore" +version = "1.0.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, +] + +[[package]] +name = "httpcore2" +version = "2.12.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "h11" }, + { name = "truststore" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/be/ad/f4f0e57345f1870f3e8cb624e058d7eca6e5a27d33bcc3311d9b618734cd/httpcore2-2.12.0.tar.gz", hash = "sha256:9293522bba0aa7c4c8e9e3f040c16575bd8868e155a77fa30c7a9085a5eae648", size = 67548, upload-time = "2026-08-18T13:22:08.211Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/74/d370e55600d9bcfa0d9794b0166126d49291a3d2b20c268fc98c453a4948/httpcore2-2.12.0-py3-none-any.whl", hash = "sha256:7e04258ce01013d7d615e5b910a3b27fac937d7a95038227e79652b4ba3b4ceb", size = 83074, upload-time = "2026-08-18T13:22:05.854Z" }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, +] + +[[package]] +name = "httpx2" +version = "2.12.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio", marker = "sys_platform != 'emscripten'" }, + { name = "httpcore2", marker = "sys_platform != 'emscripten'" }, + { name = "httpx2-jsfetch", marker = "sys_platform == 'emscripten'" }, + { name = "idna" }, + { name = "truststore", marker = "sys_platform != 'emscripten'" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7f/f8/579a8b51e42e38ee32647df9f08aa25643ae788e275cc625b199829c4671/httpx2-2.12.0.tar.gz", hash = "sha256:7631fe9887a8a2275f4a2540e053aa670fcc50742864a9ae7c66e609fdcf12cf", size = 100040, upload-time = "2026-08-18T13:22:09.086Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/95/411ba65569158e862368917aaf56597f3e5fa3b91b0502919638465a08f3/httpx2-2.12.0-py3-none-any.whl", hash = "sha256:cc8b6eecb8661c146b8f89a60e97456ee086e91a784ed31ac450c3a9e613dd36", size = 95427, upload-time = "2026-08-18T13:22:06.834Z" }, +] + +[[package]] +name = "httpx2-jsfetch" +version = "1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/c4/0e5636363151a2a1795e0a77617168b9ca438e1748ec05fc9b5687f93d64/httpx2_jsfetch-1.0.tar.gz", hash = "sha256:70a0e3eabfef7cce5ad9c629f7d01ca05e418f586646f4ddf14782e4c1454c60", size = 6872, upload-time = "2026-08-07T00:13:07.492Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9b/43/832f631d32e4f1211caa2ba368317739fe71f0b8530e4c9d15dc454bac2a/httpx2_jsfetch-1.0-py3-none-any.whl", hash = "sha256:cb916b707601e69a07721aabc8f3f6659be3a6893bc1ff5c6f9e02241df2da32", size = 6382, upload-time = "2026-08-07T00:13:06.567Z" }, +] + +[[package]] +name = "huggingface-hub" +version = "1.29.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "filelock" }, + { name = "fsspec" }, + { name = "hf-xet", marker = "platform_machine == 'AMD64' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" }, + { name = "httpx" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "tqdm" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/64/35/42316e8f6908b6d21bc8df017cc6efba94fb5edbf99b64e28dd142325e20/huggingface_hub-1.29.0.tar.gz", hash = "sha256:6ebb385a581435325cf6d5c5b233d5d4bc91175834d99fd65dae14379b36e9ad", size = 963121, upload-time = "2026-08-27T12:18:37.432Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/a5/47c2ea9b228ccbcba8467e9a64823146e8ebbad29855e591d8f5eedcc9c7/huggingface_hub-1.29.0-py3-none-any.whl", hash = "sha256:b00f7782afc14db4bc6572763810a635bdfbab8623d957bfb553bd18e03852cd", size = 795768, upload-time = "2026-08-27T12:18:35.431Z" }, +] + +[[package]] +name = "idna" +version = "3.19" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5f/f7/abb373e5757eaec4b922b92f97ec8d6d7e057cf06778247604fbc4e7c3f3/idna-3.19.tar.gz", hash = "sha256:5e0811a4383b21dc5838069f801c4fb62113b7447663d2530d2bd6e77b49bf15", size = 215237, upload-time = "2026-08-18T05:14:24.27Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, +] + +[[package]] +name = "jsonschema" +version = "4.26.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2025.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" }, +] + +[[package]] +name = "labvoice" +version = "0.0.1" +source = { editable = "." } +dependencies = [ + { name = "aiosqlite" }, + { name = "fastapi" }, + { name = "mcp" }, + { name = "pydantic" }, + { name = "pydantic-settings" }, + { name = "uvicorn" }, +] + +[package.optional-dependencies] +embeddings = [ + { name = "fastembed" }, +] + +[package.dev-dependencies] +dev = [ + { name = "certifi" }, + { name = "pytest" }, + { name = "pytest-asyncio" }, + { name = "six" }, + { name = "urllib3" }, +] + +[package.metadata] +requires-dist = [ + { name = "aiosqlite", specifier = ">=0.20" }, + { name = "fastapi", specifier = ">=0.111" }, + { name = "fastembed", marker = "extra == 'embeddings'", specifier = ">=0.3" }, + { name = "mcp", specifier = ">=1.0" }, + { name = "pydantic", specifier = ">=2.7" }, + { name = "pydantic-settings", specifier = ">=2.2" }, + { name = "uvicorn", specifier = ">=0.30" }, +] +provides-extras = ["embeddings"] + +[package.metadata.requires-dev] +dev = [ + { name = "certifi", specifier = ">=2024.0" }, + { name = "pytest", specifier = ">=8.0" }, + { name = "pytest-asyncio", specifier = ">=0.24" }, + { name = "six", specifier = ">=1.16" }, + { name = "urllib3", specifier = ">=2.0" }, +] + +[[package]] +name = "loguru" +version = "0.7.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "win32-setctime", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3a/05/a1dae3dffd1116099471c643b8924f5aa6524411dc6c63fdae648c4f1aca/loguru-0.7.3.tar.gz", hash = "sha256:19480589e77d47b8d85b2c827ad95d49bf31b0dcde16593892eb51dd18706eb6", size = 63559, upload-time = "2024-12-06T11:20:56.608Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl", hash = "sha256:31a33c10c8e1e10422bfd431aeb5d351c7cf7fa671e3c4df004162264b28220c", size = 61595, upload-time = "2024-12-06T11:20:54.538Z" }, +] + +[[package]] +name = "mcp" +version = "2.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "httpx2" }, + { name = "jsonschema" }, + { name = "mcp-types" }, + { name = "opentelemetry-api" }, + { name = "pydantic" }, + { name = "pyjwt", extra = ["crypto"] }, + { name = "python-multipart" }, + { name = "pywin32", marker = "sys_platform == 'win32'" }, + { name = "sse-starlette" }, + { name = "starlette" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, + { name = "uvicorn", marker = "sys_platform != 'emscripten'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d4/6e/21fb8e5d579dbe21d96ea4d5034200d46d8bdf2261053b5bd041f3c2f612/mcp-2.1.1.tar.gz", hash = "sha256:50b7ba1ebbe117008ea7bdd288234043e69c20b403d6851d19661e6d431a75ef", size = 3984589, upload-time = "2026-08-25T16:14:02.376Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/50/af/8644cc5fa26a59afd2df2e98eeb19e72926887fa4b7441aba4ff661140db/mcp-2.1.1-py3-none-any.whl", hash = "sha256:1c6c31c5d6471c58db76af3af8af67f46d11d01f0a59077d0a308cbdb3d3e915", size = 357912, upload-time = "2026-08-25T16:13:59.024Z" }, +] + +[[package]] +name = "mcp-types" +version = "2.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pydantic" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6a/dd/1c4417dc0b722c23a1669032d5f044e41170fe5d4773b488a50fcce98c32/mcp_types-2.1.1.tar.gz", hash = "sha256:77dcbe48fba73cca71a673f2646a5f037a017b7a0a07ac89cec1113028890eda", size = 66674, upload-time = "2026-08-25T16:14:03.861Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/d0/242e63c510f4a17381f55b1549a3f94f5687a0595984febd2b6f87a687a0/mcp_types-2.1.1-py3-none-any.whl", hash = "sha256:26f9f7f03f2a5730717a5b98e2ab7eb640ac352d05a00cdc725c311864778295", size = 69656, upload-time = "2026-08-25T16:14:00.667Z" }, +] + +[[package]] +name = "mmh3" +version = "5.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/69/d00269fee7a3102fcc0f04f0a312e41c6b237762bdcad4c19426f18e697c/mmh3-5.3.0.tar.gz", hash = "sha256:95832419b87b882bec9dcd7d041d74887ba7745b3659c14be1ae1db5cfa35cad", size = 33607, upload-time = "2026-08-26T04:58:20.042Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/97/28c3905a7e27e100ef50322798659e0af514eff600aabffbab00e3cd27ad/mmh3-5.3.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:5e7373e6834e4bdf2c24dbb1a0c6dd834bb5a189efb65723ebb58a8f3e76204b", size = 55484, upload-time = "2026-08-26T04:56:12.197Z" }, + { url = "https://files.pythonhosted.org/packages/44/13/629beb4d3e92ffcf1486c81cbb0605d9e6685b2721eb6753946a9d217359/mmh3-5.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:430ed4de594d0084d9b7956b05075a9054d290a3a0d7b370553a9096a4fd429f", size = 40091, upload-time = "2026-08-26T04:56:13.289Z" }, + { url = "https://files.pythonhosted.org/packages/c7/64/0a5832cd45207c507ee83bb7286dfeccf51c438aa8b6217f44f286f354f4/mmh3-5.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bee76669a5b588cd806aa619ea9eb8f0c8a00e6991001d830e07cc69258962a9", size = 39694, upload-time = "2026-08-26T04:56:14.244Z" }, + { url = "https://files.pythonhosted.org/packages/13/ac/e9a157fbeebf44da5e39e49ef3901cbd68651d966658b58303074f349422/mmh3-5.3.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:c6fbc4e3017fb99e639abdb58a6a31e14bcbd270562805a0b80a102f8a4f3024", size = 97220, upload-time = "2026-08-26T04:56:15.312Z" }, + { url = "https://files.pythonhosted.org/packages/af/a6/5012e363699c598166fb955f7267975284dd51eadc0383771a1a593d4ac2/mmh3-5.3.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:98db40c6ef8bbeb028e0424736a6bef3b1d8d0a02399236eb00db0dd0b7ca957", size = 103238, upload-time = "2026-08-26T04:56:16.425Z" }, + { url = "https://files.pythonhosted.org/packages/47/53/5710edf5edd969bbc42985577ddc73758a1c90a1613ffc4356087b5e330f/mmh3-5.3.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fa216ac716e7c99e4dc4b039c6219a31cd381cc0588ca45cf66f36011613f3ed", size = 106138, upload-time = "2026-08-26T04:56:17.54Z" }, + { url = "https://files.pythonhosted.org/packages/c5/dc/e7737d142ecb5847aad04fc92d63bd455587f5dc33ebbfddeb7936f98713/mmh3-5.3.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ef9fe783b932927da8070f5b2913ce412e42c80bf17fd523042325ee3a44f756", size = 112973, upload-time = "2026-08-26T04:56:18.644Z" }, + { url = "https://files.pythonhosted.org/packages/cd/04/34e1242a23e14c78a39dd76ffdf860e76d01c917e4103b9729c27efc22f7/mmh3-5.3.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1d5de36640293374673ec6813b7a23d8a9621bbd87f079c6ec4c5e8585cb1f64", size = 120621, upload-time = "2026-08-26T04:56:19.837Z" }, + { url = "https://files.pythonhosted.org/packages/f3/6b/665f1bd97666095f8a92b4191e22c21038c3e5f6bccad2a09218962e0541/mmh3-5.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0a6bd95c410ec9500d9515a4fe522e24452f71df38de47395f99aebc085a5d5a", size = 99020, upload-time = "2026-08-26T04:56:21.07Z" }, + { url = "https://files.pythonhosted.org/packages/e7/a8/0ce084753cc8a82f8cbadcb6723f2e17c341b17683eafc49729a55db4930/mmh3-5.3.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:f0c7a36ccb66bfc8fcfa7a9722614b959231e325f0e08862c6ea70a7283a6520", size = 98497, upload-time = "2026-08-26T04:56:22.252Z" }, + { url = "https://files.pythonhosted.org/packages/01/1e/501564ca0687e4138c01c12d5b1bc049511753f5a5db2538ad662bf16d97/mmh3-5.3.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:767c6c0cf3f67c3e4e246ae7e1cc9ce7755f174f994aa3111c8357f16a587161", size = 106369, upload-time = "2026-08-26T04:56:23.375Z" }, + { url = "https://files.pythonhosted.org/packages/f7/af/7e072e63c10f81b0d4f2abff29363029144c62006baa1fbe437302d24f05/mmh3-5.3.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:408d37be08e12a154b482dcb300781d3dd154abab8e002ab32ecde6aa6a325bc", size = 109882, upload-time = "2026-08-26T04:56:24.495Z" }, + { url = "https://files.pythonhosted.org/packages/a6/89/90e3f0f59eb13b362cb0c091a1ce43b94325fae8c6c20a991dc9ee6bd0b7/mmh3-5.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a2b77b3e6a9d817822407b32c514205b44ceeb8ab197bee09de19e5f1e04ce18", size = 97421, upload-time = "2026-08-26T04:56:25.675Z" }, + { url = "https://files.pythonhosted.org/packages/f4/be/eaa4b95e3fdb2617ec1c1502ab15f5941408c02a3c80a5df63ab4c412abd/mmh3-5.3.0-cp312-cp312-win32.whl", hash = "sha256:d4cc2cb5f117da6460c14c65cbc0d1cf0976af3e56de6cd627cc36019f323e15", size = 40467, upload-time = "2026-08-26T04:56:26.804Z" }, + { url = "https://files.pythonhosted.org/packages/39/86/695592b763d2c0a5739ff50e62be102a1790bd5817a5f7f9ed2ffcbe198f/mmh3-5.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:ad5e6b56000d4b1b82a380c664982371939dc8f728fcbb73d017edc035247dcb", size = 41864, upload-time = "2026-08-26T04:56:27.779Z" }, + { url = "https://files.pythonhosted.org/packages/d1/ea/b534107b184454994865f5c1695df2f666672f16636b814da182b3ab0f6f/mmh3-5.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:4b660543eee66d5f07408fc1cdd0d017416f0f5cd1725def314cca3f67b0cac5", size = 39206, upload-time = "2026-08-26T04:56:28.789Z" }, + { url = "https://files.pythonhosted.org/packages/8b/fa/e07f6b9e2fba550fe539b6c66ee7fc28e44f5bd445a7203ae4c169d4aa72/mmh3-5.3.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:6576400e7a748ec5c7ea72f38d626939876dd1756f4a0ccf552b8646dcf6f3e9", size = 41040, upload-time = "2026-08-26T04:56:29.766Z" }, + { url = "https://files.pythonhosted.org/packages/62/9c/cb0f23e71bddcc519331c9787ec029e0d2fef64ed1bc490ad84b00a43950/mmh3-5.3.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:2b4cd2fcf1b517872530d9ef1a2de2ef9b86e5a0f8927539ea0b68337618244e", size = 42153, upload-time = "2026-08-26T04:56:30.954Z" }, + { url = "https://files.pythonhosted.org/packages/27/1c/99f2ff480922046a496c2e53728a13a467b68f01a0f48370577c0825a763/mmh3-5.3.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:f401a82d80c53d88605b82a80623edd95d922732d2c513c1c5f8e4b5e10c2913", size = 38796, upload-time = "2026-08-26T04:56:32.207Z" }, + { url = "https://files.pythonhosted.org/packages/ad/05/e137452583b33a56d053ad48643a7c56e4cf466efc8a145da6a736913ae3/mmh3-5.3.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:86238bb78ff65c9fc1e6b371b78f271e23c5d61898222c201122209dc8eadc76", size = 39474, upload-time = "2026-08-26T04:56:33.196Z" }, + { url = "https://files.pythonhosted.org/packages/74/e8/a9031fe6ed0eb06ab1c98eb76182eb01dc484dc46873a8e5ef3097d9bdf4/mmh3-5.3.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:222ea0a485e23bdcb29e28d15b8b01ebe34e8720bad4b5f92b645ed86e3fc715", size = 39983, upload-time = "2026-08-26T04:56:34.195Z" }, + { url = "https://files.pythonhosted.org/packages/f9/ae/11459b39af5341de2a048998a717f57b3a1c4e6a9edf8fe09e314b2c263c/mmh3-5.3.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d95ee6696aa5b7283f4a27b67eb7db1c4fb5bb7a9117205d29ebaaa7f6294d7b", size = 55464, upload-time = "2026-08-26T04:56:35.23Z" }, + { url = "https://files.pythonhosted.org/packages/49/b7/841b580415a614a3ad836db1cb8d57c425bbeb717c80263a9d979b1a4eac/mmh3-5.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e2f439ffd4fd7d64b77f6a287d4605700bad26fe12bb1b63b4ee45211344e2fc", size = 40084, upload-time = "2026-08-26T04:56:36.44Z" }, + { url = "https://files.pythonhosted.org/packages/02/f6/f5cb0e2f7bb7df876847dab63ee984c3f6173569d5b892edc04bc797c1b7/mmh3-5.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7f9cb34c661454f73432112a81ac522ebe69500feeb8d77f744f6bd3e8b2f2ba", size = 39693, upload-time = "2026-08-26T04:56:37.428Z" }, + { url = "https://files.pythonhosted.org/packages/b5/61/9506d0b30d7388846cc3b884ec63b8d67f3ad2d521e61775315111e70ec3/mmh3-5.3.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:b6b7397804e9299bd0c01ea426245fa3d730d3e9c31f583f51aa87bed399c481", size = 97247, upload-time = "2026-08-26T04:56:38.439Z" }, + { url = "https://files.pythonhosted.org/packages/da/6f/c6a4acf4715fede1e0acb17d6080ebe9b88290d113bbf9513a8728c65b4d/mmh3-5.3.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4a19b00097fcc8e3008bb006cd6bfaf0544e9fa2abc4cc77fbad57971a37dcc0", size = 103256, upload-time = "2026-08-26T04:56:39.52Z" }, + { url = "https://files.pythonhosted.org/packages/a3/2a/f4fe4ebf2e44f49953ed1ee6b90d329d6843ebb949e60e881dbfde84e17d/mmh3-5.3.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:83d93abf6a68d54b4e2c4c041ffcffeb94b1c9ab3171443fda3f5f19024be517", size = 106172, upload-time = "2026-08-26T04:56:40.67Z" }, + { url = "https://files.pythonhosted.org/packages/1b/61/23168dc6fa92e1d9b57905b89c694a521a00570f0fe325bc3f6422fe6119/mmh3-5.3.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:598350a6adefb5799c800fd00bbeacbc115ee560e2fd7b35f703608c1037a2ed", size = 113020, upload-time = "2026-08-26T04:56:42.035Z" }, + { url = "https://files.pythonhosted.org/packages/6e/f6/68dbb5461727bb14fbca2342a7bba4521400d679d64e00dd98a992eb0be4/mmh3-5.3.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5c0772d6bba19a5601d24b3c6ce6627484fd5a3fd1d402913e1578b1447d51a0", size = 120648, upload-time = "2026-08-26T04:56:43.339Z" }, + { url = "https://files.pythonhosted.org/packages/92/18/a879ce4c26e8c1741b575e6c854b2323fd7e116000965c8904428e66fba6/mmh3-5.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:00105934e7d52f80b4364282918c37e2cc3cf9868ef4052016cbc39d8711c3f4", size = 99034, upload-time = "2026-08-26T04:56:44.771Z" }, + { url = "https://files.pythonhosted.org/packages/1b/28/b0548d78133f8e79bb16d6487f2df504ff4e16ea1330954f26be83b645ca/mmh3-5.3.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:99a5b0a908beb01b0e134b7b085d0ea6bfb7ed28ba3ed0737365aa2ce9bda0e4", size = 98587, upload-time = "2026-08-26T04:56:46.089Z" }, + { url = "https://files.pythonhosted.org/packages/97/10/abfa952c6a443d07efb286b53b439d4418f7cfbac49fca8974cd78c17427/mmh3-5.3.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:da4ad7a0d4c589069c46101dcb55ee304616293bcf614f4c445b3ecc961fa836", size = 106407, upload-time = "2026-08-26T04:56:47.16Z" }, + { url = "https://files.pythonhosted.org/packages/a6/61/3b974a1cfe683c6cb01d2d3f2d5eddfca7e0a175d976d2307269143f4e0e/mmh3-5.3.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:8962a67c314f1da82957aee5b940698aaffff13e41b3298baa59d30cbddb23e2", size = 109922, upload-time = "2026-08-26T04:56:48.451Z" }, + { url = "https://files.pythonhosted.org/packages/0e/d2/ac7e18d6fcee3b26e06b3d33ecab4459b7aa6aff9859b13eb13e353a69ab/mmh3-5.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f61f2850b318c043961662f6cdd08e69b05f1d25d0e321782a3995d39f811548", size = 97456, upload-time = "2026-08-26T04:56:49.559Z" }, + { url = "https://files.pythonhosted.org/packages/ee/80/7911629b930d46ef8cb3165bce44f021d31361a2d7c56e35efe7b0d90493/mmh3-5.3.0-cp313-cp313-win32.whl", hash = "sha256:d7eec1b09bde3a9b6e2102717a587b9c9a96c360a1ef478b5668414619cac606", size = 40458, upload-time = "2026-08-26T04:56:50.785Z" }, + { url = "https://files.pythonhosted.org/packages/45/c7/138d77c740f9d33ceffa968786fe23abe24ce442c210772b5b7cb6e0c198/mmh3-5.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:b1829bfe98d1f6e7bd79646b78e73dcef92c5aa32aaa622b9e07bf39df98c9b5", size = 41879, upload-time = "2026-08-26T04:56:51.785Z" }, + { url = "https://files.pythonhosted.org/packages/8b/e1/4312e5c18c8ef4060c9b50f1a645c9af7c3b79fad012c18fbe64a1b17103/mmh3-5.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:3fb0d4918b7d827ac804069849fde03d516628cbbf7bffe0b957ba6f1440cca6", size = 39203, upload-time = "2026-08-26T04:56:52.746Z" }, + { url = "https://files.pythonhosted.org/packages/ac/5d/838c2260e490baa075d86900ea5179cc99a3f85b6b4377b0d3671ebc3c7e/mmh3-5.3.0-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:60d00bbddaec09e8d3259a0d8805e16b96b2709f14d9c486e29568ffe6f55993", size = 41038, upload-time = "2026-08-26T04:56:53.798Z" }, + { url = "https://files.pythonhosted.org/packages/88/83/a2ff105cd6bc7f18c19c9e5e288fa741821788834d5ddd637b5f33d879ee/mmh3-5.3.0-cp314-cp314-android_24_x86_64.whl", hash = "sha256:811f0ef99cc178becef108563505b9e5aa69a406028136874edf6513d3568f8b", size = 42168, upload-time = "2026-08-26T04:56:54.871Z" }, + { url = "https://files.pythonhosted.org/packages/d6/d9/c61e52eddb1e02a25367ef1121a14b69696f17067e3395411e0a86d69ce5/mmh3-5.3.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:9a1841be8752f46cbf58a4825f3789ea66ed9c1190be5d81327509cf757b6f5a", size = 38810, upload-time = "2026-08-26T04:56:55.878Z" }, + { url = "https://files.pythonhosted.org/packages/7f/e3/2a1bfa294ef9df2f48d298e26d1bb05b44ae5ccfab3531a66fcf16eee361/mmh3-5.3.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:24eb191910181f4f41ffa2f323d63ebe725ddb0ac461baaa2274658cbe6b4c7e", size = 39489, upload-time = "2026-08-26T04:56:56.978Z" }, + { url = "https://files.pythonhosted.org/packages/60/b8/5dc5a1c593655b8ded88a88c27532d59ba7c94dac1c51665dddf6457cfca/mmh3-5.3.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:a404419c65611d015eb03b204d3558635d97fcef149d0e8ed0ef818f7262f76b", size = 39999, upload-time = "2026-08-26T04:56:58.137Z" }, + { url = "https://files.pythonhosted.org/packages/f6/ed/cf1a8e5d5d2a74918891cd790e22779d11e3ceb0bcabacfac7d47be2ccc3/mmh3-5.3.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:b77364386164808efb1d7ea1305b14bb04fc6907aab242df3f6c04f5f0c1b371", size = 55493, upload-time = "2026-08-26T04:56:59.335Z" }, + { url = "https://files.pythonhosted.org/packages/6e/5c/4da4d6af3f10635f6042ccfb5cc54ac90a53da9a14fdf1f9168892109b49/mmh3-5.3.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:e0c195d2a2cf60c5f32928415d44d430129899b4c215d710f93179a056cf560b", size = 40158, upload-time = "2026-08-26T04:57:00.475Z" }, + { url = "https://files.pythonhosted.org/packages/d8/bf/e4be8e728d94387c673510b11120d003f929858169017ab87b852ab5ac6e/mmh3-5.3.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:bc6018e95814fd64ea8357c6e9e5608b97b1f33962c76cff60efd52f76b18a40", size = 39699, upload-time = "2026-08-26T04:57:01.561Z" }, + { url = "https://files.pythonhosted.org/packages/34/64/cbf9923093f18f16a655ed5405f8992498c542321b0cbfe92c650c778dce/mmh3-5.3.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:302e5b527b36a875abb611911142e92abac7580faec51318440149ab13b8e936", size = 97245, upload-time = "2026-08-26T04:57:02.641Z" }, + { url = "https://files.pythonhosted.org/packages/cb/74/71b8f3d20b201511cbf3a3d52f7aebf5b62f8a60d8ac1a258f093e447e09/mmh3-5.3.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0a301b316198758aabbfa3ee565e221b757645d9f94b8a9d2889bfefabbb77dd", size = 103246, upload-time = "2026-08-26T04:57:03.826Z" }, + { url = "https://files.pythonhosted.org/packages/81/87/95bb64aa64057349257c487a87c7590ca205d61cacd4248875c8ad5f0530/mmh3-5.3.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a78928eb29e96e8386eebc6c4271648e3918502a24296da7020607d74d33e622", size = 106195, upload-time = "2026-08-26T04:57:05.019Z" }, + { url = "https://files.pythonhosted.org/packages/78/36/4d87428276987949476258c116a092e2110b1cd33268236282c2a71be074/mmh3-5.3.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e7adbd0f38ead7310e1e7428f254d450857645efc761c937a7d71100cce7a3a4", size = 113066, upload-time = "2026-08-26T04:57:06.365Z" }, + { url = "https://files.pythonhosted.org/packages/dc/e2/d2edf34aff2af42afa6abcadb158096dd015234065811323208b63508c03/mmh3-5.3.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:422defa81ff5c114213033cb1ce45f3904427ec9dbfa0442a0f4656191f75f5b", size = 120634, upload-time = "2026-08-26T04:57:07.52Z" }, + { url = "https://files.pythonhosted.org/packages/13/53/904a9e87364a0b472ebc3662a6c2e705b8051a726058cb7776a6c2a0966f/mmh3-5.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:76601efc7bfe44014d7bf7d6ba9c75bbb0b426c93ce0f9216cd9ec5d384c224b", size = 99075, upload-time = "2026-08-26T04:57:08.7Z" }, + { url = "https://files.pythonhosted.org/packages/51/4c/4ee963b65c9581f429d39b1242d2579c4f74648c848c364634bb24e9a7ec/mmh3-5.3.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a5ada8e81fecfca0d934520be81117e5fdccbce7ae43612ae8aeb6c40dfd69ff", size = 98598, upload-time = "2026-08-26T04:57:09.885Z" }, + { url = "https://files.pythonhosted.org/packages/79/0a/0077b5ddb6e13c6cda29eb1b31c5cd12d3456cb625e9161e5f35cb0ed787/mmh3-5.3.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:b93c17989d23a08104acc7e1912250b2eec4d24da9983d3c5f8ca9cda8d62a02", size = 106429, upload-time = "2026-08-26T04:57:11.163Z" }, + { url = "https://files.pythonhosted.org/packages/e7/86/f07f14f4dd7c5738d0008e7311b47bb84c3a8ab55c753ba1dadc93a959c5/mmh3-5.3.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:762a03f0726850677f7f1e34a105d9121b4e11a0c20c28c56fc4b33a809c0e64", size = 109903, upload-time = "2026-08-26T04:57:12.371Z" }, + { url = "https://files.pythonhosted.org/packages/cd/7f/356303be62b1053f57a506ac33b2f536a8665dc14a69c6a8468e9f5fb6d0/mmh3-5.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6f60209149e1011b4a3f3119ad2404b06507fe077755bdfcd4ea0090f64cb399", size = 97448, upload-time = "2026-08-26T04:57:13.552Z" }, + { url = "https://files.pythonhosted.org/packages/f2/57/c131c0c246714bd6483c52360fd4bbcea86ec007b1e653de3dbdf5bebb79/mmh3-5.3.0-cp314-cp314-win32.whl", hash = "sha256:1b51409765cbec88396b7a47d87220f9a34112c74a8d0db3ca2551941f023c74", size = 41008, upload-time = "2026-08-26T04:57:14.626Z" }, + { url = "https://files.pythonhosted.org/packages/c7/f3/571defe22c618c25ba6724c7029fd2ee9977936910aef4f46398f5ec2bb6/mmh3-5.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:2585bef3623efaceb1cf4734c27bbba81b9bcb4ea5b8bf53823ca75b388933c9", size = 42437, upload-time = "2026-08-26T04:57:15.637Z" }, + { url = "https://files.pythonhosted.org/packages/34/ac/974345d0709558e4bd2f8d16c46fe480058d1ac4109e90cd5f2a2525bdb4/mmh3-5.3.0-cp314-cp314-win_arm64.whl", hash = "sha256:c1fe81cd71d35fd2770dc206a4bd818bd73b515810314e1573b9db8c9a0284db", size = 39723, upload-time = "2026-08-26T04:57:16.625Z" }, + { url = "https://files.pythonhosted.org/packages/1a/fd/70b15f5f0038c8fe2cd2a30ca83404e1282af7643ba400214deff3a19498/mmh3-5.3.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:397b26f58cb062233abe36b6cdcb99f08204f529d2384e0f3ed07901dca6a2c0", size = 57172, upload-time = "2026-08-26T04:57:17.841Z" }, + { url = "https://files.pythonhosted.org/packages/dd/8f/cf76d541a79d95254888834d0e848bab14b4f98a44e18942c26ce75bbc83/mmh3-5.3.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:fe9b3b53b0688e9e5d7358e934e87c2da5ed34d997d0ef1ec403024ea760215b", size = 40953, upload-time = "2026-08-26T04:57:18.938Z" }, + { url = "https://files.pythonhosted.org/packages/fd/74/39ca2c868a1f921db0962067e8fd8f5c31a3a4b2d0ea6bb279e8e0948cd8/mmh3-5.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:045b44b299a658f02dfb43db4037437c66290f6d00984992030648b8ffc230d0", size = 40473, upload-time = "2026-08-26T04:57:19.969Z" }, + { url = "https://files.pythonhosted.org/packages/26/0b/4427f0134223b4061146bd6131db2c3b882fcaa08068e0f0d8c1f944a3f7/mmh3-5.3.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:060888503ab547f4700e93d13f45ee0d7633f5196028529c1e98c27d5b31520d", size = 109601, upload-time = "2026-08-26T04:57:20.967Z" }, + { url = "https://files.pythonhosted.org/packages/74/f9/6ab1a4d663f0c2fea4e7aeb0bfd6be70897981cf4a71f8339b2510d89ea6/mmh3-5.3.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:816db9f5ca3da2ecc9c74481c5b0474cc4368cb94e77f40bff8493abeeac81f0", size = 117370, upload-time = "2026-08-26T04:57:22.161Z" }, + { url = "https://files.pythonhosted.org/packages/cb/ee/b559b1155998448b641ff73d03e1f1141f6390f63ace9df4e42a12120cb9/mmh3-5.3.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:27706a3a4700d34718bd1eaf89719a13bbaa269606048dd00173997562c19c92", size = 120366, upload-time = "2026-08-26T04:57:23.362Z" }, + { url = "https://files.pythonhosted.org/packages/84/7e/79821c37f93fe15ca6710764c651276c6de63e376004dad7b63bc1ddbf2f/mmh3-5.3.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2d028a0e523d0c3e478544fc8350c024a0e0d73b549dd6013af4119a87589de2", size = 125940, upload-time = "2026-08-26T04:57:24.638Z" }, + { url = "https://files.pythonhosted.org/packages/77/3d/a109fc9bf5263d14989d7aaa4a51e4f21ef3563b9413ad9c05041c4d8403/mmh3-5.3.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:10508e24e01f6b52c91577e22c4466d703c2c696d34fac1a9048e0da837a1a1c", size = 135162, upload-time = "2026-08-26T04:57:25.817Z" }, + { url = "https://files.pythonhosted.org/packages/f9/fe/fa430565444bbc68fef9fea7944ee976265bd0b39ac698cf170e266766e7/mmh3-5.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:23bafb94a90f3ce2044b8a7a36c6c98ac6830ac8df1b3c0b65faa27a1bcbc49e", size = 109984, upload-time = "2026-08-26T04:57:26.982Z" }, + { url = "https://files.pythonhosted.org/packages/d4/6f/a9810ece96d857dc05bda61341e48cbf65bca9c8b24b368724e0e150d2d4/mmh3-5.3.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:2bc13752e7d80c7ea09d09368b78fca0d52f461c5c16abee5e4f78218f3d346a", size = 111111, upload-time = "2026-08-26T04:57:28.164Z" }, + { url = "https://files.pythonhosted.org/packages/0d/e7/c17260aba7a7f111d211e382dfaa14891691ab171e0172f7d251498fd60b/mmh3-5.3.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:e87e2c89016a83a6d7b8ff4e688ee6da843c5bf46bd1dcbdd36b181639575350", size = 116837, upload-time = "2026-08-26T04:57:29.336Z" }, + { url = "https://files.pythonhosted.org/packages/91/98/bb8f8ded55483672343d6b087e0fc74cd76bc9d1dc1c18c32aa468efd096/mmh3-5.3.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:93203131f4da1824dec6ffad11ff8afa03f0690f0075efa901ad7517a261a359", size = 122993, upload-time = "2026-08-26T04:57:30.542Z" }, + { url = "https://files.pythonhosted.org/packages/aa/a7/e45b0a053c79c1567f64989d4f3bb6f44510d2da7c6a38b8f82eee94162b/mmh3-5.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d1cda1816c79bf9f7b0f7ced1b48bda64c8157a8532e1318727b4157062a5a67", size = 110150, upload-time = "2026-08-26T04:57:31.745Z" }, + { url = "https://files.pythonhosted.org/packages/16/0e/bacbff120a5218cbf33cbfb562d1435e10ff43bf20345d1125f4086ef842/mmh3-5.3.0-cp314-cp314t-win32.whl", hash = "sha256:a0eee1c2cafed49facb1fd300f684401ba5bd557d6d7dfa9bd0c13c5b0904f0c", size = 41461, upload-time = "2026-08-26T04:57:32.92Z" }, + { url = "https://files.pythonhosted.org/packages/1b/c8/263a2f5af994a2c661fde9483b0e98e737b04831895bfdefc85fd81ed65d/mmh3-5.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:55347832dc6d49731283717087551839fa46a7997929403c96599b1bc93124f1", size = 43405, upload-time = "2026-08-26T04:57:33.983Z" }, + { url = "https://files.pythonhosted.org/packages/c8/8b/221f238eb4259f42d72d154ce4c4383c65bdedd7d8823ed9e7a564978a76/mmh3-5.3.0-cp314-cp314t-win_arm64.whl", hash = "sha256:50958a182c7e189fa1408d9a28d9a37afbb3d72107cf8c6fb69b07b13506c246", size = 40286, upload-time = "2026-08-26T04:57:35.101Z" }, + { url = "https://files.pythonhosted.org/packages/7a/2e/7c57e51d1276594e2c790707d2d36cd497fd96127eb6fc311274cb8c887f/mmh3-5.3.0-cp315-cp315-android_24_arm64_v8a.whl", hash = "sha256:88a79efc9949837126358be48d3a73628b615d0f9e4a81b2f819cf324b6fedd2", size = 41041, upload-time = "2026-08-26T04:57:36.309Z" }, + { url = "https://files.pythonhosted.org/packages/60/9c/e31280eba39ffcea51e1b895acfe743f5acb5a59162cfac6009360900068/mmh3-5.3.0-cp315-cp315-android_24_x86_64.whl", hash = "sha256:0e23bb59643dd36cfc1b5b6f32ca494dcb798f46281f2fa4561d34e7de777a24", size = 42168, upload-time = "2026-08-26T04:57:37.433Z" }, + { url = "https://files.pythonhosted.org/packages/43/62/228fbfe338dfb3fd410fba5f07765cd0180792d4be62581b717dc6160d11/mmh3-5.3.0-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:e5133cc123cbbb69b585bb0b0166bf03c035787892a8b365238dd060ce02f8b1", size = 38834, upload-time = "2026-08-26T04:57:38.573Z" }, + { url = "https://files.pythonhosted.org/packages/d7/6c/bba95309795fc92947b5e2ba86b1bff97ffcd8fc56d59c40073a33cc1259/mmh3-5.3.0-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:0619b41fc524c0e1bda7b29e47a9cdb4746be3ebd9413798f82c024894283d47", size = 39543, upload-time = "2026-08-26T04:57:39.597Z" }, + { url = "https://files.pythonhosted.org/packages/3b/3d/bb4b474e5387bc4654cf945734edbdaaf9184dff507df09b624b9389208c/mmh3-5.3.0-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:c1fc62fc688e884fb6300a536297a09c089c43f9eb8228790bafa66c28e28900", size = 39997, upload-time = "2026-08-26T04:57:40.637Z" }, + { url = "https://files.pythonhosted.org/packages/8f/ba/88da42a2c9b0d3c7ce030c4c2895cdb01ed64df52c811e08e7358c16eb84/mmh3-5.3.0-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:9438a4436d33b4c71b57f20cb982f791703c868f8c497c998ec33de3b9c4ce0b", size = 55547, upload-time = "2026-08-26T04:57:41.693Z" }, + { url = "https://files.pythonhosted.org/packages/2a/96/f4c4c46ef01757e10f4b89886bc49f0fdec904ecc2da9b3844fd5a331d7b/mmh3-5.3.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:453571409c955837178bedab51d5514aeda9ee4854dcde9e9134765f22da4380", size = 40156, upload-time = "2026-08-26T04:57:42.942Z" }, + { url = "https://files.pythonhosted.org/packages/2a/01/98f2f2ab0ab87eb608841ab277f94a75772661a2b20ce3a9c1bea38f809b/mmh3-5.3.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:d54b2f5dcd78b99893d0f6f265749886ae4d316fc54ab352444e581972555210", size = 39757, upload-time = "2026-08-26T04:57:43.973Z" }, + { url = "https://files.pythonhosted.org/packages/af/0b/e7db2ea82300479c32e30c26082b88eda5744a49d41d8aa5a0fb60d6b206/mmh3-5.3.0-cp315-cp315-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:c541249b3b9b5a023a9b6c9cc29e16777926e513c97fad3e2c44956e30d5fc7d", size = 98594, upload-time = "2026-08-26T04:57:45.029Z" }, + { url = "https://files.pythonhosted.org/packages/f3/c9/046535bc0362a83b28630f68e4dbfdb2a5b5e56a6463b226a023a96ad593/mmh3-5.3.0-cp315-cp315-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1232c5667aaa2f1f77096d94dc0019ceb7ace106e9066b66d28773c4226364b0", size = 104104, upload-time = "2026-08-26T04:57:46.34Z" }, + { url = "https://files.pythonhosted.org/packages/e3/72/84dc86824533d3302dc497c8f2c7bfa5e0bcdbf340f378a3c63d05155096/mmh3-5.3.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:28de4e0a140f86bea109a6d91de9f1e9a94c9d88e6ec9d4d3c78924e4f8c0a42", size = 106562, upload-time = "2026-08-26T04:57:47.503Z" }, + { url = "https://files.pythonhosted.org/packages/88/a3/085c3e201b23430974dfee96df108daecb7142745deffec71e569dfad0bf/mmh3-5.3.0-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d1a9424ee53ac4600568f02683254237a3400af2f683060e7217f744d0833885", size = 113269, upload-time = "2026-08-26T04:57:48.613Z" }, + { url = "https://files.pythonhosted.org/packages/e9/9e/5427b7b5c8ab602a1845550d02da15acece374fe71da602e3b0f37d171b8/mmh3-5.3.0-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:90ac257fd93bcd915672262b5f93f606400c1cc29e869bb2ff806038e7234a94", size = 121343, upload-time = "2026-08-26T04:57:49.866Z" }, + { url = "https://files.pythonhosted.org/packages/ba/76/59c41858157a8138e3e0f8a95cb014bbf8105598e3ebc7b53a2254561844/mmh3-5.3.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:9063635665d5e62601d1f089526155ad2aba3c85e2050e439c774919447155aa", size = 99563, upload-time = "2026-08-26T04:57:51.069Z" }, + { url = "https://files.pythonhosted.org/packages/ec/b0/411e361db86ded7b9db1db994cd9bd8fc1c50911a6d7a959c1e101214ed2/mmh3-5.3.0-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:def4d23969c4e944a9b01ad3187893edda1cf185d5913224420a72d1959245ff", size = 99563, upload-time = "2026-08-26T04:57:52.282Z" }, + { url = "https://files.pythonhosted.org/packages/e2/16/1f8a1d767c741653100496f2e62866cc857ee14a147628538b83b9cb223d/mmh3-5.3.0-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:48ae6e629a63cdadc29264a66edbaac9f18dd77feed973880c65393820867426", size = 106573, upload-time = "2026-08-26T04:57:53.514Z" }, + { url = "https://files.pythonhosted.org/packages/41/ae/ea3879a4da99713b278639d9e55176e45a67464df7809c41d5a0bed9ada1/mmh3-5.3.0-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:4785dec2f768b74c0735c9f0441b2392111a1467c463cae737bad30ac976b524", size = 110225, upload-time = "2026-08-26T04:57:54.707Z" }, + { url = "https://files.pythonhosted.org/packages/30/73/1bc3907f97cf636316414e56b929d990c0754baffd607b560d0d52e71fdf/mmh3-5.3.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:61104a5fc2923d5670f30e3ecbcb12ed70f49a17dfd757b32bc965eb90b53988", size = 98196, upload-time = "2026-08-26T04:57:55.91Z" }, + { url = "https://files.pythonhosted.org/packages/48/7a/726967f0adb26918095a0162f55a65ffdb10e7fa4909d251b9b725f7d361/mmh3-5.3.0-cp315-cp315-win32.whl", hash = "sha256:a4fa195374868fc65fe0ddefacf080c191f7405b36c8ee4ff7ce6c749b52dff9", size = 41010, upload-time = "2026-08-26T04:57:57.145Z" }, + { url = "https://files.pythonhosted.org/packages/6f/f7/efd515b3b5665ecc5cf5113cc5c012dc8028404ace5865ab774af22f5d7a/mmh3-5.3.0-cp315-cp315-win_amd64.whl", hash = "sha256:8d58d74be01b0eb74a14cfe768495c57f3a7a7c573a9db3c984b5f2c759a0fe5", size = 42427, upload-time = "2026-08-26T04:57:58.258Z" }, + { url = "https://files.pythonhosted.org/packages/6b/f0/995893261597dbf57446862928c94b7bf3ab44f409b166d2d1404b226f06/mmh3-5.3.0-cp315-cp315-win_arm64.whl", hash = "sha256:ae30d67c5f41be6c70d28557c0a3285787dccbde46a3c84a97d01996cbf43e7c", size = 39729, upload-time = "2026-08-26T04:57:59.341Z" }, + { url = "https://files.pythonhosted.org/packages/1e/61/a77fbc2aeb88c15300f3b179b9afb0c3f6395997371232929eb750b6103a/mmh3-5.3.0-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:db98041fc5d22f1cf66b38a361cf07a15321c0f2956b6134b007733de8befe2a", size = 57216, upload-time = "2026-08-26T04:58:00.474Z" }, + { url = "https://files.pythonhosted.org/packages/15/a2/07458f4eb072d684528e2e0aee011edb473842c26cd1d69cb09c197406e9/mmh3-5.3.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:70cd0d092d872b17cf1cd66c394a0537c291c97a539bd884fd0c2bdbf989cccb", size = 40961, upload-time = "2026-08-26T04:58:01.582Z" }, + { url = "https://files.pythonhosted.org/packages/f7/84/cf430e12828032c459994c09ce8a9f0da6069a02b76359ab229266a41a8c/mmh3-5.3.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:22cf74b87b11fbe732ce6e23699d59b53208114232515975ce486d1e6b5248f8", size = 40506, upload-time = "2026-08-26T04:58:02.641Z" }, + { url = "https://files.pythonhosted.org/packages/ab/c5/00a0589cad767d51b8f431cbcd3295e385bfe4d6b1fea844dd8e8dae612f/mmh3-5.3.0-cp315-cp315t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:6ff08246d6c6dcdd6306a7d806eb75867cea6238eeb88778fc9c577d8e9fe2d9", size = 108294, upload-time = "2026-08-26T04:58:03.722Z" }, + { url = "https://files.pythonhosted.org/packages/c4/9f/730e34be444a2924cf3bfa4ac4b015b656eead79e735683efecce5a69c34/mmh3-5.3.0-cp315-cp315t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:44ca9d01e9761208de5ab845ce86096d3e730b35acc0f90cedaf58d3dfa4e325", size = 114249, upload-time = "2026-08-26T04:58:04.939Z" }, + { url = "https://files.pythonhosted.org/packages/fa/d3/771008dfe72651a95e0b91c141f5938ae346585a3d26296d51d58c7c038c/mmh3-5.3.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a2c36e6d747dcf42f5afc49b107c65c7e2be5dd8e80209244bc50c6bf2bfb81c", size = 117182, upload-time = "2026-08-26T04:58:06.164Z" }, + { url = "https://files.pythonhosted.org/packages/c9/ac/95b7c8b851fb97a6974ea955f3dbe30bf7e3692ba982043f8011b0e39ffd/mmh3-5.3.0-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:002414b951d980072a90dc25e84fe41570e399503c9db46a45edf61c7f0bd3bf", size = 122413, upload-time = "2026-08-26T04:58:07.689Z" }, + { url = "https://files.pythonhosted.org/packages/79/af/99ddc49b1993da421fd25cec9f46f558a624cc9f2e76695d999a03231197/mmh3-5.3.0-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3bfc16e0bca99ecc91d4c9fdc708c432fac2eba3797e78577f4d280031456f37", size = 130998, upload-time = "2026-08-26T04:58:08.981Z" }, + { url = "https://files.pythonhosted.org/packages/14/15/b9c7f0f6d6453a75eee6b455ee87f8839381bfdfba5ae43a2110911693e9/mmh3-5.3.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:166e3c09c56e980bfef1ee4fe4eded81d544615359eb92fb7ccda8c96f5d9538", size = 107781, upload-time = "2026-08-26T04:58:10.301Z" }, + { url = "https://files.pythonhosted.org/packages/89/b0/cd2a527717e3171ef9bb50f5391bc0fb8c5c9a5df90293132bd56a8783e9/mmh3-5.3.0-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:844f16c472352afa499d3a2ff0316cc812204bda42540af4768ac80a98b56277", size = 108860, upload-time = "2026-08-26T04:58:11.527Z" }, + { url = "https://files.pythonhosted.org/packages/74/8c/09e6e3e74386a73d533903f6e99e0fde75077af3dace436d460ae0e653f3/mmh3-5.3.0-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:1e2cc33121171b1e4657146bfdaf77eb135787465f298d9f5ed04c14771c35d2", size = 114303, upload-time = "2026-08-26T04:58:12.795Z" }, + { url = "https://files.pythonhosted.org/packages/ed/b0/d0996aa44f675f3dee627c2f90bf1c071f2424c203c5cfbe4270632bacfb/mmh3-5.3.0-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:af550cb399a702b1f277c375461fcd9533f46b435bba1e7847b4b729c6a316aa", size = 119889, upload-time = "2026-08-26T04:58:14.044Z" }, + { url = "https://files.pythonhosted.org/packages/29/9c/9cfe3e09689cbe4e381e09560be44824a143583938392bc3e48b35478dd0/mmh3-5.3.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:ecd0172b50350cae19e8dbb07789e11234099de8ea44db0a981467a98c165170", size = 107518, upload-time = "2026-08-26T04:58:15.364Z" }, + { url = "https://files.pythonhosted.org/packages/f5/be/57df5ff90b968bcce8d173df2a69f668702d0940f0d66696f259f904a373/mmh3-5.3.0-cp315-cp315t-win32.whl", hash = "sha256:9e03132ea81849b5732122d3d2f39e46a327a461eb3d678f1e74747c9b7ef154", size = 41667, upload-time = "2026-08-26T04:58:16.579Z" }, + { url = "https://files.pythonhosted.org/packages/03/73/5f5d7a5c0bad6ae5568e3232d8b7bcee9639da0de45f8e664342f22bf682/mmh3-5.3.0-cp315-cp315t-win_amd64.whl", hash = "sha256:1617be1ce93f97513bbf23cafa28a6ab1d20b0928de760054a4c603a89bdab7c", size = 43152, upload-time = "2026-08-26T04:58:17.706Z" }, + { url = "https://files.pythonhosted.org/packages/a2/0a/033fef3d7a486aa369ec11cdf0455bbae6640df13491f6e7d35fd90aa000/mmh3-5.3.0-cp315-cp315t-win_arm64.whl", hash = "sha256:a8389010a2721e568fbe40ba94e7d8f931beabd59b95af2b2ab8238fd40a6b3e", size = 40275, upload-time = "2026-08-26T04:58:18.883Z" }, +] + +[[package]] +name = "numpy" +version = "2.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9a/80/db0b4559e57ec36362bedbb05530a87fafbcb6067708c946967a41d449e7/numpy-2.5.2.tar.gz", hash = "sha256:d482d171c406ae88c5b19cad3b6a1c4c5209f886ab74bc44c2c865c23f52d860", size = 20773161, upload-time = "2026-08-09T13:48:27.962Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/72/dccb0aaf40972777283303919f613964227266d0c13adebb79ac124f1c3e/numpy-2.5.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:14e373cfc6387177e8409dac3c7159be8eb05cd77096cd7c950268b86f62831c", size = 16891693, upload-time = "2026-08-09T13:44:51.702Z" }, + { url = "https://files.pythonhosted.org/packages/60/2e/b5aee50a1f74ac815cf8331812cb8251e29024025de462e0c047641c614c/numpy-2.5.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4bbd96c833ecc8cc069ce518078fc8c60cb9cbfb0fea5b7a803ad65035596d03", size = 11903109, upload-time = "2026-08-09T13:44:55.501Z" }, + { url = "https://files.pythonhosted.org/packages/f3/f4/29e78102a80601cf034d4e9767022cffeca2c3b4c926e1754572ca95593d/numpy-2.5.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:6e8172ddfcf5cf74b811d372b570b83c60bd2de87a6fbfbebdadb4a9bd9c6cbb", size = 5350202, upload-time = "2026-08-09T13:44:58.401Z" }, + { url = "https://files.pythonhosted.org/packages/11/4b/dcd3b7eadaf4035d2c7a4289d232523a6964f602598ef7674e4bd7291f93/numpy-2.5.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:65f188481f1669e26f62b701e8205d19e460fa4a9b52a1414ba382330e4a3414", size = 6687736, upload-time = "2026-08-09T13:45:00.813Z" }, + { url = "https://files.pythonhosted.org/packages/e5/21/4947e0e9d6c9fc2e2ff15b8949049ee44f63adb9cacc729ab8793f97e712/numpy-2.5.2-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8ee9c4eeb8454b3660a8b53493563c3e121c2fc94fbd72b848ef814ed7b676a9", size = 15612696, upload-time = "2026-08-09T13:45:04.151Z" }, + { url = "https://files.pythonhosted.org/packages/3a/5f/62d28cf019460c7f1394105b4d49d9911a9c444cb77ab0bd95a204c5a6de/numpy-2.5.2-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3cdec01fa790a186d430433fdd4d4ffb70eed6f0eeb4bf05c8dbe2dce0a9bcb8", size = 16722264, upload-time = "2026-08-09T13:45:07.714Z" }, + { url = "https://files.pythonhosted.org/packages/14/25/3f0be4c1b9fdf5dd5e708a6806978564d7c46a055c000496309ff2a2f8af/numpy-2.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7999d4ddb0c4025018373fd787510d46e04c769467af22869707b3c1cfd459ab", size = 16974396, upload-time = "2026-08-09T13:45:11.316Z" }, + { url = "https://files.pythonhosted.org/packages/22/72/6262cbdeeb45da9d971e40715f579d791603ba8ec0b5e2db1ac55454421d/numpy-2.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c1f017dc0875c9209d219f97feceb7d54c2661bb243deb4114478e1295808af7", size = 18476044, upload-time = "2026-08-09T13:45:14.869Z" }, + { url = "https://files.pythonhosted.org/packages/36/33/29208b8b075bde62d26a81d14b358c42b0f69b6cabd98d4ff97f37f22b05/numpy-2.5.2-cp312-cp312-win32.whl", hash = "sha256:d6a48072864e3324e194a8fbb3c657bcc5b5c869dbc64c9537b1d5c862572c0a", size = 6072817, upload-time = "2026-08-09T13:45:17.867Z" }, + { url = "https://files.pythonhosted.org/packages/7f/b9/87fea2769fe1c47c1b5b01d8310772c9d1a85d485de7cf386ef7a3332b02/numpy-2.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:28ac63476ec7651484215ee7fa15a1f78b57c14621f01e392afe17b9a1390ce4", size = 12464674, upload-time = "2026-08-09T13:45:20.734Z" }, + { url = "https://files.pythonhosted.org/packages/14/52/032b97e00461ab0809bbe4c588b035620e5a14b8cdee47ecddefc7b17d33/numpy-2.5.2-cp312-cp312-win_arm64.whl", hash = "sha256:27650bb0e7140fa3d37b9923b4803645e0b125d190f326eecfd3f4dad8e8ade1", size = 10397131, upload-time = "2026-08-09T13:45:23.73Z" }, + { url = "https://files.pythonhosted.org/packages/f5/d2/6b24738a0ef4557d189b150046cd07823c50e4273e8aebd651222e24306f/numpy-2.5.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8e4cb9a754c8a0c62eaa88273a5fba3391f4a610d1dee893c0755da31c083f15", size = 16886595, upload-time = "2026-08-09T13:45:27.323Z" }, + { url = "https://files.pythonhosted.org/packages/65/60/f2d208d366f263f39c6e69ed309290717aab41078b6d04c9be2a84fa2a07/numpy-2.5.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:52c808f96484f5571a5cc863775ce50247c17dfb3b0361f8ed6b4b0456f80080", size = 11896845, upload-time = "2026-08-09T13:45:31.638Z" }, + { url = "https://files.pythonhosted.org/packages/3c/79/81e0bf24f4d020a2b1d5cd297a9f60c3f24eeb116f9bba5870443f7b6a4a/numpy-2.5.2-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:29d81e97f668489cba8ebfd796b9bdd453525d35dd9e162e2daec94bf3fc7740", size = 5343880, upload-time = "2026-08-09T13:45:34.373Z" }, + { url = "https://files.pythonhosted.org/packages/ba/cc/e3141cf06d1a8a2c7e107543fe1269c1d1af760d4d683c0794a4ee1127c2/numpy-2.5.2-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:afb3f0632d6b2e3ba04dbce8d1e48d321b369138b73830b5ca371a0e8d479d56", size = 6682264, upload-time = "2026-08-09T13:45:36.7Z" }, + { url = "https://files.pythonhosted.org/packages/29/f1/2a64a307d92c5d98f5255a4014eb43bb6103ee477087b61ecae44a3aa9b9/numpy-2.5.2-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0aadf13b60048d501e05fa699efaf7734e2494f3498a4c2a5521d822640324f3", size = 15609566, upload-time = "2026-08-09T13:45:39.518Z" }, + { url = "https://files.pythonhosted.org/packages/7b/44/59a1eb68e773c4098d107ef34a0dbdeca501d72ffcfbff9a7707343921ce/numpy-2.5.2-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:29b86ff8a6cc556b47ec6b64b194815cc80e6bf5eedcc6cddfd65318cb0b4eee", size = 16709995, upload-time = "2026-08-09T13:45:43.661Z" }, + { url = "https://files.pythonhosted.org/packages/8a/4c/3e54d4ddbc359a1295f8b633e8106bcd4d7d4a206e82df051bdfb3058755/numpy-2.5.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6950c4b7dd562453090548ba7f5da7e59f57f85663f15d5dcc60e249192f7e59", size = 16972511, upload-time = "2026-08-09T13:45:47.094Z" }, + { url = "https://files.pythonhosted.org/packages/f2/9f/02e371638ebf19b66d46231e4be52999e87f32d1961b113bc45656608b22/numpy-2.5.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b9727f472d2f3888053b8a75ab0cb94745a9de224bb5846dbadc0092101bc71d", size = 18465609, upload-time = "2026-08-09T13:45:50.808Z" }, + { url = "https://files.pythonhosted.org/packages/eb/ae/ad6645abc7a3510fe48e8ea1ab4598166f500057ef4ebf38bfad4f1577de/numpy-2.5.2-cp313-cp313-win32.whl", hash = "sha256:4f9744f9fbdcea0bc552e8f19e1f141f811a3f9bc2be2cc6e86d982cab23e3f4", size = 6070204, upload-time = "2026-08-09T13:45:54.111Z" }, + { url = "https://files.pythonhosted.org/packages/15/20/f3489f86d81ea460b2bcdceaed094142ca6579f6be0ec527b781d39afe68/numpy-2.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:85aaccb24182c25df891ad0ec333585967e115269d5f1b17f2c9ae005bc96657", size = 12460532, upload-time = "2026-08-09T13:45:57.167Z" }, + { url = "https://files.pythonhosted.org/packages/d5/21/35b31dde1b283b79de828b80f876afd8c94e28fe1e9c375f89e261cc4c0d/numpy-2.5.2-cp313-cp313-win_arm64.whl", hash = "sha256:bd68ece1553d2023c09a4226d9e41c586ad2d20594d1a456186c33513d2cb3f2", size = 10396725, upload-time = "2026-08-09T13:46:00.478Z" }, + { url = "https://files.pythonhosted.org/packages/ac/f8/c3b222bf075b50afd8e949a07a15c4b312a4a84bd8102a332bcd953cbbb4/numpy-2.5.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d787cf769c3baeb5f6235e778edb52c08dfa923789b5958f28e6450f96107cb1", size = 16885180, upload-time = "2026-08-09T13:46:03.939Z" }, + { url = "https://files.pythonhosted.org/packages/17/e1/2c1d4b1987795a92b5bbf7c24fe249ab96aa2573ab0d7604802c189d7b86/numpy-2.5.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:24b9dc2e3d84aa58523798805194e23e736f3f6ce2d1a5b92583ae734e6dbda8", size = 11907878, upload-time = "2026-08-09T13:46:07.045Z" }, + { url = "https://files.pythonhosted.org/packages/b9/ee/d08226fc858044355983a6e5b94f08ff6f3969e0a2b160a4a89f0ddb3445/numpy-2.5.2-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:9e9413326d726c2545bfa65d2c0876871e8d8386e77f992c1d426e180bbd4323", size = 5354922, upload-time = "2026-08-09T13:46:10.04Z" }, + { url = "https://files.pythonhosted.org/packages/94/f0/6d3d933056440ebbc5e6bad92065fc6c26a48a84a36b1208580e94eea76c/numpy-2.5.2-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:60e902ac295855348a5ca2ea4c89108989a9f5fddfad3dfc0a8f36b10358567e", size = 6679168, upload-time = "2026-08-09T13:46:12.275Z" }, + { url = "https://files.pythonhosted.org/packages/c4/3b/ecd49dd90033cceb2704d88ca905d4d7d89b0e8c739608754ffd325fa820/numpy-2.5.2-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:50e500dc868e9313530ce12ba470fe50ff3afe3d62993ed6eff652dacd555b65", size = 15624501, upload-time = "2026-08-09T13:46:15.322Z" }, + { url = "https://files.pythonhosted.org/packages/c7/99/461bd36dbdfac6c1c53efa370bd55a83227542d0d118f1677dbf1a3dacd5/numpy-2.5.2-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:318b9a4c845dbea06708a29c84ee429cc3065048db34cdb799047643492050ee", size = 16713701, upload-time = "2026-08-09T13:46:18.949Z" }, + { url = "https://files.pythonhosted.org/packages/f9/9c/2b251df9e8a5d647b62b0cbc1b90a91850c1cf4859ecb532fd0b4eacff6c/numpy-2.5.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:34c319e2963be042673fb46570501b2f06c41924e17e3563d58646b4380dfb68", size = 16986065, upload-time = "2026-08-09T13:46:23.006Z" }, + { url = "https://files.pythonhosted.org/packages/8f/25/20de43f53ff1390534a124475055a19f01fe10c920a0fd11b8e18d6d6052/numpy-2.5.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f06571a052127dc1b4e8b83029b4d1b20daa2b64a31cdd181fc6bc774e9000eb", size = 18470031, upload-time = "2026-08-09T13:46:27.102Z" }, + { url = "https://files.pythonhosted.org/packages/56/5e/0c577ca308d6da5eb79b546ba10bbe5b60148192194e2da060913b1de4f1/numpy-2.5.2-cp314-cp314-win32.whl", hash = "sha256:2cc779226e476d1e1f08c74068c419e60f41a9e0e069c92f6671d31d5c985e98", size = 6121028, upload-time = "2026-08-09T13:46:30.046Z" }, + { url = "https://files.pythonhosted.org/packages/15/5c/7bcbd5b11f94199073320410cddcbb80cee62415bfeb540874b265c2d922/numpy-2.5.2-cp314-cp314-win_amd64.whl", hash = "sha256:7587f53dfbd5edc0f7b87c6217b4c6d2d1f2ef9c3da70bc1315e7db5f8d7ec9d", size = 12597627, upload-time = "2026-08-09T13:46:32.886Z" }, + { url = "https://files.pythonhosted.org/packages/87/bc/4d0b06fba0da90ccc75af62823cb9dcedb6c9ea0cffa058cb2c9ee773a77/numpy-2.5.2-cp314-cp314-win_arm64.whl", hash = "sha256:3e4c367352d3747784248a227fbec218e193b56f7e6692e3b64fc805478ecfdf", size = 10680414, upload-time = "2026-08-09T13:46:36.036Z" }, + { url = "https://files.pythonhosted.org/packages/cd/17/f429aac9dc08833a0d0f188eba38c532a751b1a1f2ca6018a37b455cb321/numpy-2.5.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b879fb674276e331513fb136b78dbc6bd3c848309e0d841cfd63be3896c4cfc1", size = 12026967, upload-time = "2026-08-09T13:46:39.084Z" }, + { url = "https://files.pythonhosted.org/packages/ca/9f/d0849de96a2a4ceaa16662f18ee13eaa9c0aa418269fdc8c4857c56b11da/numpy-2.5.2-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:fd0d703772bba096843785bd38371e31bb4a0c1151497ad5739d182114a73f7f", size = 5473874, upload-time = "2026-08-09T13:46:42.075Z" }, + { url = "https://files.pythonhosted.org/packages/89/3c/8df216d4a4a5422a3de045301cf7df8ea47286d76f5cb7160b0128ac26b7/numpy-2.5.2-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:3a2f061cebd9e3d23bdcfaaded5e2293a4c6a5b60fa42df85d410a725ce621bf", size = 6789276, upload-time = "2026-08-09T13:46:44.387Z" }, + { url = "https://files.pythonhosted.org/packages/e6/3a/20d7e9891c4ddfadd6ff8d95bf4b29f353d8e1770553de2099880551dfb9/numpy-2.5.2-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6df895598c0edcb41030126c89e0f353b07d93238116143b7405e937359736c4", size = 15659154, upload-time = "2026-08-09T13:46:47.538Z" }, + { url = "https://files.pythonhosted.org/packages/aa/d6/f3aa3d2688bf501b858835c6bd087ae9b51a56ae6fca8e2b0990abd177af/numpy-2.5.2-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1ab3d4a901f844ea836c3e80bf463c6a27d7f3c14e8e292fcf28d348b25b9bce", size = 16748909, upload-time = "2026-08-09T13:46:51.442Z" }, + { url = "https://files.pythonhosted.org/packages/7d/8f/1c5cae8d2baf86ab802ae97a00be55bc7e21ebc11b12bbc33376c5f05342/numpy-2.5.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:cebc2d6dbb605a7703d59751dea4bd6b0ab127a5a4338a6f432df1936fef8b26", size = 17027685, upload-time = "2026-08-09T13:46:55.095Z" }, + { url = "https://files.pythonhosted.org/packages/5c/27/71d3467404aedc1c24ce79610f91b52b0b0f466c43a701aa56fc75c145ab/numpy-2.5.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:eaca7ff36f0f52e2111ec71f169d8fd3e889e7ddc0d2592e0d703fd8d3ce8fac", size = 18501181, upload-time = "2026-08-09T13:46:59.09Z" }, + { url = "https://files.pythonhosted.org/packages/14/2f/42921d27c40aea7e077f4a423ae509fd9220b028cd787bafefd8ab2b3a5f/numpy-2.5.2-cp314-cp314t-win32.whl", hash = "sha256:ddf47472af2e4280d79bac82304f5e80150211f1b9e614b760061d5fdfbb6eba", size = 6271085, upload-time = "2026-08-09T13:47:01.903Z" }, + { url = "https://files.pythonhosted.org/packages/75/e6/bad5f5d56de9b1971bac959963dda276d35c40f1854475005434bbe08692/numpy-2.5.2-cp314-cp314t-win_amd64.whl", hash = "sha256:44ef9675d908e65f9953063837c3277730f3f4437615a4cdab67b366cabaf884", size = 12787971, upload-time = "2026-08-09T13:47:04.963Z" }, + { url = "https://files.pythonhosted.org/packages/df/05/f608795cb34391acd67e38d94a3c36abd8d8576293a3a80727d7595c372c/numpy-2.5.2-cp314-cp314t-win_arm64.whl", hash = "sha256:eaa088384c46f519dacb93b7ec483a6d6b19a4a2085ae4f25ab9b1c43d387d1e", size = 10750306, upload-time = "2026-08-09T13:47:07.976Z" }, + { url = "https://files.pythonhosted.org/packages/33/c6/28de0191c5f82b7d42a0a51390ba98587048aa93a39fafb05bdbe6e8d00c/numpy-2.5.2-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:078f9b027b478c9379b9677babbf0f8b8f1ecfada27636d7b9a93990c638739f", size = 16885274, upload-time = "2026-08-09T13:47:11.439Z" }, + { url = "https://files.pythonhosted.org/packages/dd/d1/973ca116000d244897e468ea1aff30b589e5022e3c8744b71706fe33bd57/numpy-2.5.2-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:50a68f4bacd8a2b33d8da3d2269d0d78500f86ea582e4786dc10f5ef2c2c6842", size = 11907846, upload-time = "2026-08-09T13:47:15.128Z" }, + { url = "https://files.pythonhosted.org/packages/78/d9/8c4b3937ef204cb2fd88d389ccd0f265a2ffb11f35a01d2064cf46714bd6/numpy-2.5.2-cp315-cp315-macosx_14_0_arm64.whl", hash = "sha256:e79aba74ffaf5f78a050d777c184cddf8fdffabab38acf5f3ef1fecbc17895d6", size = 5354892, upload-time = "2026-08-09T13:47:18.07Z" }, + { url = "https://files.pythonhosted.org/packages/74/9b/b6ee65ea2999fdb7023935e108e6fb776ee4082aa15f159acfa857e578c8/numpy-2.5.2-cp315-cp315-macosx_14_0_x86_64.whl", hash = "sha256:9a0731745a72a184490a582fb4af2533512bd071ace67785b5fdffc0ae58dce8", size = 6679309, upload-time = "2026-08-09T13:47:20.456Z" }, + { url = "https://files.pythonhosted.org/packages/43/f3/acb18d8b137a393c8e7803a8c994c9e64bde3930692a69d826993113a159/numpy-2.5.2-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4ec954036759bcee3aa484f8603bd9c14f3e776293b85578b8734c2d72777c69", size = 15625850, upload-time = "2026-08-09T13:47:24.365Z" }, + { url = "https://files.pythonhosted.org/packages/a9/bf/a8e9bb0db815a0e265b5744ebedd3af0bd5faad8604e5b50a1cd012f3c91/numpy-2.5.2-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dc649493697006bc90614a5f0bbc8cb3cb1866715c474e473694968d7e6b99ab", size = 16713664, upload-time = "2026-08-09T13:47:27.965Z" }, + { url = "https://files.pythonhosted.org/packages/0c/c3/6e913736b3dd6582344af32418b5fb9dab34282e8a8174ae1d54ceb0fc13/numpy-2.5.2-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:cf7de32f486e4ac9e2d93b810f9e9ac72a728dd46a32a0bb403222f27f653514", size = 16986749, upload-time = "2026-08-09T13:47:31.541Z" }, + { url = "https://files.pythonhosted.org/packages/80/09/7d3b23eff5c7428ef6c01e6f7052bb60d504c4d33e317b36b8959c24ad97/numpy-2.5.2-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:2ffa7bacab3e2ee1b19ed31766bb60bb380b68c23f051e199c5cc598afd68710", size = 18470495, upload-time = "2026-08-09T13:47:35.364Z" }, + { url = "https://files.pythonhosted.org/packages/a5/a4/68a321d825374f6eb677ffe8ef8c6b9a328304e6fd2e39d9530822776607/numpy-2.5.2-cp315-cp315-win32.whl", hash = "sha256:6b588cc8f902d6bff201c19fd00c43ab8545671e3554d014e12e14139e5e8617", size = 6120696, upload-time = "2026-08-09T13:47:38.561Z" }, + { url = "https://files.pythonhosted.org/packages/c8/23/deafbb1700f79fae9cd1e91220f133d124cc267de1b584da3fbf6db2f6cd/numpy-2.5.2-cp315-cp315-win_amd64.whl", hash = "sha256:07d4e89f3a9ab0a9ba24264ccdb642b3dd951b2281e8883a5481a4aa79cc31a7", size = 12597324, upload-time = "2026-08-09T13:47:41.401Z" }, + { url = "https://files.pythonhosted.org/packages/33/cd/3272ba105e3bbbdaeb11357eda31e7a6825ffe159e8171665660299a948f/numpy-2.5.2-cp315-cp315-win_arm64.whl", hash = "sha256:a610dc7e3c52edd39c2bc2375ff9c3fd59cb3ad00e4472d36f83bc1457145788", size = 10680466, upload-time = "2026-08-09T13:47:44.873Z" }, + { url = "https://files.pythonhosted.org/packages/0e/0e/58370637b1bb70a5c9ce2b43f4b521ccb224e36ccb76a6596b17ae4b447c/numpy-2.5.2-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:40f4d451aed46a8046a1aae41c4e55fb3612273df9c502480135e1501576a34b", size = 16993947, upload-time = "2026-08-09T13:47:48.97Z" }, + { url = "https://files.pythonhosted.org/packages/10/93/2abcb807712b289d6d60fe4cf30532f98974a8396d885650f3ba5a13026e/numpy-2.5.2-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:c081cbe16ba1ab53078e5ff29013621e33c509eedab055775d956427712c236e", size = 12025331, upload-time = "2026-08-09T13:47:52.646Z" }, + { url = "https://files.pythonhosted.org/packages/8b/3a/2898e003a5fbaf87e76c039b4ee1f5eb390471b4ffe74887c1f34c4e791e/numpy-2.5.2-cp315-cp315t-macosx_14_0_arm64.whl", hash = "sha256:0090ccdd57ec2703e9b49d0bf554767370581c1dd0a6b2bb2b2d9def317d042a", size = 5472336, upload-time = "2026-08-09T13:47:55.403Z" }, + { url = "https://files.pythonhosted.org/packages/61/a5/23f69d07c544597b29758b31b55c27dc9d541012a2c1496189fef702aec2/numpy-2.5.2-cp315-cp315t-macosx_14_0_x86_64.whl", hash = "sha256:6a9bb119fb8dd21ba30b3f0e555b7e2b081bd9883af21ec9c1c633d161cda3a8", size = 6788387, upload-time = "2026-08-09T13:47:58.192Z" }, + { url = "https://files.pythonhosted.org/packages/15/ea/c0dbdbcf22f43782510a3e492dd3da73c6112b69cac8929d16d127536fc4/numpy-2.5.2-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a839318485284a6fb31be4f8f2c91c8f2cb22f4543c4a8903f12b0671ffe07cc", size = 15667096, upload-time = "2026-08-09T13:48:01.562Z" }, + { url = "https://files.pythonhosted.org/packages/fc/5e/29c73c31748cdb0f7566642125ba17fd5b56780cddf891b085dab27e4466/numpy-2.5.2-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba0a474801b8dc67b66bf465548abc90e82b44d2611b5770f33008dcabffe8ec", size = 16751730, upload-time = "2026-08-09T13:48:05.706Z" }, + { url = "https://files.pythonhosted.org/packages/47/95/02501e8454796bb58dadf7a99d3181e0b464bf264e1003039572f9779fac/numpy-2.5.2-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:0a4035ae1129ff8777f08bfbd44f1e5d8e9c049ce0c2dd78fc0d92c13e7251c0", size = 17038686, upload-time = "2026-08-09T13:48:09.627Z" }, + { url = "https://files.pythonhosted.org/packages/0e/b5/53a681d91b5c82687067d8ea5035e02d917b5509d6f334cb06484a954714/numpy-2.5.2-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:77843ca236b777e67f8d6b3660ea116e499612703a0ecd7093f316201eb9d8e2", size = 18507727, upload-time = "2026-08-09T13:48:13.744Z" }, + { url = "https://files.pythonhosted.org/packages/42/06/6e11443f7b64ee376c860506091103bf68f92d2cab9e8d96d4501babf07c/numpy-2.5.2-cp315-cp315t-win32.whl", hash = "sha256:7354826bc6f8f69402e9b7fe28d15fcd34feebd74f856f111585c5b0c9fb0251", size = 6269775, upload-time = "2026-08-09T13:48:17.543Z" }, + { url = "https://files.pythonhosted.org/packages/f1/18/195d6b86cd72dbbc501edfa778005fa6b87afd34c153e46028cd3a0938f4/numpy-2.5.2-cp315-cp315t-win_amd64.whl", hash = "sha256:e5651f3f87add730ee6608d915009e19c911fba0cb000c7e3ea994b7d768eb12", size = 12782559, upload-time = "2026-08-09T13:48:21.023Z" }, + { url = "https://files.pythonhosted.org/packages/b4/07/458c344f0f0c178f4481dad5cca790626ffe4c34eabf9467069d06ee4999/numpy-2.5.2-cp315-cp315t-win_arm64.whl", hash = "sha256:5f8e00be2ec6f45f4e8a41a527f68d44a7d96fee92a650e4d8b1326f77f61e6e", size = 10748103, upload-time = "2026-08-09T13:48:24.21Z" }, +] + +[[package]] +name = "onnxruntime" +version = "1.29.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "flatbuffers" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "protobuf" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/d4/80/381c1e9efed9cc32d00aa7cab0547dc84116cec906c3ffe3613686d6963a/onnxruntime-1.29.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:3a3814c041251d6a77fdf513fb282056538ee826d2f1178a0df3c549d3fff6ba", size = 21430049, upload-time = "2026-08-17T22:53:48.286Z" }, + { url = "https://files.pythonhosted.org/packages/30/12/4be0e345d38fe707a701ca07e8f63c05b152a2e6285d1e43a7faf63fedd2/onnxruntime-1.29.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:d2fb19e848f7c33ed8d3182b52504aaa11c5e8da438bbb47296f85b133cbcf6b", size = 20816870, upload-time = "2026-08-17T22:53:51.169Z" }, + { url = "https://files.pythonhosted.org/packages/96/eb/e6968f5e41aac3125f2ff5708855f09cb0b70d85ed3115b625b0b58305ba/onnxruntime-1.29.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:2b80d8c7ec2cc7438e4da3760b88c24568cba72c9ace96d668800a6c79419acb", size = 23136745, upload-time = "2026-08-17T22:53:53.92Z" }, + { url = "https://files.pythonhosted.org/packages/b4/80/5b28f1f1111210fc4a336ddbc6950f468ebf9a6a265420568f4f43fa33ce/onnxruntime-1.29.0-cp312-cp312-win_amd64.whl", hash = "sha256:4acf2b4948b7ede87221ca6332344b8facdc8059d6ac751a7d367d04532b02dd", size = 14001407, upload-time = "2026-08-17T22:53:56.486Z" }, + { url = "https://files.pythonhosted.org/packages/6f/d6/6883f89ea4b044e6e8447ebfaf9bcecdf457b7d80a683635e130b25498e0/onnxruntime-1.29.0-cp312-cp312-win_arm64.whl", hash = "sha256:dc61a79cb39afd66ab3f01fd2c23591a7f01de89c1668e1fb6315067fc279164", size = 13746981, upload-time = "2026-08-17T22:53:58.977Z" }, + { url = "https://files.pythonhosted.org/packages/41/f8/d375facf60edaf41f5732f9f689c98a800fcc52df5cf6ddfb406703eb5a1/onnxruntime-1.29.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:be0f8ed688cfb1d4d5765a137193b7bfab0c8ea214eed99260b380bb525a3a7f", size = 21429708, upload-time = "2026-08-17T22:54:01.44Z" }, + { url = "https://files.pythonhosted.org/packages/c9/17/b9ad04051a8c4f504852ce0e8e10f9a6b2f1a331eedcdcc503df776dd0ea/onnxruntime-1.29.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:d67673c5367727860922c5262d724472f1b5539fb7ccf4c81a638f9b71719803", size = 20816263, upload-time = "2026-08-17T22:54:04.088Z" }, + { url = "https://files.pythonhosted.org/packages/83/2c/d8eb945d2a372149df9705a8d5c8d7c6c46c987c5446dbcea9e1ea7f6556/onnxruntime-1.29.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:e2128f31f449e922c62dbe5d8b6b7b079f0bcaf2d56a102fa203cb6e5bb5ab19", size = 23136817, upload-time = "2026-08-17T22:54:06.714Z" }, + { url = "https://files.pythonhosted.org/packages/e1/3b/66b424c63fa92dfaa48d1719efaae66fc8c256b9426a832eda51d8dfe1e9/onnxruntime-1.29.0-cp313-cp313-win_amd64.whl", hash = "sha256:2945e1f82f81f27e88decea88c7861f45baea23818950d467bf3909aa303119e", size = 14001310, upload-time = "2026-08-17T22:54:09.13Z" }, + { url = "https://files.pythonhosted.org/packages/83/22/d6a700e3a6322fa3d56fbe7cee9ffc53f35e77ffcd6b7e97f4b7722a27ab/onnxruntime-1.29.0-cp313-cp313-win_arm64.whl", hash = "sha256:4b940b0d777590c7e20bf298f5c16af1ea6ad1b400a1c822a6be192f64f4d954", size = 13747112, upload-time = "2026-08-17T22:54:11.608Z" }, + { url = "https://files.pythonhosted.org/packages/4a/89/c4af146de3d60a32c89fea48d5d34bfd044faaf8957270043a03bd1b462b/onnxruntime-1.29.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:533f8370ce124304e5cb08ab961836cf755631e3dd77adc5f3bbdab70c2b7d99", size = 20826136, upload-time = "2026-08-17T22:54:14.315Z" }, + { url = "https://files.pythonhosted.org/packages/9d/f2/e6bbacd11dfe8d070613261a758795ea128b9fc9bea391a2a7da2e4c7a08/onnxruntime-1.29.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:c1ad3f437153fe77f9d01a08fbaac0beb030e09b8a80ace1603bcf69b6c95481", size = 23138951, upload-time = "2026-08-17T22:54:17.154Z" }, + { url = "https://files.pythonhosted.org/packages/ff/a3/718e1b83096a1bc7b0fc8014c23d4cf795559fe666961cfac4fc038a4871/onnxruntime-1.29.0-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:e74b278af1d949876f5d91d1268fd6c680e79f2bac194967394eaba9fdf69e7e", size = 21431104, upload-time = "2026-08-17T22:54:20.118Z" }, + { url = "https://files.pythonhosted.org/packages/4e/17/c75e78ddc1fe69b6ebaef7fe88ac83f29bfe10955e3a0d2436d93473c91c/onnxruntime-1.29.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:939e5d65f332e6d399774b2bd0d3559fd8fa629c1e77833db29d968d2384f23d", size = 20818488, upload-time = "2026-08-17T22:54:23.147Z" }, + { url = "https://files.pythonhosted.org/packages/65/54/9f197c578d3d3d7bea16971e233e5483981228eec73748585cf7b5933403/onnxruntime-1.29.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:6c0c37b92f67ed68dd36221ce0403e1d9bd4f7efce724439978a2597848530e5", size = 23136994, upload-time = "2026-08-17T22:54:26.321Z" }, + { url = "https://files.pythonhosted.org/packages/24/53/4616a55d2495679cfd0195f968feb3d74fe30e26467d168ee243ac97c089/onnxruntime-1.29.0-cp314-cp314-win_amd64.whl", hash = "sha256:4a3129ae56e70d2618ff773920166916310370a7e3cacb60b9e0e8910092725f", size = 14350643, upload-time = "2026-08-17T22:54:28.794Z" }, + { url = "https://files.pythonhosted.org/packages/0a/0f/c338cb5500a522c7e671a3bb1276f4562404fbecce8a0e274565aa968484/onnxruntime-1.29.0-cp314-cp314-win_arm64.whl", hash = "sha256:e417ef8628dcce310d2d53023e750ea298ec14d4341ae6dc3a572bfd9bc7fa97", size = 14124294, upload-time = "2026-08-17T22:54:31.015Z" }, + { url = "https://files.pythonhosted.org/packages/b8/e7/61064289a9a1301b25c1f0f574fe98aba31c2d388db3c1dbec664f78621f/onnxruntime-1.29.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:11264bb58f7b7cf6af835ab10d36838d73680580820fd6f51d90124a1ca8f449", size = 20826174, upload-time = "2026-08-17T22:54:34.283Z" }, + { url = "https://files.pythonhosted.org/packages/60/21/d0c04b561b46e9bff89b5f500fb7415b8ca0669f7902204f76ab06bb0c7e/onnxruntime-1.29.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:1ea91cef3b971506e51ae9c37c16d027774ec64994a524ec1bdfb027d68a9832", size = 23138547, upload-time = "2026-08-17T22:54:37.491Z" }, +] + +[[package]] +name = "opentelemetry-api" +version = "1.44.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ee/8b/aa9e2d8b8dfa7c946f7dec5d1f8f6ba8eca062f43509a06bdb5ce93d26c0/opentelemetry_api-1.44.0.tar.gz", hash = "sha256:67647e5e9566edcf421166fdf022b3537f818635daa852b289e34604dc6fb33a", size = 72406, upload-time = "2026-07-16T15:25:32.678Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ca/6f/a04e900f465ff3221ccc395522503e2d10e79fa21f2723c8e177aae1e0d1/opentelemetry_api-1.44.0-py3-none-any.whl", hash = "sha256:94b98c893a91b88657eaac1e3ba89618cdb85be6918196705354f34728b2cdef", size = 60018, upload-time = "2026-07-16T15:25:11.657Z" }, +] + +[[package]] +name = "packaging" +version = "26.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" }, +] + +[[package]] +name = "pillow" +version = "12.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", hash = "sha256:3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce", size = 47025035, upload-time = "2026-07-01T11:56:38.965Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/37/bf/fb3ebff8ddcb76aac5a01389251bbbb9519922a9b520d8247c1ca864a25d/pillow-12.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ba09209fbe443b4acccebe845d8a138b89a8f4fbaeedd44953490b5315d5e965", size = 5345969, upload-time = "2026-07-01T11:54:06.397Z" }, + { url = "https://files.pythonhosted.org/packages/d8/66/9a386a92561f402389a4fc70c18838bf6d35eb5eb5c6850b4b2dc64f5048/pillow-12.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ffd0c5368496f41b0944be820fcb7a838aa6e623d250b01acf2643939c3f99d7", size = 4780323, upload-time = "2026-07-01T11:54:09.351Z" }, + { url = "https://files.pythonhosted.org/packages/25/27/ac8f99618ffd3dde21db0f4d4b1d2ab00c0880595bfd17df103f7f39fd0c/pillow-12.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d9c7f76c0673154f044e9d78c8655fb4213f6ca31a836df48b40fe5d187717b9", size = 6266838, upload-time = "2026-07-01T11:54:11.71Z" }, + { url = "https://files.pythonhosted.org/packages/84/21/a35af28dcc61f37ed850a2d64c65c701321dfbf25085e469d5559360cbbf/pillow-12.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:78cb2c6865a35ab8ff8b75fd122f6033b92a62c82801110e48ddd6c936a45d91", size = 6940830, upload-time = "2026-07-01T11:54:13.732Z" }, + { url = "https://files.pythonhosted.org/packages/eb/51/8b08617af3ad95e33ce6d7dd2c99ed6c8298f7fb131636303956be022e25/pillow-12.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e491916b378fba47242221bb9ead245211b70d504f495d105d17b14a24b4907c", size = 6344383, upload-time = "2026-07-01T11:54:15.756Z" }, + { url = "https://files.pythonhosted.org/packages/1d/72/cf78ac9780bb93c28328f408973845a309d4d145041665f734572ced1b52/pillow-12.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0dd2064cbc55aaec028ef5fbb60fa47bb6c3e7918e07ff17935284b227a9d2df", size = 7052934, upload-time = "2026-07-01T11:54:17.721Z" }, + { url = "https://files.pythonhosted.org/packages/20/20/25e0f4dc178a6bc0696793720055519a0de89e7661dae886992decbd2f81/pillow-12.3.0-cp312-cp312-win32.whl", hash = "sha256:dbce0b29841537a2fa4a214c2bbf14de3587c9680caa9b4e217568472490b28f", size = 6472684, upload-time = "2026-07-01T11:54:19.839Z" }, + { url = "https://files.pythonhosted.org/packages/45/89/da2f7971a317f83d807fdd4065c0af40208e59e692cc43d315a71a0e96d1/pillow-12.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:a2b55dd6b2a4c4b7d87ffa56bdb33fdc5fdb9a462173861a7bc097f17d91cb09", size = 7227137, upload-time = "2026-07-01T11:54:22.025Z" }, + { url = "https://files.pythonhosted.org/packages/de/47/4845a0a6c0dbf1db8456bd9fc791f13c5ced7ced20606d08a0aacfd25b49/pillow-12.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:331b624368d4f1d069149002f25f44bc61c8919ce8ddb3c45bdad8f6e2d89510", size = 2568267, upload-time = "2026-07-01T11:54:24.051Z" }, + { url = "https://files.pythonhosted.org/packages/9d/ac/31fb64e1e7efb5a4b50cd3d92049ba89ac6e4d8d3bb6a74e15048ca3353e/pillow-12.3.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:21900ce7ba264168cd50defae43cd75d25c833ad4ad6e73ffc5596d12e25ac89", size = 4161684, upload-time = "2026-07-01T11:54:25.934Z" }, + { url = "https://files.pythonhosted.org/packages/87/b4/9805e23d2b4d77842b468513841fda254ee42f0289d25088340e4ff46e2d/pillow-12.3.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4e8c2a84d977f50b9daed6eeaf3baef67d00d5d74d932288f02cb94518ee3ace", size = 4255487, upload-time = "2026-07-01T11:54:27.935Z" }, + { url = "https://files.pythonhosted.org/packages/df/39/ecf519435a200c693fe053a6ee4d835b41cf963a4dfc2551c4e637cb2a71/pillow-12.3.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:ae26d61dfa7a47befdc7572b521024e8745f3d809bd95ca9505a7bba9ef849ec", size = 3696433, upload-time = "2026-07-01T11:54:29.813Z" }, + { url = "https://files.pythonhosted.org/packages/42/92/2fc3ffad878ae8dd5469ec1bc8eb83b71f48e13efdf68f02709003982a32/pillow-12.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7a743ff716f746fc19a9557f60dab1600d4613255f8a7aeb3cdde4db7eb15a66", size = 5345889, upload-time = "2026-07-01T11:54:31.97Z" }, + { url = "https://files.pythonhosted.org/packages/10/76/8803c13605b763d33d156c4678fc77f8443389c0c51c8aef707bb02015f4/pillow-12.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d69141514cc30b774ceea5e3ed3a6635c8d8a96edf664689b890f4089111fb35", size = 4780109, upload-time = "2026-07-01T11:54:34.026Z" }, + { url = "https://files.pythonhosted.org/packages/1f/01/e18aff37cb0b4aac47ac90f016d347a49aca667ef97f190b06ac2aabc928/pillow-12.3.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f7401aebd7f581d7f83a439d87d474999317ee099218e5ad25d125290990ba65", size = 6263736, upload-time = "2026-07-01T11:54:36.131Z" }, + { url = "https://files.pythonhosted.org/packages/f7/62/de5bdd77d935331f4f802edc11e4d82950f642caad6cb2f949837b8560e2/pillow-12.3.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0847a763afefb695bc912d7c131e7e0632d4edc1d8698f58ddabec8e46b8b6d3", size = 6937129, upload-time = "2026-07-01T11:54:38.216Z" }, + { url = "https://files.pythonhosted.org/packages/70/4d/105627a13300c5e0df1d174230b32fd1273062c96f7745fd552b945d1e1d/pillow-12.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:571b9fcb07b97ef3a492028fb3d2dc0993ca23a06138b0315286566d29ef718a", size = 6339562, upload-time = "2026-07-01T11:54:40.354Z" }, + { url = "https://files.pythonhosted.org/packages/6b/1d/f13de01a553988ab895ba1c722e06cf3144d4f57656fd5b81b6d881f1179/pillow-12.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:756c768d0c9c2955feb7a56c37ea24aea2e369f8d36a88da270b6a9f19e62b5e", size = 7049439, upload-time = "2026-07-01T11:54:42.489Z" }, + { url = "https://files.pythonhosted.org/packages/c9/f9/066794cca041b969964f779ee5fa66a9498bbf34248ac39c5d7954e4198f/pillow-12.3.0-cp313-cp313-win32.whl", hash = "sha256:a876864214e136f0eb367788dbd7df045f4806801518e2cfe9e13229cfe06d8f", size = 6473287, upload-time = "2026-07-01T11:54:44.9Z" }, + { url = "https://files.pythonhosted.org/packages/a6/9b/7a58e61d62be561da3a356fe2384d4059a6345fc130e23ef1c36a5b81d24/pillow-12.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:1cca606cd25738df4ed873d5ad46bbdb3d83b5cbca291f6b4ff13a4df6b0bbe8", size = 7239691, upload-time = "2026-07-01T11:54:47.141Z" }, + { url = "https://files.pythonhosted.org/packages/aa/b0/c4ed4f0ef8f8fa5ee8351537db6650bb8189f7e118842978dd6589065692/pillow-12.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:b629de27fda84b42cde7edef0d85f13b958b47f6e9bbcbba9b673c562a89bd8b", size = 2568185, upload-time = "2026-07-01T11:54:49.137Z" }, + { url = "https://files.pythonhosted.org/packages/dc/01/001f65b68192f0228cc1dbbc8d2530ab5d58b61037ba0587f946fea607cd/pillow-12.3.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:9cf95fe4d0f84c82d282745d9bb08ad9f926efa00be4697e767b814ce40d4330", size = 4161736, upload-time = "2026-07-01T11:54:51.156Z" }, + { url = "https://files.pythonhosted.org/packages/1a/d2/0219746d0fd16fc8a84498e79452375be3797d3ce4044596ce565164b84f/pillow-12.3.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:8728f216dcdb6e6d555cf971cb34076139ad74b31fc2c14da4fafc741c5f6217", size = 4255435, upload-time = "2026-07-01T11:54:53.414Z" }, + { url = "https://files.pythonhosted.org/packages/c8/02/8d0bc62ef0302318c46ff2a512822d2610e81c7aa46c9b3abe6cbaca5ad0/pillow-12.3.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:a45650e8ce7fafffd731db8550230db6b0d306d181a90b67d3e6bca2f1990930", size = 3696262, upload-time = "2026-07-01T11:54:55.739Z" }, + { url = "https://files.pythonhosted.org/packages/85/e2/73c77d218410b14f5f2d565e8a998d5317b7b9c75368d29985139f7a46f0/pillow-12.3.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ba54cfebe86920a559a7c4d6b9050791c20513650a1952ebe3368c7dc70306f8", size = 5350344, upload-time = "2026-07-01T11:54:57.657Z" }, + { url = "https://files.pythonhosted.org/packages/c7/da/32c752228ae345f489e3a42499d817b6c3996da7e8a3bc7a04fc806b243b/pillow-12.3.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e158cb00350dc278f3b91551101aa7d12415a66ebf2c91d8d5ac14e56ddd3ad0", size = 4780131, upload-time = "2026-07-01T11:54:59.713Z" }, + { url = "https://files.pythonhosted.org/packages/b1/9d/8b2c807dbef61a5197c047afe99823787eb66f63daf9fb2432f91d6f0462/pillow-12.3.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9aeb04d6aef139de265b29683e119b638208f88cf73cdd1658aa07221165321", size = 6263757, upload-time = "2026-07-01T11:55:01.778Z" }, + { url = "https://files.pythonhosted.org/packages/5c/44/c85361f65dbe00eea8576ee467c768d25129989efb76e94f205e9ca9bb46/pillow-12.3.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:251bf95b67017e27b13d82f5b326234ca62d70f9cf4c2b9032de2358a3b12c7b", size = 6936962, upload-time = "2026-07-01T11:55:03.93Z" }, + { url = "https://files.pythonhosted.org/packages/18/7e/e483414b35800b86b6f08dbbc7803fb5cd52c4d6f897f47d53ea2c7e6f65/pillow-12.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fe3cca2e4e8a592be0f269a1ca4835c25199d9f3ce815c8491048f785b0a0198", size = 6339171, upload-time = "2026-07-01T11:55:05.989Z" }, + { url = "https://files.pythonhosted.org/packages/f0/f4/68c491844841ede6bed70189546b3ee9731cf9f2cbad396faff5e1ccba45/pillow-12.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:23aceaa007d6172b02c277f0cd359c79492bbb14f7072b4ede9fbcaf20648130", size = 7048116, upload-time = "2026-07-01T11:55:08.131Z" }, + { url = "https://files.pythonhosted.org/packages/a3/34/77f3f793fed8efc7d243f21b33c5a3f0d1c97ee70346d3db855587e155ff/pillow-12.3.0-cp314-cp314-win32.whl", hash = "sha256:af8d94b0db561cf68b88a267c5c44b49e134f525d0dc2cb7ed413a66bc23559a", size = 6467209, upload-time = "2026-07-01T11:55:10.408Z" }, + { url = "https://files.pythonhosted.org/packages/f1/e0/492879f69d94f91f60fc8cd05ba03650e9520afebb2fb7aa12777d7c7f38/pillow-12.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:fdafc9cce40277e0f7a0feabce0ee50dd2fa1800f3b38015e51296b5e814048d", size = 7237707, upload-time = "2026-07-01T11:55:12.745Z" }, + { url = "https://files.pythonhosted.org/packages/c9/ac/6b11f2875f1c2ac040d84e1bbf9cf22a88038f901ca1037898b280b38365/pillow-12.3.0-cp314-cp314-win_arm64.whl", hash = "sha256:e91206ee562682b51b98ef4b26a6ef48fd84e15fd4c4bc5ec768eb641d206838", size = 2565995, upload-time = "2026-07-01T11:55:14.736Z" }, + { url = "https://files.pythonhosted.org/packages/52/69/c2208e56af9bfc1913afb24020297a691eb1d4ef688474c8a04913f65e04/pillow-12.3.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:164b31cd1a0490ab6efae01aa5df49da7061be0af1b30e035b6e9a1bfe34ee6e", size = 5352503, upload-time = "2026-07-01T11:55:17.076Z" }, + { url = "https://files.pythonhosted.org/packages/07/70/e5686d753e898a45d778ff1718dba8516ead6ab6b95d85fc8c4b70650cf2/pillow-12.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5afb51d599ea772b8365ae807ae557f18bccfe46ab261fd1c2a9ed700fc6eb17", size = 4782956, upload-time = "2026-07-01T11:55:19.448Z" }, + { url = "https://files.pythonhosted.org/packages/d5/37/25c6692f06927ee973ff18c8d9ee98ad0b4d84ee67a09610c2dd1447958e/pillow-12.3.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3edce1d53195db527e0191f84b71d02022de0540bf43a16ed734ed7537b07385", size = 6322855, upload-time = "2026-07-01T11:55:21.613Z" }, + { url = "https://files.pythonhosted.org/packages/cc/91/420637fcb8f1bc11029e403b4538e6694744428d8246118e45719f944556/pillow-12.3.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bf16ba1b4d0b6b7c8e534936632270cf70eb00dbe09005bc345b2677b726855c", size = 6989642, upload-time = "2026-07-01T11:55:24.006Z" }, + { url = "https://files.pythonhosted.org/packages/10/08/b94d7811281ccf0d143a1cf768d1c49e1e54af63e7b708ab2ee3eb87face/pillow-12.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:24870b09b224f7ae3c39ed07d10e819d06f8720bc551847b1d623832b5b0e28d", size = 6391281, upload-time = "2026-07-01T11:55:26.252Z" }, + { url = "https://files.pythonhosted.org/packages/d2/87/24233f785f55474dc02ce3e739c5528a77e3a862e9333d1dd7a25cc31f70/pillow-12.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:30f2aa603c41533cc25c05acd0da21636e84a315768feb631c937177db558931", size = 7096716, upload-time = "2026-07-01T11:55:28.318Z" }, + { url = "https://files.pythonhosted.org/packages/23/26/fcb2f6e37175b04f53570b59937867e2b80ee1685e744023153028fc14f9/pillow-12.3.0-cp314-cp314t-win32.whl", hash = "sha256:4b0a7fe987b14c31ebda6083f74f22b561fd3739bc0ac51e019622e3d72668c7", size = 6474125, upload-time = "2026-07-01T11:55:30.956Z" }, + { url = "https://files.pythonhosted.org/packages/90/de/3634abee5f1c9e13c56787b7d5517b0ba8d6de51700b95578cf338349c9f/pillow-12.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:962864dc93511324d51ddbb5b9f8731bf71675b93ca612a07441896f4688fb8c", size = 7242939, upload-time = "2026-07-01T11:55:34.044Z" }, + { url = "https://files.pythonhosted.org/packages/ce/2a/fd13f8eb24de5714a6eb444a3d67e2842c6c576e159a43793adf23051351/pillow-12.3.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0740a512dc522224c77d9aa5a8d70d8b7d73fb91f2c21125d8d025d3b8990e45", size = 2567506, upload-time = "2026-07-01T11:55:35.988Z" }, + { url = "https://files.pythonhosted.org/packages/5d/dc/8fdce34ec725a33c81c6ba122b904d6b9024e50ea9ac7bede62fab54506c/pillow-12.3.0-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:0feb2e9d6ad6c9e3c06effe9d00f3f1e618a6643273576b016f591e9315a7139", size = 4162063, upload-time = "2026-07-01T11:55:37.941Z" }, + { url = "https://files.pythonhosted.org/packages/76/66/2044b9a63d3b84ff048228dfcb7cd9bf0df983e8470971bf7d4c57b693de/pillow-12.3.0-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:9e881fca225083806662a5c43d627d215f258ff43c890f831966c7d7ba9c7402", size = 4255549, upload-time = "2026-07-01T11:55:40.022Z" }, + { url = "https://files.pythonhosted.org/packages/52/7e/1f67e6f4ece6b582ee4b539decbcc9f848dc245a93ed8cd7338bafef72f1/pillow-12.3.0-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:4998562bf62a445225f22e07c896bb04b35b1b1f2eb6d760584c9c51d7a5f78c", size = 3696331, upload-time = "2026-07-01T11:55:41.98Z" }, + { url = "https://files.pythonhosted.org/packages/12/40/d306fc2c8e4d45d7f175c77edca7063be7b86fe7fe6e68f4353bf71d808c/pillow-12.3.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:dc624f6bc473dacdf7ef7eb8678d0d08edf15cd94fad6ae5c7d6cc67a4e4902f", size = 5350370, upload-time = "2026-07-01T11:55:44.028Z" }, + { url = "https://files.pythonhosted.org/packages/dd/44/668fb1437e8ce420f62d6106eb66e44a5971602a4d794615bdf79315d82d/pillow-12.3.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:71d6097b330eea8fd15097780c8e89cb1a8ce7838669f48c5bacd6f663dd4701", size = 4780147, upload-time = "2026-07-01T11:55:46.073Z" }, + { url = "https://files.pythonhosted.org/packages/0c/08/93fa2e70e30a2d81547e481b6ee2bb9522117221fb1e0ce4b5df70967677/pillow-12.3.0-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:28ce87c5ab450a9dd970b52e5aca5fe63ed432d18a2eaddd1979a00a1ba24ace", size = 6273659, upload-time = "2026-07-01T11:55:48.264Z" }, + { url = "https://files.pythonhosted.org/packages/f8/6d/043e96ff814fc31a33077e4cba86082167db520c93632afdf2042febbb0c/pillow-12.3.0-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6b02afb9b97f65fbca5f31db6a2a3ba21aa93030225f150fa3f249717e938fb4", size = 6947439, upload-time = "2026-07-01T11:55:50.503Z" }, + { url = "https://files.pythonhosted.org/packages/af/92/ba71d2ee2ac0edf3fa33bd9d5ee9ee080da70b1766f3ca3934f9938ddac9/pillow-12.3.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:1182d52bc2d5e5d7d0949503aa7e36d12f42205dc287e4883f407b1988820d39", size = 6353577, upload-time = "2026-07-01T11:55:52.697Z" }, + { url = "https://files.pythonhosted.org/packages/0f/ce/e63064e2122923ff687c8ad792d0d736a7b3920a56a46982e81a7fdd25d6/pillow-12.3.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:e795b7eb908249c4e43c7c99fac7c2c75dab0c43566e37db472a355f63693d71", size = 7060394, upload-time = "2026-07-01T11:55:55.149Z" }, + { url = "https://files.pythonhosted.org/packages/54/76/a09cc3ccc8d773a7283d34c38bec1708f9e3cc932093cbc4c5e71ac4060b/pillow-12.3.0-cp315-cp315-win32.whl", hash = "sha256:57b3d78c95ba9059768b10e28b813002261d3f3dfc55cc48b0c988f625175827", size = 6467375, upload-time = "2026-07-01T11:55:57.769Z" }, + { url = "https://files.pythonhosted.org/packages/3e/03/1846c49ba3b1d5550392a4bbd06d6fb4578e1cd91a803198b5c90f5f7d53/pillow-12.3.0-cp315-cp315-win_amd64.whl", hash = "sha256:fa4ecea169a355be7a3ade2c783e2ed12f0e40d2c5621cda8b3297faf7fbb9f5", size = 7237048, upload-time = "2026-07-01T11:55:59.975Z" }, + { url = "https://files.pythonhosted.org/packages/fb/bb/89f35dcc79610423f9f195504d7def7f0d1416a711541b42867e25fe3412/pillow-12.3.0-cp315-cp315-win_arm64.whl", hash = "sha256:877c3f311ff35410f690861c4409e7ccbf0cd2f878e50628a28e5a0bb689e658", size = 2566006, upload-time = "2026-07-01T11:56:02.143Z" }, + { url = "https://files.pythonhosted.org/packages/30/88/707027ba09942dfa2c28759b5c222d769290a41c6d20ea60ec250801941f/pillow-12.3.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:e9871b1ffbfa9656b60aeee92ed5136a5742696006fa322b29ea3d8da0ecc9cf", size = 5352509, upload-time = "2026-07-01T11:56:04.2Z" }, + { url = "https://files.pythonhosted.org/packages/b0/6d/00352fa25332c2569cd387851f568cc5a4b75a9adbfb37ac4fbce4c02eec/pillow-12.3.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:53aa02d20d10c3d814d536aa4e5ac9b84ca0ff5a88377963b085ad6822f93e64", size = 4783167, upload-time = "2026-07-01T11:56:06.631Z" }, + { url = "https://files.pythonhosted.org/packages/13/4f/9e049dfa21af7c22427275720e2490267ba8138120add5c4c574deb69782/pillow-12.3.0-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:446c34dcc4324b084a53b705127dc15717b22c5e140ae0a3c38349d4efec071e", size = 6329237, upload-time = "2026-07-01T11:56:08.868Z" }, + { url = "https://files.pythonhosted.org/packages/36/16/cf6eeaae8d0fce8dd390a33437cf68c5d5bd73834a2bc6e2f14efda0ab45/pillow-12.3.0-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cf1845d02ad822a369a49f2bb9345b1614744267682e7a03527dc3bf6eea1777", size = 6997047, upload-time = "2026-07-01T11:56:11.379Z" }, + { url = "https://files.pythonhosted.org/packages/1e/69/dbf769bdd55f48bf5733cac28edc6364ffaa072ec9ba336266e4fe66be55/pillow-12.3.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:186941b6aef820ad110fb01fb06eb925374dc3a21b17e37ec9a53b250c6fe2d1", size = 6400440, upload-time = "2026-07-01T11:56:13.908Z" }, + { url = "https://files.pythonhosted.org/packages/a0/e1/ffc9cfc2eea0d178da8018e18e959301ad9d6bc9f3edb7181e748a474b97/pillow-12.3.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:f13c32a3abd6079a66d9526e18dad9b6d280384d49d7c54040cd57b6424041d9", size = 7105895, upload-time = "2026-07-01T11:56:16.575Z" }, + { url = "https://files.pythonhosted.org/packages/18/f0/a5595c1e8c3ae44b9828cb2f0fa8155e5095ef04d6327b8f61cf44a3df85/pillow-12.3.0-cp315-cp315t-win32.whl", hash = "sha256:1657923d2d45afb66526e5b933e5b3052e6bdea196c90d3abb2424e18c77dae8", size = 6474384, upload-time = "2026-07-01T11:56:18.855Z" }, + { url = "https://files.pythonhosted.org/packages/e4/04/62bcd9f844984c5938d3b05264a61d797a29d3e0812341a8204af70bbdee/pillow-12.3.0-cp315-cp315t-win_amd64.whl", hash = "sha256:8cd2f7bdda092d99c9fc2fb7391354f306d01443d22785d0cbfafa2e2c8bb418", size = 7243537, upload-time = "2026-07-01T11:56:21.214Z" }, + { url = "https://files.pythonhosted.org/packages/3d/68/1f3066acedf37673694a7141381d8f811ae97f30d34413d236abe7d489f1/pillow-12.3.0-cp315-cp315t-win_arm64.whl", hash = "sha256:06ff022112bc9cbf83b60f8e028d94ad87b60621706487e65f673de61610ab59", size = 2567491, upload-time = "2026-07-01T11:56:23.506Z" }, +] + +[[package]] +name = "pluggy" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, +] + +[[package]] +name = "protobuf" +version = "7.36.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a7/e7/0553e21d25ca4d9f573135775348a372c3ec34a93a71d5f297c3bac38341/protobuf-7.36.0.tar.gz", hash = "sha256:e8e09cb0d794c6687926fa558a8a6e72aa10edb997d5ca61da0765f12a3e00ea", size = 510034, upload-time = "2026-08-20T16:34:01.071Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/ae/58e3ca96cb2e118cc546b677359b3c6659f79a140935c08dec94c7998585/protobuf-7.36.0-cp310-abi3-macosx_10_9_universal2.whl", hash = "sha256:9103532dffd80c6fab7e50c65a31007680a06eb57537d437bb1b35812c138a37", size = 453256, upload-time = "2026-08-20T16:33:53.945Z" }, + { url = "https://files.pythonhosted.org/packages/f0/15/5162230af4912697f0fe406f6800f80760945babcff0e2c2fe6c84ef2d5d/protobuf-7.36.0-cp310-abi3-manylinux2014_aarch64.whl", hash = "sha256:bf94a5917c71058262de683669bc0a797a7669d3de71f0b36d058e3194f47b44", size = 341436, upload-time = "2026-08-20T16:33:55.134Z" }, + { url = "https://files.pythonhosted.org/packages/d7/09/1670b2bfc9a45e807e520c3e9be36524db9ccc7dc05ea17af7681cabdc61/protobuf-7.36.0-cp310-abi3-manylinux2014_s390x.whl", hash = "sha256:3297e60abdff301e5f74393d87f6cc59dacab5f024a89548a6e8de1d26576b16", size = 354440, upload-time = "2026-08-20T16:33:56.077Z" }, + { url = "https://files.pythonhosted.org/packages/c7/f8/bd5804695ba400e423c33fd4d9f58c28d86633d5ba1945c36ff3967d98cb/protobuf-7.36.0-cp310-abi3-manylinux2014_x86_64.whl", hash = "sha256:70f5ec8eb0da81a44360c0dc0beac99a0d78071d21956a7076bae8bd2051841b", size = 340439, upload-time = "2026-08-20T16:33:56.992Z" }, + { url = "https://files.pythonhosted.org/packages/ef/9f/acd02338235a3e7d03168c4303478347b7624fc8189ff4e7f0d2654bbe86/protobuf-7.36.0-cp310-abi3-win32.whl", hash = "sha256:7326fd717bdc419162a735938d89d4032332bcc3408804012b24ff3a37086071", size = 440216, upload-time = "2026-08-20T16:33:57.99Z" }, + { url = "https://files.pythonhosted.org/packages/0e/4e/12cb93270967a2affff5b3f720694700d4d87712a67afd05c8cb3f6fa52c/protobuf-7.36.0-cp310-abi3-win_amd64.whl", hash = "sha256:1781cc1de61249b750848029bca452c0a8b7e990080316b9bbc2518b2117b488", size = 453731, upload-time = "2026-08-20T16:33:58.951Z" }, + { url = "https://files.pythonhosted.org/packages/01/c3/629999e78d46c1115c11886d51c6bd68c17ce4a944f1ea3e153a91316a33/protobuf-7.36.0-py3-none-any.whl", hash = "sha256:53374d53fc29a67f7dbbf0ade47d7526a0f0137bf0f9c90e48d8a60790ef748c", size = 177024, upload-time = "2026-08-20T16:34:00.053Z" }, +] + +[[package]] +name = "py-rust-stemmers" +version = "0.1.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6b/c1/9763f9fb1cd73f9c317a83feeed6e0d4af320c6bbddab47b4a94f3a47d0c/py_rust_stemmers-0.1.8.tar.gz", hash = "sha256:6b0f6f48bc54d607aed802de872fcd5a71bae969a6760976dc78ce55e8eaf3da", size = 9732, upload-time = "2026-05-22T11:00:24.358Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/6a/39080bc8f4a441a35378c0faeeb834fb27974997f40d51342574e70f9662/py_rust_stemmers-0.1.8-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:6a9a4b8733d0b307bd0879ab7e321aa8a0bfd054a75a5cb23c647df5ca7d17c3", size = 290230, upload-time = "2026-05-22T10:59:44.551Z" }, + { url = "https://files.pythonhosted.org/packages/73/15/ae60b9010924adac465f418822d9c514690aba6846edd67b6e2b5c227745/py_rust_stemmers-0.1.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:51d0042d2a92ef0f7048bfc06b6c2a02306af31ea47f09d24b34e4b7e63c4e80", size = 275449, upload-time = "2026-05-22T10:59:45.547Z" }, + { url = "https://files.pythonhosted.org/packages/ec/7c/94be8b932179823d66e0d2be03a94706132a7d16a640d5e5710de1cb1b8f/py_rust_stemmers-0.1.8-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:89d3d34094b9b6078a8ea6fe1c7044e5fd32f14e76c94818c5008f49ae075f08", size = 316676, upload-time = "2026-05-22T10:59:46.522Z" }, + { url = "https://files.pythonhosted.org/packages/f3/a4/8bd5c9f31207136830457d819e3f98bb21c54c0cdc40d6f1845ce4efdf7c/py_rust_stemmers-0.1.8-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:40c86be90cee4a709ad84fde4db7f11ca44d65630a56b77ec86fe84c23adfc09", size = 319458, upload-time = "2026-05-22T10:59:47.914Z" }, + { url = "https://files.pythonhosted.org/packages/f9/95/95da2b353b164a3a2b8a1c799866a58060693be4f1dc21065663dc67dc17/py_rust_stemmers-0.1.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:515884bcfb47b10335146648f276930d0c1201ae5e8b7b400fb46d8ea05c0ec2", size = 323541, upload-time = "2026-05-22T10:59:48.894Z" }, + { url = "https://files.pythonhosted.org/packages/3e/ce/f34403b68808519dfa3220e1d94a40f26d5025f27e28893e2388ab9cfde5/py_rust_stemmers-0.1.8-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:fa42f5f8feb694aaaa869eedf477fcaf66f67a192cd64d94302d06920c33864a", size = 323873, upload-time = "2026-05-22T10:59:49.872Z" }, + { url = "https://files.pythonhosted.org/packages/57/01/fb8527f6474d576975415405c985a97260e0403829e062103d334230b7d2/py_rust_stemmers-0.1.8-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2e86ad68fe297a6652f0f0390625ea81858b6f27862fd4c5ee1214bf5af29b9d", size = 494761, upload-time = "2026-05-22T10:59:51.021Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ac/73816237dbec20a7299abf901e2f7b6061d238754e033b48e423603f5336/py_rust_stemmers-0.1.8-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:4b90fc81411943b114e8eb4988a876ba3b12bd2d20741559803eddc4131575dc", size = 596141, upload-time = "2026-05-22T10:59:52.122Z" }, + { url = "https://files.pythonhosted.org/packages/52/0a/dd48debf386a206ee1c6ad75a0827eac89428441291c90d98bc3803fccf1/py_rust_stemmers-0.1.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:56cc2c2df742fa6529285b7d204720f34b7da789ed78eb578442f93c6de97d89", size = 541633, upload-time = "2026-05-22T10:59:53.18Z" }, + { url = "https://files.pythonhosted.org/packages/92/ca/ebb707ab280636b8f46d040ccb051d1a9ddbc1f1ca2d90cdba626872f405/py_rust_stemmers-0.1.8-cp312-cp312-win_amd64.whl", hash = "sha256:dd967eea2f808a1e73aa71ecccef0f4925a4cca4eb02ced94057afe3303153ef", size = 212134, upload-time = "2026-05-22T10:59:54.245Z" }, + { url = "https://files.pythonhosted.org/packages/c2/98/f078f3930311e7b6154ccdf9166c4e30a416c7d199e136b5f09265d58a35/py_rust_stemmers-0.1.8-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:5bd15b89203ecd886960e237124d1aa6e55498d76418c36c967d3b12168d43dc", size = 290427, upload-time = "2026-05-22T10:59:55.316Z" }, + { url = "https://files.pythonhosted.org/packages/c9/46/21d784a3f1db6a23051ffd5826d8ee667d26a64587c1cfbda0443ed87fff/py_rust_stemmers-0.1.8-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6c92733b020534470ca5a0d7fe8b85c85622ff383d4f37fec75a1c677aa84921", size = 275628, upload-time = "2026-05-22T10:59:56.687Z" }, + { url = "https://files.pythonhosted.org/packages/57/d5/701c73a4f6a7fecfd96a6588f0cafe98d6b0acde93adf8a2e45535f3d1d5/py_rust_stemmers-0.1.8-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9ab605a86c950ba7e8ab1392cf91296c0bec3084babb897a4aecf90a10c82395", size = 316656, upload-time = "2026-05-22T10:59:57.67Z" }, + { url = "https://files.pythonhosted.org/packages/9d/0d/c58fe98153cfdb6abf4dfb6ac335c923000d4af4e736080c3a3045b7aea7/py_rust_stemmers-0.1.8-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:21ed8055cec1f78d666afad8ffd7a51775ba419d2c615b8a1df7b32ca7f33e2b", size = 319377, upload-time = "2026-05-22T10:59:58.664Z" }, + { url = "https://files.pythonhosted.org/packages/5c/d7/e60d04849e90aa3ad457211cc4999c30401f433341f9a5588c12b81f9877/py_rust_stemmers-0.1.8-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ae773e1d01e9aa328d175f461475d0cd7074a82bfcc71de6dc5765e51f1cc9f7", size = 323719, upload-time = "2026-05-22T10:59:59.845Z" }, + { url = "https://files.pythonhosted.org/packages/6a/48/c0e4fb955db784cc354e0756354602f7043ff4c10fcbd9d901a2f8fe3239/py_rust_stemmers-0.1.8-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:5cc8fab9d0f1b274a26935a632362b8278f03e81b65e8b8644d5ca3f62a5a1a4", size = 324110, upload-time = "2026-05-22T11:00:01.26Z" }, + { url = "https://files.pythonhosted.org/packages/48/eb/981b26baff37cf7a26ee206763cc4d2fb3e1db8f0f86ec030074431fae05/py_rust_stemmers-0.1.8-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:35570098da02eb439afcd7270a12bf850bbe874b85cb912e0fb2d87a6e703920", size = 494645, upload-time = "2026-05-22T11:00:02.737Z" }, + { url = "https://files.pythonhosted.org/packages/6d/af/f16e805b7aefc2257b192b83a89300c8360b0fdffd3dfefa92dee4ec9b15/py_rust_stemmers-0.1.8-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:0a68745d4b3c7f5abc778ca967e8711df6154873abcfe4e62a6631fa2363cc32", size = 596124, upload-time = "2026-05-22T11:00:04.499Z" }, + { url = "https://files.pythonhosted.org/packages/76/8c/e7a2c940ba00e0792ae346aed5e755d51d37cf6d6853f6b141e5380e285d/py_rust_stemmers-0.1.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7cc0cc0b8eb45d2158c28ea43e2f338c110aad63052ad3bd00bc7446a595e12f", size = 541771, upload-time = "2026-05-22T11:00:06.081Z" }, + { url = "https://files.pythonhosted.org/packages/c2/a0/dd7c5fc6ade6d2a2a49e49937f06f2d488511454e8ab1b313d277ee8c3b1/py_rust_stemmers-0.1.8-cp313-cp313-win_amd64.whl", hash = "sha256:15af4e12e1288de2e5241eec375afc6ad6be4c125a28ca010599d9f92db23f01", size = 212438, upload-time = "2026-05-22T11:00:07.244Z" }, + { url = "https://files.pythonhosted.org/packages/b0/7e/f4346adfd44acbd7eaedcbd7d21b7f40ec9712e6c699e71fddad8dae6f8d/py_rust_stemmers-0.1.8-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:526b58958c6ffa36c4a805326cfb624ecbd665d16ba435027dbed0bcbcaa09d2", size = 290379, upload-time = "2026-05-22T11:00:08.192Z" }, + { url = "https://files.pythonhosted.org/packages/c2/d8/988fc3f5dc0dbbd4bf5909f50ff953ab55ee8b5f79a835d00e57847d3123/py_rust_stemmers-0.1.8-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:2b607f0b270951fb66479baf4b68716cc63a981585cbd898b0b6b5c359efde7e", size = 275458, upload-time = "2026-05-22T11:00:09.522Z" }, + { url = "https://files.pythonhosted.org/packages/f4/94/e04c8b6a8364bca1b368785cef143755dd2d1ffe74df8f8b47b075bb1043/py_rust_stemmers-0.1.8-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b0327b151ab8a338fb54fdac114ba34394327fc1e2c4c425ad1caf2013e5de3", size = 314711, upload-time = "2026-05-22T11:00:10.878Z" }, + { url = "https://files.pythonhosted.org/packages/4f/cb/f59f9a80caa099cb6625a46c9a8e6e7e80bb3ed284f17e80245c8240a66e/py_rust_stemmers-0.1.8-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:dadd0e369703817fc7026987b3093f461f9f58d8dde74e689d546184bc8f3451", size = 319370, upload-time = "2026-05-22T11:00:11.961Z" }, + { url = "https://files.pythonhosted.org/packages/06/59/8211cd0f56e53f7770debd9a78de37985fb5662ae66e3b7b380f4c79888b/py_rust_stemmers-0.1.8-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:245e2c61c52e073341893a9682cd1396b61047154548aee30bb1af3d8ed4b4cc", size = 321373, upload-time = "2026-05-22T11:00:13.213Z" }, + { url = "https://files.pythonhosted.org/packages/10/72/fe33e614c114264d1ba54d39da4b5a4abeb6aedd0d26e5a8fd0637d6ddba/py_rust_stemmers-0.1.8-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:451ee1c02a3f5cf1e161b46ba9032cdda4ba10a8b03ff9ee61c1d34d42a0bc81", size = 321707, upload-time = "2026-05-22T11:00:14.177Z" }, + { url = "https://files.pythonhosted.org/packages/91/f9/3cd18902fe2fa54557d3fe9132552256372d381c7aca71346163055d78b1/py_rust_stemmers-0.1.8-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d396dd25c473c1bc4248c79cd223f4b36356b55a124652f015c6a001547f81ac", size = 492457, upload-time = "2026-05-22T11:00:15.245Z" }, + { url = "https://files.pythonhosted.org/packages/90/d7/32c6d3995e7036b73683389de2771f4dbbf40de192b7efe73c2528ee1eb5/py_rust_stemmers-0.1.8-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:479c77c32d8be692f3cfcde7e19273f02ac81d6f45c6aef49887ef95cab7abbb", size = 596085, upload-time = "2026-05-22T11:00:16.404Z" }, + { url = "https://files.pythonhosted.org/packages/00/8c/e68fa5d862ea6a27fced3535c25ea4eaa26ba1ce00dfef5841924c74b167/py_rust_stemmers-0.1.8-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c786235275c5c2abb7f206b8236aee3ca0bc53c7497daf7fb7b01d3491469547", size = 539747, upload-time = "2026-05-22T11:00:17.414Z" }, + { url = "https://files.pythonhosted.org/packages/44/48/aa584cf3772e01231641c95dc1aa73327a7d986c562639d78d0013733acf/py_rust_stemmers-0.1.8-cp314-cp314-win_amd64.whl", hash = "sha256:931d13570962b093417e5443a9d1bd63d73fa239ebb81e5b1d346663571403e4", size = 209636, upload-time = "2026-05-22T11:00:18.662Z" }, +] + +[[package]] +name = "pycparser" +version = "3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" }, +] + +[[package]] +name = "pydantic" +version = "2.13.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/53/ef/fc4f868f4e2cee79f863883abffceff107875f569b848507319842d2a681/pydantic-2.13.5.tar.gz", hash = "sha256:51a9c5f7b2f8e636f04c6cada605d9b6a3bf1348fdf945a3d8869b19bba0ee08", size = 845750, upload-time = "2026-08-28T14:04:00.916Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/47/c95ffc2009878c7aac0c5e08528022dcb885933252a88b5f170058014464/pydantic-2.13.5-py3-none-any.whl", hash = "sha256:346a034f080da3755d8e9cb5e00e8b07de1d39e4f6e2c87d8ab7cafa0b269a73", size = 472589, upload-time = "2026-08-28T14:03:59.136Z" }, +] + +[[package]] +name = "pydantic-core" +version = "2.46.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/af/f9/8a06bea35ef8daf588f707784c973a7046e0034c8d8cfb08828eeffb8b75/pydantic_core-2.46.5.tar.gz", hash = "sha256:10416c15b8839ecc4ef4d0885da76da6fd0f67333a0eb8aff6d93c4b8f2910fc", size = 472262, upload-time = "2026-08-28T10:01:31.677Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/3f/76358795aa7a8c6d4f36e2cb828ad1c90ee118e1393a9281664f5aade9d4/pydantic_core-2.46.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:b9fe6fb92520e3fd61f2e49000b6911b188824f089b75973ea06d6267f0b476d", size = 2076516, upload-time = "2026-08-28T09:58:21.576Z" }, + { url = "https://files.pythonhosted.org/packages/db/50/26b091836076ce4cb2fac264186936acc069e0595772cfd02a563bc4761a/pydantic_core-2.46.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a39ac25a9a2fa4072efdb429833c4a4c8009a51ff9eea3eeae131713cd27991e", size = 1922874, upload-time = "2026-08-28T09:58:23.766Z" }, + { url = "https://files.pythonhosted.org/packages/09/f0/2a8ce3849e299d44e2d2c196b6082643a3235565a735cb51db7a6261f614/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4fdc8b93a41521988916eeaa271173fcca7fa0803d62f87675aac8dcec1c8e29", size = 1951772, upload-time = "2026-08-28T09:58:25.435Z" }, + { url = "https://files.pythonhosted.org/packages/87/46/ac0dc8bdd9e6048183a14eb127764e7ad9240021c17513074a4711b0e31e/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b98134087d9de723658d17a42c7d0da8d6e2ef08015dee7dc93889047315f5e4", size = 2031832, upload-time = "2026-08-28T09:58:27.102Z" }, + { url = "https://files.pythonhosted.org/packages/c4/c2/339de5bef7be36301a2231eaa52e62163742c2281f11b5f4892bc79785cd/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e652ab17569c94bff5475520f907b7148b8c24036a8ebbe5cf7cf7493d28579a", size = 2208645, upload-time = "2026-08-28T09:58:28.948Z" }, + { url = "https://files.pythonhosted.org/packages/7b/a0/9ff22b797724262da14427abaed4dd1d864a139693fc5e7809114376a716/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d925f3d9afd05a8c0fb3a1031463a8d59ebe5e2afad297e29c78be19e13b4e62", size = 2265935, upload-time = "2026-08-28T09:58:30.625Z" }, + { url = "https://files.pythonhosted.org/packages/c0/a4/eb9409ec0736e50aa70a412f16c204ed149516846912f7e6724d4c73ee53/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0fc5be0abd4a407e200d844b404e33639a554e7bd0d448e7b9ae181be4789ac2", size = 2066284, upload-time = "2026-08-28T09:58:32.289Z" }, + { url = "https://files.pythonhosted.org/packages/c0/02/7f6156ffc926857f1c37c07d9a388682865a81830ab6a1b637082c25e399/pydantic_core-2.46.5-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:816ff0a6550ffc06c098ccd2e0698600f9aa7da192a79eaa6f9af504a35db869", size = 2105889, upload-time = "2026-08-28T09:58:33.986Z" }, + { url = "https://files.pythonhosted.org/packages/92/b1/e781d357ebe09fc929f995700f1b3503e8897f1cece183ecb1300d4d67e9/pydantic_core-2.46.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c7ea57fc63aa7da93a1bd2d644e6577befae10c52c4e36377635eea1056a74f5", size = 2158006, upload-time = "2026-08-28T09:58:35.647Z" }, + { url = "https://files.pythonhosted.org/packages/70/0a/644597d84ab400e50609c192120b85c9681c22d3a20461b9060a79be0a7a/pydantic_core-2.46.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:efd62a42486f1bda5d24cb4f63d15a3c7768375fe83d36f9417b4ad7a2fb20b3", size = 2158408, upload-time = "2026-08-28T09:58:37.38Z" }, + { url = "https://files.pythonhosted.org/packages/1e/ee/ca3b7b3a4b3769ffe9ce9432a7c9be755de9593a46d3b0d54d0409323e44/pydantic_core-2.46.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:2bc9419666990c06d7397831f2126a1ecc3594aaa3ff7de5bf2d066802f4e07b", size = 2309609, upload-time = "2026-08-28T09:58:39.22Z" }, + { url = "https://files.pythonhosted.org/packages/ce/52/39fa1f451486019524ca685020390e7ca351832fd874530ba30c8628e6dc/pydantic_core-2.46.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:18a09e1e1011b462f2e32774f25859ef1223d5c2b0546a633cf56654710721e0", size = 2342618, upload-time = "2026-08-28T09:58:40.89Z" }, + { url = "https://files.pythonhosted.org/packages/81/5e/468fc630568c61dcef3cd47ad32ffbeed9af643f49208d1ea86ab4f890c4/pydantic_core-2.46.5-cp312-cp312-win32.whl", hash = "sha256:5cb482e9e84c851f4e623fe4acc1ced89168cf1fe18f7089db4548c8f5bbb65b", size = 1939475, upload-time = "2026-08-28T09:58:42.591Z" }, + { url = "https://files.pythonhosted.org/packages/cf/c9/4c19f41b84cf6b622a72fbeed7665b25d47a187d68d47d0d430c07f23268/pydantic_core-2.46.5-cp312-cp312-win_amd64.whl", hash = "sha256:5e81740c09e310f5aa5cbd3e434a01c154d4bef93241c7877b39f211d2b78ba8", size = 2043140, upload-time = "2026-08-28T09:58:44.272Z" }, + { url = "https://files.pythonhosted.org/packages/af/dd/0c1a050299147c746e5256db16d645ab5efd4f78c59937d581a0524e74a2/pydantic_core-2.46.5-cp312-cp312-win_arm64.whl", hash = "sha256:f7b0ec93a2893de856652154d73b7ba622f26fa97726487dcac373de5f4c6084", size = 1997729, upload-time = "2026-08-28T09:58:46.13Z" }, + { url = "https://files.pythonhosted.org/packages/f5/37/5abe39a8372a61d3dc3c1338fc504281c01b32fdb3169cd7187153b56d3e/pydantic_core-2.46.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:b7ca9034437b6022f941f4857459562ee00a560b97e7cce8a0ec5a74fc6766e0", size = 2075885, upload-time = "2026-08-28T09:58:47.856Z" }, + { url = "https://files.pythonhosted.org/packages/21/43/6323b1f8b217780454c61304bcd2b38ae4762f50754414124603ccc90bb2/pydantic_core-2.46.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f332f0e72a5a0400141f830744e141bf9f97917878dbe968669e8a7fefea78ff", size = 1922768, upload-time = "2026-08-28T09:58:49.58Z" }, + { url = "https://files.pythonhosted.org/packages/0f/a3/c05ca796e1197618a774b01e596aeedfefc2f7d8c01ae3054e910b120e8a/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:193375f3548919d3f0b60936ca113ada3e38f264f91b9b8e0508efaad57be931", size = 1951241, upload-time = "2026-08-28T09:58:51.511Z" }, + { url = "https://files.pythonhosted.org/packages/68/32/33bc39ac705c52cffc908e8389f9754fdb208aea5c69cceddf4eb3ce99af/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:79bdfa52f843137045b2d081cc05c120ba6665d29b7559c2c47690906f39279f", size = 2031975, upload-time = "2026-08-28T09:58:53.166Z" }, + { url = "https://files.pythonhosted.org/packages/b0/70/2333e885c0f6a67bc105c5916965dac9b57f2718ee20d81d1a06a4ebdc13/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:24922243639cbdac66c75fcb6fd6495a9cb52b213d62f9a0d16f0310b1ff8038", size = 2208542, upload-time = "2026-08-28T09:58:55.017Z" }, + { url = "https://files.pythonhosted.org/packages/f7/ea/296debfb4264207bbda5936133892e027c0a58875ad53ebd512fba8ec3a2/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c76fe65e607be28c7fd4d56fc3c42b1583aa058ce3408b7ad0fd540171d31f9f", size = 2264692, upload-time = "2026-08-28T09:58:56.767Z" }, + { url = "https://files.pythonhosted.org/packages/d3/f2/9e4de77a6271e07a76d2d58b11c091a979c191ed2939bf80067568b369d2/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f7b393a8b3da82f5c1fc0751e6d01ac6c55b93c18226a60bdfba4a724efafd1", size = 2066633, upload-time = "2026-08-28T09:58:58.531Z" }, + { url = "https://files.pythonhosted.org/packages/8d/db/f9e9d0c97445987b2084823d5c240de88087338f04fc2cfaa2df186b8049/pydantic_core-2.46.5-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:7ac031912d54f3d83ef3b3eb98dfabc1608802e2202263d25957eeed40b94761", size = 2105235, upload-time = "2026-08-28T09:59:00.421Z" }, + { url = "https://files.pythonhosted.org/packages/07/c5/79169b047b3b2c3e99e04bc76372af9637e0bf6db638274fa927df96369e/pydantic_core-2.46.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:837b396ca3d7b74091ca623f6cbd8351bd42d670a79c2683e79fb089f06a2de5", size = 2157367, upload-time = "2026-08-28T09:59:02.442Z" }, + { url = "https://files.pythonhosted.org/packages/26/b5/ba6057afb7c291bd449f51b867f95aef2072941c4ce4e5c31d6ffd132d3b/pydantic_core-2.46.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:5ee239d575f80b08eca11f6e20f90c4c695de7825c67eefe6091fbf20dda648e", size = 2158420, upload-time = "2026-08-28T09:59:04.2Z" }, + { url = "https://files.pythonhosted.org/packages/6e/28/2057abecaafdc22912afa819603a51f0a62d40643b7c4871c51721fea9be/pydantic_core-2.46.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:e80675d75ae2cd14372cb65cad5400d9347a3d3f6c13000183f22dfd027283ed", size = 2309588, upload-time = "2026-08-28T09:59:06.048Z" }, + { url = "https://files.pythonhosted.org/packages/71/9d/881156dc404e27479c4246128d73538464cab4a239bec61995e227644c30/pydantic_core-2.46.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:9c4b71f10dd532fb7a5cbc8f58707779e64f03a258c2bf8bfbaecfcd9970b519", size = 2341866, upload-time = "2026-08-28T09:59:08.539Z" }, + { url = "https://files.pythonhosted.org/packages/5a/38/d66f443a259f84d13babdceae568e572b0ed26da17ca5d0a649ebb110a67/pydantic_core-2.46.5-cp313-cp313-win32.whl", hash = "sha256:97bf8de4d541598c94a59344eeb988a94c08ff76b5723c41f6567ec18c7892ea", size = 1938580, upload-time = "2026-08-28T09:59:10.402Z" }, + { url = "https://files.pythonhosted.org/packages/2c/1e/1d5371213f4cc9a7ed70c0bfcc7911de22311ee99a662a56077d7292d2ac/pydantic_core-2.46.5-cp313-cp313-win_amd64.whl", hash = "sha256:15f4a94963c95accac15b7b657bb177d3ad82bb90b0d0526d9a9b85079925db5", size = 2041980, upload-time = "2026-08-28T09:59:12.396Z" }, + { url = "https://files.pythonhosted.org/packages/5a/48/4222d90b1c67568bace4dec6dca6271449c66de3595d72b6d098f5fde597/pydantic_core-2.46.5-cp313-cp313-win_arm64.whl", hash = "sha256:d22a945598fb91236b4dd793a6e42e4f3dd7740bb5aace5ebd7d4c08d13bb575", size = 1997213, upload-time = "2026-08-28T09:59:14.245Z" }, + { url = "https://files.pythonhosted.org/packages/8e/8a/14596f2a8367da50cf7cbac48169ee5d9c8e11d486a3b527082384630c72/pydantic_core-2.46.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:c1c43ad4339643d70ebb8124e1305a7dab423001eff58bb41a0f731adbc98355", size = 2074081, upload-time = "2026-08-28T09:59:16.141Z" }, + { url = "https://files.pythonhosted.org/packages/ae/d5/d8a4eb6d6c7f66b91dd37c576d76e9e60fba900caf5372c17bcf949febc2/pydantic_core-2.46.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1a353f84de772f423b5ffb11d7ae352fbbef0f446f3c0b0af0f8236d7233606e", size = 1920497, upload-time = "2026-08-28T09:59:18.065Z" }, + { url = "https://files.pythonhosted.org/packages/8e/26/092079428f86e927e030b2c0ced87df69dbb1c875cdeaa67bf42ea2be746/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5086029a57366b8cf81b130a43908738095c270c21a8d7f0e8bdfdb89718e2f3", size = 1952130, upload-time = "2026-08-28T09:59:20.476Z" }, + { url = "https://files.pythonhosted.org/packages/08/c3/8ec0e290a9ebaebd64047bf5fda94be835c6b1551b02437e4b76778fbcd7/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:46c25dda9d092a06c08db76ffe0a197107904d0dfac653f7d5306bbcd6d6119c", size = 2026371, upload-time = "2026-08-28T09:59:22.227Z" }, + { url = "https://files.pythonhosted.org/packages/01/72/4fd20ad520fb8da0157f95b27a7eb05a72790ef08138e7701ac972c342ea/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:37ea7b83c935e5b0d68c9449b82651accf78a10828b2c02b2f2d9e9496446c21", size = 2202822, upload-time = "2026-08-28T09:59:24.277Z" }, + { url = "https://files.pythonhosted.org/packages/31/b0/d16e0771206b29314f0d52198b720be21e8a99ab2bf11e3bc0d7c9cebdff/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e64e88d5585bea9ce95861079de72006c7fa6d3df4e3a3b65ba31eb979c15c9f", size = 2262756, upload-time = "2026-08-28T09:59:26.608Z" }, + { url = "https://files.pythonhosted.org/packages/2c/9b/59634b7ac631c63b2a37760eb6943af3e29573d6b59a4abc5e7f019d4cee/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:54d510bac3ee52247af28ed4bb18a1e799f040ac60fd2bf5ccd4c92f1fbe786f", size = 2068352, upload-time = "2026-08-28T09:59:29.044Z" }, + { url = "https://files.pythonhosted.org/packages/08/7c/570abb1ad2155348dc754ea91be22e5aaa18eb6d69a6068f7c6f2679a6ed/pydantic_core-2.46.5-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:a2a5e1d0ff29adddc9f6d6821a66302e4493f8ca898b715b6b1182c2c201ea0a", size = 2104777, upload-time = "2026-08-28T09:59:30.95Z" }, + { url = "https://files.pythonhosted.org/packages/8e/25/5bf74adc65a1ac5b7be3f6cb0bcb5433615c1598a801c19d830d84c98ded/pydantic_core-2.46.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:03b9666e41e35d8909852ba191a0607520f81b74eaf12ccf8737005dbb313821", size = 2156312, upload-time = "2026-08-28T09:59:32.604Z" }, + { url = "https://files.pythonhosted.org/packages/90/6a/2ef38830675e050121040618135564ed56b860b45433b02d9b4ebece46f3/pydantic_core-2.46.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:a91c17edf6eea2402cb5457b4c89e99bc5ed1004aa34c4adf1d4258c1a5c22c2", size = 2150067, upload-time = "2026-08-28T09:59:34.453Z" }, + { url = "https://files.pythonhosted.org/packages/90/ef/a7dbb03a14a64c2a4621f989c615ed9a892535a6cad938fc27079f919d80/pydantic_core-2.46.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:b49924c73a235e969511bf2aabdff3beebf9820931f646c80274d5d780010c47", size = 2304516, upload-time = "2026-08-28T09:59:36.194Z" }, + { url = "https://files.pythonhosted.org/packages/68/f8/6bb4c4b80e8a6fde1904c64a51c62a1d04fcdfa3ea521a66b2ddefa1d885/pydantic_core-2.46.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:2cbd9a5eff05e51c447c34dfa4632145b26b09120cf04bd0c871e44c1a5e1c9a", size = 2335223, upload-time = "2026-08-28T09:59:37.931Z" }, + { url = "https://files.pythonhosted.org/packages/2a/80/f46b8c681195190b2c1f1c7c0a81abce60663e987613e09ef64d433dd96b/pydantic_core-2.46.5-cp314-cp314-win32.whl", hash = "sha256:2d5d76654becf5efd62c9e51c3756c67b49498b0c9a40884934c40807adbd074", size = 1934827, upload-time = "2026-08-28T09:59:39.836Z" }, + { url = "https://files.pythonhosted.org/packages/f7/3c/60674207246bc0a4009d2391b7c7251c7159f279c8d2ab8aae8ef46f3dee/pydantic_core-2.46.5-cp314-cp314-win_amd64.whl", hash = "sha256:fa10ef4112775900e7a0661068635eb67b2ab824fbde764de6e0e21982a93db0", size = 2042648, upload-time = "2026-08-28T09:59:41.792Z" }, + { url = "https://files.pythonhosted.org/packages/69/0c/117c562c7c1babdf44576b72a5e496906506c93690387ecfbca7c729ae2e/pydantic_core-2.46.5-cp314-cp314-win_arm64.whl", hash = "sha256:045ab3b6d308439e32b81cc173bba5b9018bc6ed896afd0c65b3b009b1699af5", size = 1989652, upload-time = "2026-08-28T09:59:43.702Z" }, + { url = "https://files.pythonhosted.org/packages/e8/66/9336ae58f9eb68c41d121894e52c4c89eccb07eb8f602a04ee9c3f37736a/pydantic_core-2.46.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8816f3d218beb4b787de5c9759c259b8fa61f9dec42dc7811f320a33771778b7", size = 2065829, upload-time = "2026-08-28T09:59:45.364Z" }, + { url = "https://files.pythonhosted.org/packages/c5/02/bc19b47a96c2d3109760711acf22369e56bd7e405ca52f7ade164d2ead57/pydantic_core-2.46.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:bce57638e08ac148e5778cce7feb968307a727d66f8e2274a543d0cf0c9ad6a3", size = 1905716, upload-time = "2026-08-28T09:59:47.18Z" }, + { url = "https://files.pythonhosted.org/packages/52/a4/70b47c0509923dd98ccfed04fb3e32ea3849c82a0ff2205bb41009b43c00/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:976e1128455aa595ea04c79ccfedff1aaeab96ee013fcc916bed120c4f0ad94f", size = 1934216, upload-time = "2026-08-28T09:59:49.241Z" }, + { url = "https://files.pythonhosted.org/packages/52/ab/aa03b65f7bb198585edf806b906c3223ecf1795543e39e23aec4cce27ad2/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b891faeedeafba41b2983e5001a81b6a915b69544c7e7570d1989ce1c36ac7", size = 2010635, upload-time = "2026-08-28T09:59:51.692Z" }, + { url = "https://files.pythonhosted.org/packages/3c/8b/0da06343f30b84ec549aafd309c6456223d5dc8bd36af504c573faad561d/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5f194189415698233dd1114a093a9b56e61e2c57e11b469be3b0506f46f0771c", size = 2209369, upload-time = "2026-08-28T09:59:53.582Z" }, + { url = "https://files.pythonhosted.org/packages/d6/5b/844c4defaa34a3df66eb9257087d121d70c201298b96abdf9f492fc2f1bf/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:82a36973cf8a2ef5406f4fe2edbf8ed0c99629535d959e0b100c76a32535a111", size = 2253238, upload-time = "2026-08-28T09:59:55.484Z" }, + { url = "https://files.pythonhosted.org/packages/f4/64/a4e536cb16d7f61a7fd3120b46c577fc7fa7325992f69c4f52bc786d77d8/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdbb78909f52b981d3b2d56b97328d71eb0b974c36bd77c920123a7ebb192829", size = 2065740, upload-time = "2026-08-28T09:59:58.038Z" }, + { url = "https://files.pythonhosted.org/packages/5f/75/aaa38c6bc2d085f6605b34eabdc6a8a4e0b2e61fc9c8e6e52b28e97b3125/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:52e24eacdb536cade636aa90fb851835222becff8484b7001fdc78cb0290f2aa", size = 2087425, upload-time = "2026-08-28T09:59:59.898Z" }, + { url = "https://files.pythonhosted.org/packages/55/ae/fcab4cfc39aba3689e1d20c8b5250ad280957022c09af2ed9cd585602a5e/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:37ae34309d7bd8c0d61ab839668058f2a7962ea1fc51d105d2db228fe0618034", size = 2139306, upload-time = "2026-08-28T10:00:03.057Z" }, + { url = "https://files.pythonhosted.org/packages/2d/f4/f1d03a4bc9d9acbc62f4d742b8a319af52f71885079868b2ff8e48a651ee/pydantic_core-2.46.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:0cdbada856a1c69a7624a64d3d9aefe79300bd6ef827b43a4f265010b9b55184", size = 2144589, upload-time = "2026-08-28T10:00:05.645Z" }, + { url = "https://files.pythonhosted.org/packages/83/f3/7a53bb1356de514a4cd295f25b6ac39237895620c0462d2592b76c16e114/pydantic_core-2.46.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:545f26c504b27c3758439a5e6d9349931f0a04f855668d5fe323c89e82300a38", size = 2288882, upload-time = "2026-08-28T10:00:07.931Z" }, + { url = "https://files.pythonhosted.org/packages/cd/94/5a81583660c175c59d49ffb09f4b3a44debeaf86a19fca664ae1cdd9ee32/pydantic_core-2.46.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:ff218293c9c806138dca139765e3b067621be52bcd93cdc14c7711be7ddc90a9", size = 2335210, upload-time = "2026-08-28T10:00:10.177Z" }, + { url = "https://files.pythonhosted.org/packages/5a/9f/5d685c2693b972d1a59c998586e8823712b66603aeff47ee60a4bdaafd37/pydantic_core-2.46.5-cp314-cp314t-win32.whl", hash = "sha256:97cf3eb53a8cccacf9d46686a0926186c9bfb5574f2ed66d3639d5fe117cd3a9", size = 1921180, upload-time = "2026-08-28T10:00:12.35Z" }, + { url = "https://files.pythonhosted.org/packages/70/12/5c94ee16d65a37a15f9e869f5e6256df111154491173801a4c5e800ab548/pydantic_core-2.46.5-cp314-cp314t-win_amd64.whl", hash = "sha256:d2f9fc07a8042a8f95925b35c4f04f469707c981fc33245b6ca187cf5d2dd290", size = 2020515, upload-time = "2026-08-28T10:00:14.774Z" }, + { url = "https://files.pythonhosted.org/packages/63/19/67830dda664e6bdf9285ee2e40f355d0d7d6b92aa0c42e8d217bb8d33d36/pydantic_core-2.46.5-cp314-cp314t-win_arm64.whl", hash = "sha256:acf8a67ba51f4ca9ddbd0e6b3000a65ac51ab734661778b3e7ba64d99a710f2f", size = 1989276, upload-time = "2026-08-28T10:00:16.984Z" }, + { url = "https://files.pythonhosted.org/packages/df/dd/053c2e4303f791f3b8f8a14ab0b22008e8eb21d868c0c90b4f9be705b76a/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:013d6f3483d81e02e7c328831808f336c8596ee33b4bd4026b9ffb1e960b8942", size = 2062540, upload-time = "2026-08-28T10:01:00.318Z" }, + { url = "https://files.pythonhosted.org/packages/d7/dd/a18df751a5e37dd51bfad7f68e766999125bebe68c9e1d10a493ad01bd63/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:e9c134bb666dd54b778b9fc0d2b50cbb7f979b9e3716f26a88c9ab3b6fc1dd0f", size = 1902040, upload-time = "2026-08-28T10:01:02.529Z" }, + { url = "https://files.pythonhosted.org/packages/b7/13/01d40f9d07ce8a779fd6e0bd8ad4fba91309500dd67b869e2e219d261a6d/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:347ec774390c87326a2e4929d58d3f7e8763a104d5d35f4cd595a4c952366433", size = 1967479, upload-time = "2026-08-28T10:01:05.004Z" }, + { url = "https://files.pythonhosted.org/packages/fa/04/c81d4841331c2178b6fb09ae225425e110ed72d990c9fe556c4ec03d1013/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e24d8f05fa2d28513d94e877e9c75ad66175376209b3977f916e240e623193c", size = 2111034, upload-time = "2026-08-28T10:01:07.345Z" }, +] + +[[package]] +name = "pydantic-settings" +version = "2.15.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pydantic" }, + { name = "python-dotenv" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/68/ca/31c57507b13119d7d3cfa1576dad2911a4861e3be07b579395f4e9d393f9/pydantic_settings-2.15.0.tar.gz", hash = "sha256:694b793e84f766ba76a90ebdefc01d0a9a045dab0382bee70393da93712ad117", size = 261253, upload-time = "2026-08-07T09:24:57.419Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/30/a4/2bffa9f8e804325a09867f0e9d30795c80ea9f8d62560bd1b6ad6220eb2f/pydantic_settings-2.15.0-py3-none-any.whl", hash = "sha256:0ba092c291c94baceb5eff768aa0d56400a457585bc0175925a5a5510303da42", size = 69413, upload-time = "2026-08-07T09:24:55.839Z" }, +] + +[[package]] +name = "pygments" +version = "2.21.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" }, +] + +[[package]] +name = "pyjwt" +version = "2.13.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3b/81/58d0ac84e1ef3a3843791d6954d94c0b33d526c75eeb1efbce9d0a4c4077/pyjwt-2.13.0.tar.gz", hash = "sha256:41571c89ca91598c79e8ef18a2d07367d4810fbbd6f637794879baf1b7703423", size = 107515, upload-time = "2026-05-21T19:54:36.618Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/5e/ecf12fdb62546d64385c158514e9b2b671f7832108ef2ecd2020ce0af2d1/pyjwt-2.13.0-py3-none-any.whl", hash = "sha256:66adcc2aff09b3f1bbd95fc1e1577df8ac8723c978552fd43304c8a290ac5728", size = 31274, upload-time = "2026-05-21T19:54:35.362Z" }, +] + +[package.optional-dependencies] +crypto = [ + { name = "cryptography" }, +] + +[[package]] +name = "pytest" +version = "9.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" }, +] + +[[package]] +name = "pytest-asyncio" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pytest" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/7c/d36d04db312ecf4298932ef77e6e4a9e8ad017906e24e34f0b0c361a2473/pytest_asyncio-1.4.0.tar.gz", hash = "sha256:c6c0d2259945122819f171a32ecea2c349ead889ee28176caaf492143424be42", size = 58514, upload-time = "2026-05-26T09:56:04.083Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/03/e2/08a497ef684b88559c9cc5f4ad53a37e7b99e727094a86d6ea32536d5d3c/pytest_asyncio-1.4.0-py3-none-any.whl", hash = "sha256:933ca923a23075a87fb7070c0ec272a6848489824d887c85c812670932835aa1", size = 16930, upload-time = "2026-05-26T09:56:02.576Z" }, +] + +[[package]] +name = "python-dotenv" +version = "1.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6a/53/ed9d74092561d4b01a2ef1349d52cdbc135e526c245f366b089cfca6de49/python_dotenv-1.2.3.tar.gz", hash = "sha256:a20a594dabeaa385725aa239d5244871c143ecb356add8a20fcf23773a6c3a35", size = 58945, upload-time = "2026-08-16T16:54:54.067Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0d/17/c5c6b53ddc18f297992099b3d9ec16c855c0ccc83263a21fe4d1c625ec6c/python_dotenv-1.2.3-py3-none-any.whl", hash = "sha256:904552145e8bfed22162c09dab1c2b9b54fefa7b23ba780f4f26ca0316b0f0d9", size = 22780, upload-time = "2026-08-16T16:54:52.473Z" }, +] + +[[package]] +name = "python-multipart" +version = "0.0.32" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5b/42/55c32bb9b12693c092ad250a0e82edb5b31ddeda6eb772de5f308b3804ad/python_multipart-0.0.32.tar.gz", hash = "sha256:be54b7f3fa167bb83e4fcd936b887b708f4e57fe75911c02aebf53efaf8d938e", size = 46881, upload-time = "2026-06-04T16:18:58.647Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e1/04/e8135ebd1ad02c56ec633277529b2602ff99ff634be76cdba5744cf554fd/python_multipart-0.0.32-py3-none-any.whl", hash = "sha256:ff6d3f776f16878c894e52e107296ffc890e913c611b1a4ec6c44e2821fe2e23", size = 30042, upload-time = "2026-06-04T16:18:57.319Z" }, +] + +[[package]] +name = "pywin32" +version = "312" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/83/ff/32aa7d2ed0ab12b323aaa64f9b75e6ad4f8fd09f9ccfc28c79414d46838d/pywin32-312-cp312-cp312-win32.whl", hash = "sha256:dab4f65ac9c4e48400a2a0530c46c3c579cd5905ecd11b80692373915269208b", size = 6371877, upload-time = "2026-06-04T07:49:28.836Z" }, + { url = "https://files.pythonhosted.org/packages/03/d9/77040d3b43df3f3be32ea289433d660d2727f5ba327bc73be835127d9d60/pywin32-312-cp312-cp312-win_amd64.whl", hash = "sha256:b457f6d628a47e8a7346ce22acb7e1a46a4a78b52e1d17e1af56871bd19a93bc", size = 6914841, upload-time = "2026-06-04T07:49:31.85Z" }, + { url = "https://files.pythonhosted.org/packages/e3/cc/7b1ec671775756020a0ee7f4feeaf3c568f0ab86bd3900088cf986937a92/pywin32-312-cp312-cp312-win_arm64.whl", hash = "sha256:6017c58e12f6809fbb0555b75df144c2922a9ffd18e4b9b5afa863b6c1a9d950", size = 6727901, upload-time = "2026-06-04T07:49:34.244Z" }, + { url = "https://files.pythonhosted.org/packages/2d/41/12fbfd7f36ed2146d8bc9de96c2741296bf0d490b98508496cff322e274c/pywin32-312-cp313-cp313-win32.whl", hash = "sha256:7a27df850933d16a8eabfbaeb73d52b273e2da667f80d70b01a89d1f6828d02c", size = 6370184, upload-time = "2026-06-04T07:49:36.253Z" }, + { url = "https://files.pythonhosted.org/packages/ba/db/36a78e3403099d31d9746d13fdcde5accc43c1155f375a34d15983a479a7/pywin32-312-cp313-cp313-win_amd64.whl", hash = "sha256:c53e878d15a1c44788082bfe712a905433473aa38f86375b7cf8b45e3acbaaf9", size = 6914298, upload-time = "2026-06-04T07:49:38.876Z" }, + { url = "https://files.pythonhosted.org/packages/84/37/c1697194092b76de9ed47ca124323f02c57ffc8a45c06f88a3d5acaf01eb/pywin32-312-cp313-cp313-win_arm64.whl", hash = "sha256:59aba5d5940842075343a5ddc6b11f1cdf0d1567fe745290359dfbcc7c2eb831", size = 6727640, upload-time = "2026-06-04T07:49:41.083Z" }, + { url = "https://files.pythonhosted.org/packages/fc/2b/1f3cded5822fd49c02f40544cbb5f58c7cfd6b1694869fd476cb6170ee97/pywin32-312-cp314-cp314-win32.whl", hash = "sha256:a77a90fbb6881238d2ca9c6fd797b25817f3768fe78d214a90137ff055a75f5b", size = 6468928, upload-time = "2026-06-04T07:49:43.188Z" }, + { url = "https://files.pythonhosted.org/packages/21/82/3bf86d2e2808902013132e1ce905a7da0da53790f3836c64bf44d55e24f3/pywin32-312-cp314-cp314-win_amd64.whl", hash = "sha256:a4dd3a848290ef724347b19f301045831d8e802fa4464f491b98b1e0a081432e", size = 7024157, upload-time = "2026-06-04T07:49:45.34Z" }, + { url = "https://files.pythonhosted.org/packages/a4/0e/73f6d6800b4f27655abd9e9f6aaeaefcddb2b946e4674efa2bab184a7f7b/pywin32-312-cp314-cp314-win_arm64.whl", hash = "sha256:9fce94568364e0155e6dfb781ac5d95903be8baf28670632beab1b523f300daa", size = 6839598, upload-time = "2026-06-04T07:49:47.613Z" }, + { url = "https://files.pythonhosted.org/packages/eb/61/caa39686032d2ebdd04ff0ab5cbe163126c0066d98e00c9018646e42393b/pywin32-312-cp315-cp315-win32.whl", hash = "sha256:5c1fbe4a937a73ae9297384a3da38518cbc694c68ad8a809b2e19acd350f03ed", size = 6471159, upload-time = "2026-06-04T07:49:50.035Z" }, + { url = "https://files.pythonhosted.org/packages/0f/cd/7e1de64a4a6f69c04214169657ccab0d93a670ea50e35eb8f489d7378249/pywin32-312-cp315-cp315-win_amd64.whl", hash = "sha256:c2f03a0f73f804a13c2735b99392b0cd426bb4f2c4d0178e5ac966a0f21618d5", size = 7025293, upload-time = "2026-06-04T07:49:54.857Z" }, + { url = "https://files.pythonhosted.org/packages/23/ed/4532e9388e65fa16b46776ef47ad631a64eda1631884488af707666350ed/pywin32-312-cp315-cp315-win_arm64.whl", hash = "sha256:a8597d28f267b39074aef51fa593530082b39cbe5a074226096857b1fed2dfb9", size = 6840337, upload-time = "2026-06-04T07:49:57.531Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, + { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, + { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, +] + +[[package]] +name = "referencing" +version = "0.37.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "rpds-py" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" }, +] + +[[package]] +name = "requests" +version = "2.34.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" }, +] + +[[package]] +name = "rpds-py" +version = "2026.6.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/2a/9618a122aeb2a169a28b03889a2995fe297588964333d4a7d67bdf46e147/rpds_py-2026.6.3.tar.gz", hash = "sha256:1cebd1337c242e4ec2293e541f712b2da849b29f48f0c293684b71c0632625d4", size = 64051, upload-time = "2026-06-30T07:17:53.009Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5c/be/2e8974163072e7bab7df1a5acd54c4498e75e35d6d18b864d3a9d5dadc92/rpds_py-2026.6.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a0811d33247c3d6128a3001d763f2aa056bb3425204335400ac54f89eec3a0d0", size = 343691, upload-time = "2026-06-30T07:15:14.96Z" }, + { url = "https://files.pythonhosted.org/packages/a4/73/319dfa745dd668efe89309141ded489126461fcecd2b8f3a3cda185129b6/rpds_py-2026.6.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:538949e262e46caa31ac01bdb3c1e8f642622922cacbabbae6a8445d9dc33eaf", size = 338542, upload-time = "2026-06-30T07:15:16.267Z" }, + { url = "https://files.pythonhosted.org/packages/21/63/4239893be1c4d09b709b1a8f6be4188f0870084ff547f46606b8a75f1b03/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:55927d532399c2c646100ff7feb48eaa940ad70f42cd68e1328f3ded9f81ca24", size = 368180, upload-time = "2026-06-30T07:15:17.62Z" }, + { url = "https://files.pythonhosted.org/packages/1c/ca/9c5de382225234ceb37b1844ebdb140db12b2a278bb9efe2fcd19f6c82ce/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f56f1695bc5c0871cbc33dc0130fcf503aab0c57dcc5a6700a4f49eba4f2652e", size = 375067, upload-time = "2026-06-30T07:15:18.952Z" }, + { url = "https://files.pythonhosted.org/packages/87/dc/863f69d1bf04ade34b7fe0d59b9fdf6f0135fe2d7cbca74f1d665589559d/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:270b293dae9058fc9fcedab50f13cebf46fb8ed1d1d54e0521a9da5d6b211975", size = 490509, upload-time = "2026-06-30T07:15:20.434Z" }, + { url = "https://files.pythonhosted.org/packages/ce/ef/eac16a12048b45ec7c7fa94f2be3438a5f26bf9cc8580b18a1cfd609b7f6/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:127565fead0a10943b282957bd5447804ff3160ad79f2ad2635e6d249e380680", size = 382754, upload-time = "2026-06-30T07:15:21.831Z" }, + { url = "https://files.pythonhosted.org/packages/04/8f/d2f3f532616be4d06c316ef119683e832bd3d41e112bf3a88f4151c95b17/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ecabd69db66de867690f9797f2f8fa27ba501bbc24540cbdbdc649cd15888ba6", size = 366189, upload-time = "2026-06-30T07:15:23.371Z" }, + { url = "https://files.pythonhosted.org/packages/e3/29/41a7b0e98a4b44cd676ab7598419623373eb43b20be68c084935c1a8cf88/rpds_py-2026.6.3-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:58eadac9cd119677b60e1cf8ac4052f35949d71b8a9e5556efccbe82533cf22a", size = 377750, upload-time = "2026-06-30T07:15:24.659Z" }, + { url = "https://files.pythonhosted.org/packages/2e/05/ecda0bec46f9a1565090bcdc941d023f6a25aff85fda28f89f8d19878152/rpds_py-2026.6.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7491ee23305ac3eb59e492b6945881f5cd77a6f731061a3f25b77fd40f9e99a4", size = 395576, upload-time = "2026-06-30T07:15:25.987Z" }, + { url = "https://files.pythonhosted.org/packages/68/a8/6ed52f03ee6cb854ce78785cc9a9a672eb880e83fd7224d471f667d151f1/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2c99f7e8ccb3dd6e3e4bfeac657a7b208c9bac8075f4b078c02d7404c34107fa", size = 543807, upload-time = "2026-06-30T07:15:27.356Z" }, + { url = "https://files.pythonhosted.org/packages/8f/d6/156c0d3eea27ba09b92562ba2364ba124c0a061b199e17eac637cd25a5e2/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:62698275682bf121181861295c9181e789030a2d516071f5b8f3c23c170cd0fc", size = 611187, upload-time = "2026-06-30T07:15:28.931Z" }, + { url = "https://files.pythonhosted.org/packages/f1/31/774212ed989c62f7f310220089f9b0a3fb8f40f5443d1727abd5d9f52bc9/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a214c993455f99a89aaeadc9b21241900037adc9d97203e374d75513c5911822", size = 573030, upload-time = "2026-06-30T07:15:30.553Z" }, + { url = "https://files.pythonhosted.org/packages/c9/50/22f73127a41f1ce4f87fe39aadfb9a126345801c274aa93ae88456249327/rpds_py-2026.6.3-cp312-cp312-win32.whl", hash = "sha256:501f9f04a588d6a09179368c57071301445191767c64e4b52a6aa9871f1ef5ed", size = 202185, upload-time = "2026-06-30T07:15:32.027Z" }, + { url = "https://files.pythonhosted.org/packages/04/3a/f0ee4d4dde9d3b69dedf1b5f74e7a40017046d55052d173e418c6a94f960/rpds_py-2026.6.3-cp312-cp312-win_amd64.whl", hash = "sha256:2c958bf94822e9290a40aaf2a822d4bc5c88099093e3948ad6c571eca9272e5f", size = 220394, upload-time = "2026-06-30T07:15:33.359Z" }, + { url = "https://files.pythonhosted.org/packages/f3/83/3382fe37f809b59f02aac04dbc4e765b480b46ee0227ed516e3bdc4d3dfc/rpds_py-2026.6.3-cp312-cp312-win_arm64.whl", hash = "sha256:22bffe6042b9bcb0822bcd1955ec00e245daf17b4344e4ed8e9551b976b63e96", size = 215753, upload-time = "2026-06-30T07:15:34.778Z" }, + { url = "https://files.pythonhosted.org/packages/a4/9e/b818ee580026ec578138e961027a68820c40afeb1ec8f6819b54fb99e196/rpds_py-2026.6.3-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:3cfe765c1da0072636ca06628261e0ea05688e160d5c8a03e0217c3854037223", size = 343012, upload-time = "2026-06-30T07:15:36.005Z" }, + { url = "https://files.pythonhosted.org/packages/f3/6b/686d9dc4359a8f163cfbbf89ee0b4e586431de22fe8248edb63a8cf50d49/rpds_py-2026.6.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f4d78253f6996be4901669ad25319f842f740eccf4d58e3c7f3dd39e6dde1d8f", size = 338203, upload-time = "2026-06-30T07:15:37.462Z" }, + { url = "https://files.pythonhosted.org/packages/9e/9b/069aa329940f8207615e091f5eedbbd40e1e15eac68a0790fd05ccdf796c/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:54f45a148e28767bf343d33a684693c70e451c6f4c0e9904709a723fafbdfc1f", size = 367984, upload-time = "2026-06-30T07:15:39.008Z" }, + { url = "https://files.pythonhosted.org/packages/14/db/34c203e4becff3703e4d3bc121842c00b8689197f398161203a880052f4e/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:842e7b070435622248c7a2c44ae53fa1440e073cc3023bc919fed570884097a7", size = 374815, upload-time = "2026-06-30T07:15:40.253Z" }, + { url = "https://files.pythonhosted.org/packages/ee/7d/8071067d2cc453d916ad836e828c943f575e8a44612537759002a1e07381/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8020133a74bd81b4572dd8e4be028a6b1ebcd70e6726edc3918008c08bee6ee6", size = 490545, upload-time = "2026-06-30T07:15:41.729Z" }, + { url = "https://files.pythonhosted.org/packages/a3/42/da06c5aa8f0484ff07f270787434204d9f4535e2f8c3b51ed402267e63c3/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cdc7e35386f3847df728fbcb5e887e2d79c19e2fa1eba9e51b6621d23e3243af", size = 382828, upload-time = "2026-06-30T07:15:43.327Z" }, + { url = "https://files.pythonhosted.org/packages/57/d7/fe978efc2ae50abe48eb7464668ea99f53c010c60aeebb7b35ad27f23661/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:acac386b453c2516111b50985d60ce46e7fadb5ea71ae7b25f4c946935bf27cf", size = 365678, upload-time = "2026-06-30T07:15:44.992Z" }, + { url = "https://files.pythonhosted.org/packages/69/9d/1d8922e1990b2a6eb532b6ff53d3e73d2b3bbffc84116c75826bee73dfc6/rpds_py-2026.6.3-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:425560c6fa0415f27261727bb20bd097568485e5eb0c121f1949417d1c516885", size = 377811, upload-time = "2026-06-30T07:15:46.523Z" }, + { url = "https://files.pythonhosted.org/packages/b1/3d/198dceafb4fb034a6a47347e1b0735d34e0bd4a50be4e898d408ee66cb14/rpds_py-2026.6.3-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a550fb4950a06dde3beb4721f5ad4b25bf4513784665b0a8522c792e2bd822a4", size = 395382, upload-time = "2026-06-30T07:15:47.955Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f1/13968e49655d40b6b19d8b9140296bbc6f1d86b3f0f6c346cf9f1adddf4b/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4f4bca01b63096f606e095734dd56e74e175f94cfbf24ff3d63281cec61f7bb7", size = 543832, upload-time = "2026-06-30T07:15:49.33Z" }, + { url = "https://files.pythonhosted.org/packages/ac/ab/289bcb1b90bd3e40a2900c561fa0e2087345ecbb094f0b870f2345142b7c/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ccffae9a092a00deb7efd545fe5e2c33c33b88e7c054337e9a74c179347d0b7d", size = 611011, upload-time = "2026-06-30T07:15:50.847Z" }, + { url = "https://files.pythonhosted.org/packages/1e/16/5043105e679436ccfbc8e5e0dd2d663ed18a8b8113515fd06a5e5d77c83e/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1cf01971c4f2c5553b772a542e4aaf191789cd331bc2cd4ff0e6e65ba49e1e97", size = 572431, upload-time = "2026-06-30T07:15:52.394Z" }, + { url = "https://files.pythonhosted.org/packages/85/ed/adab103321c0a6565d5ae1c2998349bc3ee175b82ccc5ae8fc04cc413075/rpds_py-2026.6.3-cp313-cp313-win32.whl", hash = "sha256:8c3d1e9c15b9d51ca0391e13da1a25a0a4df3c58a37c9dc368e0736cf7f69df0", size = 201710, upload-time = "2026-06-30T07:15:53.894Z" }, + { url = "https://files.pythonhosted.org/packages/7b/ed/a03b09668e74e5dabbf2e211f6468e1820c0552f7b0500082da31841bf7b/rpds_py-2026.6.3-cp313-cp313-win_amd64.whl", hash = "sha256:9250a9a0a6fd4648b3f868da8d91a4c52b5811a62df58e753d50ae4454a36f80", size = 219454, upload-time = "2026-06-30T07:15:55.25Z" }, + { url = "https://files.pythonhosted.org/packages/27/17/b8642c12930b71bc2b25831f6708ccf0f75abcd11883932ec9ce54ba3a78/rpds_py-2026.6.3-cp313-cp313-win_arm64.whl", hash = "sha256:900a67df3fd1660b035a4761c4ce73c382ea6b35f90f9863c36c6fd8bf8b09bb", size = 215063, upload-time = "2026-06-30T07:15:56.573Z" }, + { url = "https://files.pythonhosted.org/packages/b6/36/7fbe9dcdaf857fb3f63c2a2284b62492d95f5e8334e947e5fb6e7f68c9be/rpds_py-2026.6.3-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:931908d9fc855d8f74783377822be318edb6dcb19e47169dc038f9a1bf60b06e", size = 344510, upload-time = "2026-06-30T07:15:57.921Z" }, + { url = "https://files.pythonhosted.org/packages/ba/54/f785cc3d3f60839ca57a5af4927a9f347b07b2799c373fc20f7949f87c7e/rpds_py-2026.6.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d7469697dce35be237db177d42e2a2ee26e6dcc5fc052078a6fefabd288c6edd", size = 339495, upload-time = "2026-06-30T07:15:59.238Z" }, + { url = "https://files.pythonhosted.org/packages/63/ef/d4cdaf309e6b095b43597103cf8c0b951d6cca2acce68c474f75ec12e0c7/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bcfbcf66006befb9fd2aeaa9e01feaf881b4dc330a02ba07d2322b1c11be7b5d", size = 369454, upload-time = "2026-06-30T07:16:01.021Z" }, + { url = "https://files.pythonhosted.org/packages/96/4a/9559a68b7ee15db09d7981212e8c2e219d2a1d6d4faa0391d813c3496a36/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:847927daf4cffbd4e90e42bc890069897101edd015f956cb8721b3473372edda", size = 374583, upload-time = "2026-06-30T07:16:02.287Z" }, + { url = "https://files.pythonhosted.org/packages/ef/75/8964aa7d2c6e8ac43eba8eb6e6b0fdda1f46d39f2fc3e6aa9f2cb17f485d/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aca6c1ef08a82bfe327cc156da694660f599923e2e6665b6d81c9c2d0ac9ffc8", size = 492919, upload-time = "2026-06-30T07:16:03.723Z" }, + { url = "https://files.pythonhosted.org/packages/8f/97/6908094ac804115e65aedfd90f1b5fee4eebebd3f6c4cfc5419939267565/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ae50181a047c871561212bb97f7932a2d45fb53e947bd9b57ebad85b529cbc53", size = 383725, upload-time = "2026-06-30T07:16:05.305Z" }, + { url = "https://files.pythonhosted.org/packages/d1/9c/0d1fdc2e7aba23e290d603bc494e97bd205bae262ce33c6b32a69768ed5e/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc319e5a1de4b6913aac94bf6a2f9e847371e0a140a43dd4991db1a09bc2d504", size = 367255, upload-time = "2026-06-30T07:16:07.086Z" }, + { url = "https://files.pythonhosted.org/packages/c4/fe/f0209ca4a9ed074bc8acb44dfd0e81c3122e94c9689f5645b7973a866719/rpds_py-2026.6.3-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:e4316bf32babbed84e691e352faf967ce2f0f024174a8643c37c94a1080374fc", size = 379060, upload-time = "2026-06-30T07:16:08.525Z" }, + { url = "https://files.pythonhosted.org/packages/c6/8d/f1cc54c616b9d8897de8738aac148d20afca93f68187475fe194d09a71b9/rpds_py-2026.6.3-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8c6e5a2f750cc71c3e3b11d71661f21d6f9bc6cebc6564b1466417a1ec03ec77", size = 395960, upload-time = "2026-06-30T07:16:09.989Z" }, + { url = "https://files.pythonhosted.org/packages/fb/04/aafff00f73aeca2945f734f1d483c64ab8f472d0864ab02377fd8e89c3b2/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4470ce197d4090875cf6affbf1f853338387428df97c4fb7b7106317b8214698", size = 545356, upload-time = "2026-06-30T07:16:11.816Z" }, + { url = "https://files.pythonhosted.org/packages/fd/cc/e229663b9e4ddac5a4acbe9085dd80a71af2a5d356b8b39d6bff233f24b0/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ea964164cc9afa72d4d9b23cc28dafae93693c0a53e0b42acbff15b22c3f9ddd", size = 612319, upload-time = "2026-06-30T07:16:13.586Z" }, + { url = "https://files.pythonhosted.org/packages/e3/7a/8a0e6d3e6cd066af108b71b43122c3fe158dd9eb86acac626593a2582eb1/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:639c8929aa0afe81be836b04de888460d6bed38b9c54cfc18da8f6bfabf5af5d", size = 573508, upload-time = "2026-06-30T07:16:15.23Z" }, + { url = "https://files.pythonhosted.org/packages/87/03/2a69ab618a789cf6cf85c86bb844c62d090e700ab1a2aa676b3741b6c516/rpds_py-2026.6.3-cp314-cp314-win32.whl", hash = "sha256:882076c00c0a608b131187055ddc5ae29f2e7eaf870d6168980420d58528a5c8", size = 202504, upload-time = "2026-06-30T07:16:16.893Z" }, + { url = "https://files.pythonhosted.org/packages/85/62/a3892ba945f4e24c78f352e5de3c7620d8479f73f211406a97263d13c7d2/rpds_py-2026.6.3-cp314-cp314-win_amd64.whl", hash = "sha256:0be972be84cfcaf46c8c6edf690ca0f154ac17babf1f6a955a51579b34ad2dc5", size = 220380, upload-time = "2026-06-30T07:16:18.108Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e7/c2bd44dc831931815ad11ebb5f430b5a0a4d3caa9de837107876c30c3432/rpds_py-2026.6.3-cp314-cp314-win_arm64.whl", hash = "sha256:2a9c6f195058cb45335e8cc3802745c603d716eb96bc9625950c1aac71c0c703", size = 215976, upload-time = "2026-06-30T07:16:19.654Z" }, + { url = "https://files.pythonhosted.org/packages/79/9c/fff7b74bce9a091ec9a012a03f9ff5f69364eaf9451060dfc4486da2ffdd/rpds_py-2026.6.3-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:f90938e92afda60266da758ee7d363447f7f0138c9559f9e1811629580582d90", size = 346840, upload-time = "2026-06-30T07:16:21.268Z" }, + { url = "https://files.pythonhosted.org/packages/e9/44/77bcb1168b33704908295533d27f10eb811e9e3e193e8993dc99572211d3/rpds_py-2026.6.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ec829541c45bca16e61c7ae50c20501f213605beb75d1aba91a6ee37fbbb56a4", size = 340282, upload-time = "2026-06-30T07:16:22.875Z" }, + { url = "https://files.pythonhosted.org/packages/87/3c/7a9081c7c9e645b39efe19e4ffbeccd80add246327cd9b888aecffd72317/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:afd70d95892096cdb26f15a00c45907b17817577aa8d1c76b2dcc2788391f9e9", size = 370403, upload-time = "2026-06-30T07:16:24.415Z" }, + { url = "https://files.pythonhosted.org/packages/f7/69/af47021eb7dad6ff3396cb001c08f0f3c4d06c20253f75be6421a59fe6b7/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:29dfa0533a5d4c94d4dfa1b694fcb56c9c63aad8330ffdd816fd225d0a7a162f", size = 376055, upload-time = "2026-06-30T07:16:26.111Z" }, + { url = "https://files.pythonhosted.org/packages/81/fc/a3bcf517084396a6dd258c592567a3c011ba4557f2fde23dceaf26e74f2e/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:af05d726809bff6b141be124d4c7ce998f9c9c7f30edb1f46c07aa103d540b41", size = 494419, upload-time = "2026-06-30T07:16:27.596Z" }, + { url = "https://files.pythonhosted.org/packages/c9/eb/13d529d1788135425c7bf207f8463458ca5d92e43f3f701365b83e9dffc1/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9826217f048f620d9a712672818bf231442c1b35d96b227a07eabd11b4bb6945", size = 384848, upload-time = "2026-06-30T07:16:29.183Z" }, + { url = "https://files.pythonhosted.org/packages/8e/f4/b7ac49f30013aba8f7b9566b1dd07e81de95e708c1374b7bacc5b9bc5c9c/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:536bceea4fa4acf7e1c61da2b5786304367c816c8895be71b8f537c480b0ea1f", size = 371369, upload-time = "2026-06-30T07:16:30.912Z" }, + { url = "https://files.pythonhosted.org/packages/31/86/6260bafa622f788b07ddec0e52d810305c8b9b0b8c27f58a2ab04bf62b4f/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:bc0011654b91cc4fb2ae701bec0a0ba1e552c0714247fa7af6c59e0ccfa3a4e1", size = 379673, upload-time = "2026-06-30T07:16:32.486Z" }, + { url = "https://files.pythonhosted.org/packages/19/c3/03f1ee79a047b48daeca157c89a18509cde22b6b951d642b9b0af1be660a/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:539d75de9e0d536c84ff18dfeb805398e58227001ce09231a26a08b9aed1ee0e", size = 397500, upload-time = "2026-06-30T07:16:34.471Z" }, + { url = "https://files.pythonhosted.org/packages/f0/95/8ed0cd8c377dca12aea498f119fe639fc474d1461545c39d2b5872eb1c0f/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:166cf54d9f44fc6ceb53c7860258dde44a81406646de79f8ed3234fca3b6e538", size = 545978, upload-time = "2026-06-30T07:16:36.45Z" }, + { url = "https://files.pythonhosted.org/packages/d3/f2/0eb57f0eaa83f8fc152a7e03de968ab77e1f00732bebc892b190c6eebde7/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:d34c20167764fbcf927194d532dd7e0c56772f0a5f943fa5ef9e9afbba8fb9db", size = 613350, upload-time = "2026-06-30T07:16:38.213Z" }, + { url = "https://files.pythonhosted.org/packages/5b/de/e0674bdbc3ef7634989b3f854c3f34bc1f587d36e5bfdc5c378d57034619/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ea7bb13b7c9a29791f87a0387ba7d3ad3a6d783d827e4d3f27b40a0ff44495e2", size = 576486, upload-time = "2026-06-30T07:16:39.797Z" }, + { url = "https://files.pythonhosted.org/packages/f2/f6/21101359743cd136ada781e8210a85769578422ba460672eea0e29739200/rpds_py-2026.6.3-cp314-cp314t-win32.whl", hash = "sha256:6de4744d05bd1aa1be4ed7ea1189e3979196808008113bbbf899a460966b925e", size = 201068, upload-time = "2026-06-30T07:16:41.316Z" }, + { url = "https://files.pythonhosted.org/packages/a6/b2/9574d4d44f7760c2aa32d92a0a4f41698e33f5b204a0bf5c9758f52c79d5/rpds_py-2026.6.3-cp314-cp314t-win_amd64.whl", hash = "sha256:c7b9a2f8f4d8e90af72571d3d495deebdd7e3c75451f5b41719aee166e940fc2", size = 220600, upload-time = "2026-06-30T07:16:43.091Z" }, + { url = "https://files.pythonhosted.org/packages/08/ae/f23a2697e6ee6340a578b0f136be6483657bef0c6f9497b752bb5c0964bb/rpds_py-2026.6.3-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:e059c5dde6452b44424bd1834557556c226b57781dee1227af23518459722b13", size = 344726, upload-time = "2026-06-30T07:16:44.5Z" }, + { url = "https://files.pythonhosted.org/packages/c3/63/e7b3a1a5358dd32c930a1062d8e15b67fd6e8922e81df9e91706d66ee5c8/rpds_py-2026.6.3-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2f7c26fbc5acd2522b95d4177fe4710ffd8e9b20529e703ffbf8db4d93903f05", size = 339587, upload-time = "2026-06-30T07:16:46.255Z" }, + { url = "https://files.pythonhosted.org/packages/ec/64/10a85681916ca55fffb91b0a211f84e34297c109243484dd6394660a8a7c/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3086b538543802f84c843911242db20447de00d8752dd0efc936dbcf02218ba", size = 369585, upload-time = "2026-06-30T07:16:48.101Z" }, + { url = "https://files.pythonhosted.org/packages/76/c2/baf95c7c38823e12ba34407c5f5767a89e5cf2233895e56f608167ae9493/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8f2e5c5ee828d42cb11760761c0af6507927bec42d0ad5458f97c9203b054617", size = 375479, upload-time = "2026-06-30T07:16:49.93Z" }, + { url = "https://files.pythonhosted.org/packages/6a/94/0aad06c72d65101e11d33528d438cda99a39ce0da99466e156158f2541d3/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ed0c1e5d10cdc7135537988c74a0188da68e2f3c30813ba3744ab1e42e0480f9", size = 492418, upload-time = "2026-06-30T07:16:51.641Z" }, + { url = "https://files.pythonhosted.org/packages/b5/17/de3f5a479a1f056535d7489819639d8cd591ea6281d700390b43b1abd745/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8c2642a7603ec0b16ed77da4555db3b4b472341904873788327c0b0d7b95f1bb", size = 384123, upload-time = "2026-06-30T07:16:53.622Z" }, + { url = "https://files.pythonhosted.org/packages/46/7d/bf09bd1b145bb2671c03e1e6d1ab8651858d90d8c7dfeadd85a37a934fd8/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e4320744c1ffdd95a603def63344bfab2d33edeab301c5007e7de9f9f5b3885", size = 367351, upload-time = "2026-06-30T07:16:55.241Z" }, + { url = "https://files.pythonhosted.org/packages/a3/ea/1bb734f314b8be319149ddee80b18bd41372bdcfbdf88d28131c0cd37719/rpds_py-2026.6.3-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:a9f4645593036b81bbdb36b9c8e0ea0d1c3fee968c4d59db0344c14087ef143a", size = 378827, upload-time = "2026-06-30T07:16:56.841Z" }, + { url = "https://files.pythonhosted.org/packages/4b/93/d9611e5b25e26df9a3649813ed66193ace9347a7c7fc4ab7cf70e94851c0/rpds_py-2026.6.3-cp315-cp315-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e55d236be29255554da47abe5c577637db7c24a02b8b46f0ca9524c855801868", size = 395966, upload-time = "2026-06-30T07:16:58.557Z" }, + { url = "https://files.pythonhosted.org/packages/c3/cb/99d77e16e5534ae1d90629bbe419ba6ee170833a6a85e3aa1cc41726fbbc/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:24e9c5386e16669b674a69c156c8eeefcb578f3b3397b713b08e6d60f3c7b187", size = 545680, upload-time = "2026-06-30T07:17:00.164Z" }, + { url = "https://files.pythonhosted.org/packages/59/15/11a29755f790cef7a2f755e8e14f4f0c33f39489e1893a632a2eee59672b/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:c60924535c75f1566b6eb75b5c31a48a43fef04fa2d0d201acbad8a9969c6107", size = 611853, upload-time = "2026-06-30T07:17:01.962Z" }, + { url = "https://files.pythonhosted.org/packages/68/86/0c27547e21644da938fb530f7e1a8148dd24d02db07e7a5f2567a17ce710/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:38a2fea2787428f811719ceb9114cb78964a3138838320c29ac39526c79c16ba", size = 573715, upload-time = "2026-06-30T07:17:03.693Z" }, + { url = "https://files.pythonhosted.org/packages/29/71/4d8fcf700931815594bce892255bbd973b94efaf0fc1932b0590df18d886/rpds_py-2026.6.3-cp315-cp315-win32.whl", hash = "sha256:d483fe17f01ad64b7bf7cc38fcefff1ca9fb83f8c2b2542b68f97ffe0611b369", size = 202864, upload-time = "2026-06-30T07:17:05.746Z" }, + { url = "https://files.pythonhosted.org/packages/eb/62/b577562de0edbb55b2be85ce5fd09c33e386b9b13eee09833af4240fd5c4/rpds_py-2026.6.3-cp315-cp315-win_amd64.whl", hash = "sha256:67e3a721ffc5d8d2210d3671872298c4a84e4b8035cfe42ffd7cde35d772b146", size = 220430, upload-time = "2026-06-30T07:17:07.471Z" }, + { url = "https://files.pythonhosted.org/packages/c8/95/d6d0b2509825141eef60669a5739eec88dbc6a48053d6c92993a5704defe/rpds_py-2026.6.3-cp315-cp315-win_arm64.whl", hash = "sha256:6e84adbcf4bf841aed8116a8264b9f50b4cb3e7bd89b516122e616ac56ca269e", size = 215877, upload-time = "2026-06-30T07:17:09.008Z" }, + { url = "https://files.pythonhosted.org/packages/b7/bf/f3ea278f0afd615c1d0f19cb69043a41526e2bb600c2b536eb192218eb27/rpds_py-2026.6.3-cp315-cp315t-macosx_10_12_x86_64.whl", hash = "sha256:ae6dd8f10bd17aad820876d24caec9efdafd80a318d16c0a48edb5e136902c6b", size = 346933, upload-time = "2026-06-30T07:17:10.762Z" }, + { url = "https://files.pythonhosted.org/packages/9d/29/9907bdf1c5346763cf10b7f6852aad86652168c259def904cbe0082c5864/rpds_py-2026.6.3-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:bdbd97738551fca3917c1bd7188bec1920bb520104f28e7e1007f9ceb17b7690", size = 340274, upload-time = "2026-06-30T07:17:12.266Z" }, + { url = "https://files.pythonhosted.org/packages/6f/2c/8e03767b5778ef25cebf74a7a91a2c3806f8eced4c92cb7406bbe060756d/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b95977e7211527ab0ba576e286d023389fbeeb32a6b7b771665d333c60e5342", size = 370763, upload-time = "2026-06-30T07:17:14.107Z" }, + { url = "https://files.pythonhosted.org/packages/2e/e1/df2a7e1ba2efd796af26194250b8d42c821b46592311595162af9ef0528d/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d15fde0e6fb0d88a60d221204873743e5d9f0b7d29165e62cd86d0413ad74ba6", size = 376467, upload-time = "2026-06-30T07:17:15.76Z" }, + { url = "https://files.pythonhosted.org/packages/6b/de/8a0814d1946af29cb068fb259aa8622f856df1d0bab58429448726b537f5/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a136d453475ac0fcbda502ef1e6504bd28d6d904700915d278deeab0d00fe140", size = 496689, upload-time = "2026-06-30T07:17:17.308Z" }, + { url = "https://files.pythonhosted.org/packages/df/f3/f19e0c852ba13694f5a79f3b719331051573cb5693feacf8a88ffffc3a71/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f826877d462181e5eb1c26a0026b8d0cab05d99844ecb6d8bf3627a2ca0c0442", size = 385340, upload-time = "2026-06-30T07:17:18.928Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ae/7ec3a9d2d4351f99e37bcb06b6b6f954512646bfdbf9742e1de727865daf/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:79486287de1730dbaff3dbd124d0ca4d2ef7f9d29bf2544f1f93c09b5bcbbd12", size = 372179, upload-time = "2026-06-30T07:17:20.539Z" }, + { url = "https://files.pythonhosted.org/packages/d3/ac/9cee911dff2aaa9a5a8354f6610bf2e6a616de9197c5fff4f54f82585f1e/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_31_riscv64.whl", hash = "sha256:808345f53cb952433ca2816f1604ff3515608a81784954f38d4452acfe8e61d5", size = 379993, upload-time = "2026-06-30T07:17:22.212Z" }, + { url = "https://files.pythonhosted.org/packages/83/6b/7c2a07ba88d1e9a936612f7a5d067467ed03d971d5a06f7d309dff044a7e/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1967debc37f64f2c4dc90a7f563aec558b471966e12adcac4e1c4240496b6ebf", size = 398909, upload-time = "2026-06-30T07:17:23.66Z" }, + { url = "https://files.pythonhosted.org/packages/97/0b/776ffcb66783637b0031f6d58d6fb55913c8b5abf00aeecd46bf933fb477/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:f0840b5b17057f7fd918b76183a4b5a0635f43e14eb2ce60dce1d4ee4707ea00", size = 546584, upload-time = "2026-06-30T07:17:25.264Z" }, + { url = "https://files.pythonhosted.org/packages/55/33/ba3bc04d7092bd553c9b2b195624992d2cc4f3de1f380b7b93cbee67bd79/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:faa679d19a6696fd54259ad321251ad77a13e70e03dd834daa762a44fb6196ef", size = 614357, upload-time = "2026-06-30T07:17:26.888Z" }, + { url = "https://files.pythonhosted.org/packages/8b/71/14edf065f04630b1a8472f7653cad03f6c478bcf95ea0e6aed55451e33ea/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:23a439f31ccbeff1574e24889128821d1f7917470e830cf6544dced1c662262a", size = 576533, upload-time = "2026-06-30T07:17:28.546Z" }, + { url = "https://files.pythonhosted.org/packages/ba/76/65002b08596c389105720a8c0d22298b8dc25a4baf89b2ce431343c8b1de/rpds_py-2026.6.3-cp315-cp315t-win32.whl", hash = "sha256:913ca42ccad3f8cc6e292b587ae8ae49c8c823e5dce51a736252fc7c7cdfa577", size = 201204, upload-time = "2026-06-30T07:17:30.193Z" }, + { url = "https://files.pythonhosted.org/packages/8c/97/d855d6b3c322d1f27e26f5241c42016b56cf01377ea8ed348285f54652f0/rpds_py-2026.6.3-cp315-cp315t-win_amd64.whl", hash = "sha256:ae3d4fe8c0b9213624fdce7279d70e3b148b682ca20719ebd193a23ebfa47324", size = 220719, upload-time = "2026-06-30T07:17:31.788Z" }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, +] + +[[package]] +name = "sse-starlette" +version = "3.4.8" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "starlette" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f8/00/b42a44342a054d58cb1115d7c8aa9cb4290dd9442f9c1b91a4b8173dba22/sse_starlette-3.4.8.tar.gz", hash = "sha256:ed89ffbb75cbf78a5fe2f2109cd584792ee7f9dfac96f791db546df8f15f3f9c", size = 32548, upload-time = "2026-08-05T11:19:49.982Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dd/3a/764912c58293d95b6dcdf4cc255f9d10de310580ced547b082eb9d72018c/sse_starlette-3.4.8-py3-none-any.whl", hash = "sha256:6e82314c786709a3cd9520f2285cf9fff90e181e598e8a357b0cf80f66afba0d", size = 16516, upload-time = "2026-08-05T11:19:48.748Z" }, +] + +[[package]] +name = "starlette" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b5/b4/205b0d5241d934e8add0c38aa924c4f9fb7330834ff11e5444db964ec3f9/starlette-1.6.0.tar.gz", hash = "sha256:d4e3ac5e546444960c710297a3c9fc3f7ebae1b7e963f3d36173b49da535be9b", size = 2716969, upload-time = "2026-08-08T18:27:57.512Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/cb/6a6a47d5b464bd08695d254f3da6e7986cc70c9fa5d778eda57538edfe56/starlette-1.6.0-py3-none-any.whl", hash = "sha256:a86dd39d14bb45f85a3d18525215a9ef0cfd1f192ac793220e72598c90335f0c", size = 75969, upload-time = "2026-08-08T18:27:56.196Z" }, +] + +[[package]] +name = "tokenizers" +version = "0.23.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "huggingface-hub" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c1/60/21f715d9faba5f5407ff759472ade058ec4a507ad62bcea47cb847239a73/tokenizers-0.23.1.tar.gz", hash = "sha256:1feeeadf865a7915adc25445dea30e9933e593c31bb96c277cee36de227c8bfa", size = 365748, upload-time = "2026-04-27T14:43:25.606Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/87/39/b87a87d5bb9470610b80a2d31df42fcffeaf35118b8b97952b2aff598cc7/tokenizers-0.23.1-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:e03d6ffcbe0d56ee9c1ccd070e70a13fa750727c0277e138152acbc0252c2224", size = 3146732, upload-time = "2026-04-27T14:43:15.427Z" }, + { url = "https://files.pythonhosted.org/packages/e2/6a/068ed9f6e444c9d7e9d55ce134181325700f3d7f30410721bdc8f848d727/tokenizers-0.23.1-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:e0948bbb1ac1d7cdfc9fb6d62c596e3b7550036ad60ecd654a66ad273326324e", size = 3054954, upload-time = "2026-04-27T14:43:13.745Z" }, + { url = "https://files.pythonhosted.org/packages/6c/36/e006edf031154cba92b8416057d92c3abe3635e4c4b0aa0b5b9bb39dde70/tokenizers-0.23.1-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1bf13402aff9bc533c89cb849ec3b412dc3fbeacc9744840e423d7bf3f7dc0e3", size = 3374081, upload-time = "2026-04-27T14:43:01.241Z" }, + { url = "https://files.pythonhosted.org/packages/a2/ef/7735d226f9c7f874a6bee5e3f27fb25ecabdf207d37b8cf45286d0795893/tokenizers-0.23.1-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f836ca703b89ae07919a309f9651f7a88fd5a33d5f718ba5ad0870ec0256bad6", size = 3247641, upload-time = "2026-04-27T14:43:03.856Z" }, + { url = "https://files.pythonhosted.org/packages/b9/d9/24827036f6e21297bfffda0768e58eb6096a4f411e932964a01707857931/tokenizers-0.23.1-cp310-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae848657742035523fdf261773630cb819a26995fcd3d9ecae0c1daf6e5a4959", size = 3585624, upload-time = "2026-04-27T14:43:10.664Z" }, + { url = "https://files.pythonhosted.org/packages/0c/9a/22f3582b3a4f49358293a5206e25317621ee4526bfe9cdaa0f07a12e770e/tokenizers-0.23.1-cp310-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:53b09e85775d5187941e7bab30e941b4134ab4a7dd8c68e783d231fb7ca27c51", size = 3844062, upload-time = "2026-04-27T14:43:05.643Z" }, + { url = "https://files.pythonhosted.org/packages/7e/65/b8f8814eef95800f20721384136d9a1d22241d50b2874357cb70542c392f/tokenizers-0.23.1-cp310-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ea5a0ce170074329faaa8ea3f6400ecde604b6678192688533af80980daae71a", size = 3460098, upload-time = "2026-04-27T14:43:08.854Z" }, + { url = "https://files.pythonhosted.org/packages/0d/d5/1353e5f677ec27c2494fb6a6725e82d56c985f53e90ec511369e7e4f02c6/tokenizers-0.23.1-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5075b405006415ea148a992d093699c66eb01952bf59f4d5727089a98bda45a4", size = 3346235, upload-time = "2026-04-27T14:43:12.377Z" }, + { url = "https://files.pythonhosted.org/packages/71/89/39b6b8fc073fb6d413d0147aa333dc7eff7be65639ac9d19930a0b21bf33/tokenizers-0.23.1-cp310-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:56f3a77de629917652f876294dc9fe6bad4a0c43bc229dc72e59bb23a0f4729a", size = 3426398, upload-time = "2026-04-27T14:43:07.264Z" }, + { url = "https://files.pythonhosted.org/packages/0f/80/127c854da64827e5b79264ce524993a90dddcb320e5cd42412c5c02f9e8a/tokenizers-0.23.1-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9d10a6d957ef01896dc274e890eee27d41bd0e74ef31e60616f0fc311345184e", size = 9823279, upload-time = "2026-04-27T14:43:17.222Z" }, + { url = "https://files.pythonhosted.org/packages/fe/ba/44c2502feb1a058f096ddfb4e0996ef3225a01a388e1a9b094e91689fe93/tokenizers-0.23.1-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:1974288a609c343774f1b897c8b482c791ab17b75ab5c8c2b1737565c1d82288", size = 9644986, upload-time = "2026-04-27T14:43:19.45Z" }, + { url = "https://files.pythonhosted.org/packages/9e/c1/464019a9fb059870bfe4eebb4ba12208f3042035e258bf5e782906bd3847/tokenizers-0.23.1-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:120468fb4c24faf0543c835a4fabafa4deb3f20a035c9b6e83d0b553a97615d4", size = 9976181, upload-time = "2026-04-27T14:43:21.463Z" }, + { url = "https://files.pythonhosted.org/packages/79/94/3ac1432bda31626071e9b6a12709b97ae05131c804b94c8f3ac622c5da32/tokenizers-0.23.1-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e3d8f40ea6268047de7046906326abed5134f27d4e8447b23763afe5808c8a96", size = 10113853, upload-time = "2026-04-27T14:43:23.617Z" }, + { url = "https://files.pythonhosted.org/packages/6a/dd/631b21433c771b1382535326f0eca80b9c9cee2e64961dd993bc9ac4669e/tokenizers-0.23.1-cp310-abi3-win32.whl", hash = "sha256:93120a930b919416da7cd10a2f606ac9919cc69cacae7980fa2140e277660948", size = 2536263, upload-time = "2026-04-27T14:43:29.888Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/2553f72aaf65a2797d4229e37fa7fbe38ffbf3e32912d31bdd78b3323e59/tokenizers-0.23.1-cp310-abi3-win_amd64.whl", hash = "sha256:e7bfaf995c1bdbbd21d13539decb6650967013759318627d85daeb7881af16b7", size = 2798223, upload-time = "2026-04-27T14:43:28.51Z" }, + { url = "https://files.pythonhosted.org/packages/cd/2b/2be299bab55fc595e3d38567edb1a87f86e594842968fa9515a07bdcf422/tokenizers-0.23.1-cp310-abi3-win_arm64.whl", hash = "sha256:a26197957d8e4425dfba746315f3c425ea00cfa8367c5fbc4ec73447893dcea9", size = 2664127, upload-time = "2026-04-27T14:43:26.949Z" }, +] + +[[package]] +name = "tqdm" +version = "4.70.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/21/3b/6c24bec5be5e743ffd99576daa5cc077722fc7d5bbc00bd133fa0c698dc6/tqdm-4.70.0.tar.gz", hash = "sha256:55b0b0dbd97462d06ebee91e4dac24ed4d4702be82b24f07e6c1d27e08cea220", size = 795438, upload-time = "2026-07-27T11:33:15.271Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/1c/01bfd571a64e7f270e6bab5e33777debe0edc56759233ce84f27dec92d14/tqdm-4.70.0-py3-none-any.whl", hash = "sha256:7f585706bfddbdebf89daac705b2dfcc16890130727d3197ca62c732b4310953", size = 80184, upload-time = "2026-07-27T11:33:13.167Z" }, +] + +[[package]] +name = "truststore" +version = "0.10.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/53/a3/1585216310e344e8102c22482f6060c7a6ea0322b63e026372e6dcefcfd6/truststore-0.10.4.tar.gz", hash = "sha256:9d91bd436463ad5e4ee4aba766628dd6cd7010cf3e2461756b3303710eebc301", size = 26169, upload-time = "2025-08-12T18:49:02.73Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/19/97/56608b2249fe206a67cd573bc93cd9896e1efb9e98bce9c163bcdc704b88/truststore-0.10.4-py3-none-any.whl", hash = "sha256:adaeaecf1cbb5f4de3b1959b42d41f6fab57b2b1666adb59e89cb0b53361d981", size = 18660, upload-time = "2025-08-12T18:49:01.46Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" }, +] + +[[package]] +name = "typing-inspection" +version = "0.4.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/26/b09b8010994eccc3c09092e6b34058f36a460eea2d4c3e8b910c695975a0/typing_inspection-0.4.4.tar.gz", hash = "sha256:547274fa6b0a561ccf549cc9524b999a578e737d015d8709d021f9d0d13bea47", size = 76928, upload-time = "2026-08-12T12:37:25.997Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/67/81/4add07e5172b7ac40d8ed5ff580409a7801a4fe26d529bdd915401dabfbe/typing_inspection-0.4.4-py3-none-any.whl", hash = "sha256:65b8397ba37ccbce054456aaccddfc91e6e3083c92824df348d96ca832f3f147", size = 14750, upload-time = "2026-08-12T12:37:24.648Z" }, +] + +[[package]] +name = "urllib3" +version = "2.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" }, +] + +[[package]] +name = "uvicorn" +version = "0.52.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f2/0f/3f86e61397dd33bf2ccf28188c40db6a740658aeebbbf6e7dbc101a1f487/uvicorn-0.52.4.tar.gz", hash = "sha256:73acfee47a0b133c5de13d219492d62d8a31e935f4fe6e41a232451a15379f86", size = 100627, upload-time = "2026-08-19T06:27:41.821Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/79/4a20b54ab0491485ccd8c077db2d39187c7f12b3e15485d38a7be37c81b4/uvicorn-0.52.4-py3-none-any.whl", hash = "sha256:f86e41a149d7d05a9969337e3946a9c171c06a5d42680896daaba624aeac8da1", size = 79871, upload-time = "2026-08-19T06:27:40.36Z" }, +] + +[[package]] +name = "win32-setctime" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b3/8f/705086c9d734d3b663af0e9bb3d4de6578d08f46b1b101c2442fd9aecaa2/win32_setctime-1.2.0.tar.gz", hash = "sha256:ae1fdf948f5640aae05c511ade119313fb6a30d7eabe25fef9764dca5873c4c0", size = 4867, upload-time = "2024-12-07T15:28:28.314Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e1/07/c6fe3ad3e685340704d314d765b7912993bcb8dc198f0e7a89382d37974b/win32_setctime-1.2.0-py3-none-any.whl", hash = "sha256:95d644c4e708aba81dc3704a116d8cbc974d70b3bdb8be1d150e36be6e9d1390", size = 4083, upload-time = "2024-12-07T15:28:26.465Z" }, +] diff --git a/vendor/elabapi-python/PKG-INFO b/vendor/elabapi-python/PKG-INFO new file mode 100644 index 0000000..2d9de4d --- /dev/null +++ b/vendor/elabapi-python/PKG-INFO @@ -0,0 +1,19 @@ +Metadata-Version: 2.4 +Name: elabapi-python +Version: 5.6.1 +Summary: eLabFTW REST API v2 Documentation +Home-page: https://github.com/elabftw/elabapi-python +Author-email: +Keywords: Swagger,eLabFTW REST API v2 Documentation +Requires-Dist: urllib3>=1.15 +Requires-Dist: six>=1.10 +Requires-Dist: certifi +Requires-Dist: python-dateutil +Dynamic: description +Dynamic: home-page +Dynamic: keywords +Dynamic: requires-dist +Dynamic: summary + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + diff --git a/vendor/elabapi-python/README.md b/vendor/elabapi-python/README.md new file mode 100644 index 0000000..db5faed --- /dev/null +++ b/vendor/elabapi-python/README.md @@ -0,0 +1,417 @@ +# elabapi-python +This document describes all available endpoints and methods for eLabFTW's API version 2. + +This Python package is automatically generated by the [Swagger Codegen](https://github.com/swagger-api/swagger-codegen) project: + +- API version: 2.0.0 +- Package version: 5.6.1 +- Build package: io.swagger.codegen.v3.generators.python.PythonClientCodegen + +## Requirements. + +Python 2.7 and 3.4+ + +## Installation & Usage +### pip install + +If the python package is hosted on Github, you can install directly from Github + +```sh +pip install git+https://github.com/elabftw/elabapi-python.git +``` +(you may need to run `pip` with root permission: `sudo pip install git+https://github.com/elabftw/elabapi-python.git`) + +Then import the package: +```python +import elabapi_python +``` + +### Setuptools + +Install via [Setuptools](http://pypi.python.org/pypi/setuptools). + +```sh +python setup.py install --user +``` +(or `sudo python setup.py install` to install the package for all users) + +Then import the package: +```python +import elabapi_python +``` + +## Getting Started + +Please follow the [installation procedure](#installation--usage) and then run the following: + +```python +from __future__ import print_function +import time +import elabapi_python +from elabapi_python.rest import ApiException +from pprint import pprint + +# Configure API key authorization: token +configuration = elabapi_python.Configuration() +configuration.api_key['Authorization'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['Authorization'] = 'Bearer' + +# create an instance of the API class +api_instance = elabapi_python.ApiKeysApi(elabapi_python.ApiClient(configuration)) +id = 56 # int | ID of the API key + +try: + # Delete an API key. + api_instance.delete_apikey(id) +except ApiException as e: + print("Exception when calling ApiKeysApi->delete_apikey: %s\n" % e) + +# Configure API key authorization: token +configuration = elabapi_python.Configuration() +configuration.api_key['Authorization'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['Authorization'] = 'Bearer' + +# create an instance of the API class +api_instance = elabapi_python.ApiKeysApi(elabapi_python.ApiClient(configuration)) + +try: + # Read API keys + api_response = api_instance.get_apikeys() + pprint(api_response) +except ApiException as e: + print("Exception when calling ApiKeysApi->get_apikeys: %s\n" % e) + +# Configure API key authorization: token +configuration = elabapi_python.Configuration() +configuration.api_key['Authorization'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['Authorization'] = 'Bearer' + +# create an instance of the API class +api_instance = elabapi_python.ApiKeysApi(elabapi_python.ApiClient(configuration)) +body = elabapi_python.ApikeysBody() # ApikeysBody | (optional) + +try: + # Create an API key + api_instance.post_apikeys(body=body) +except ApiException as e: + print("Exception when calling ApiKeysApi->post_apikeys: %s\n" % e) +``` + +## Documentation for API Endpoints + +All URIs are relative to *https://elab.local:3148/api/v2* + +Class | Method | HTTP request | Description +------------ | ------------- | ------------- | ------------- +*ApiKeysApi* | [**delete_apikey**](docs/ApiKeysApi.md#delete_apikey) | **DELETE** /apikeys/{id} | Delete an API key. +*ApiKeysApi* | [**get_apikeys**](docs/ApiKeysApi.md#get_apikeys) | **GET** /apikeys | Read API keys +*ApiKeysApi* | [**post_apikeys**](docs/ApiKeysApi.md#post_apikeys) | **POST** /apikeys | Create an API key +*BrandingApi* | [**get_instance_branding**](docs/BrandingApi.md#get_instance_branding) | **GET** /instance/branding/{id} | Read a branding asset as a binary file. +*BrandingApi* | [**post_instance_branding**](docs/BrandingApi.md#post_instance_branding) | **POST** /instance/branding/{id} | Update a branding asset. +*CommentsApi* | [**delete_entity_comment**](docs/CommentsApi.md#delete_entity_comment) | **DELETE** /{entity_type}/{id}/comments/{subid} | Delete an entity comment. +*CommentsApi* | [**patch_entity_comment**](docs/CommentsApi.md#patch_entity_comment) | **PATCH** /{entity_type}/{id}/comments/{subid} | Modify an entity comment. +*CommentsApi* | [**post_entity_comments**](docs/CommentsApi.md#post_entity_comments) | **POST** /{entity_type}/{id}/comments | Create a comment. +*CommentsApi* | [**read_entity_comment**](docs/CommentsApi.md#read_entity_comment) | **GET** /{entity_type}/{id}/comments/{subid} | Read a comment of that entity. +*CommentsApi* | [**read_entity_comments**](docs/CommentsApi.md#read_entity_comments) | **GET** /{entity_type}/{id}/comments | Read all comments of that entity. +*CompoundsApi* | [**delete_compound**](docs/CompoundsApi.md#delete_compound) | **DELETE** /compounds/{id} | Soft-delete a compound +*CompoundsApi* | [**get_compound**](docs/CompoundsApi.md#get_compound) | **GET** /compounds/{id} | Get a single compound +*CompoundsApi* | [**get_compounds**](docs/CompoundsApi.md#get_compounds) | **GET** /compounds | Read compounds +*CompoundsApi* | [**post_compounds**](docs/CompoundsApi.md#post_compounds) | **POST** /compounds | Create or import a compound +*ConfigApi* | [**delete_config**](docs/ConfigApi.md#delete_config) | **DELETE** /config | Reset the config to default values +*ConfigApi* | [**get_config**](docs/ConfigApi.md#get_config) | **GET** /config | Read the config +*ConfigApi* | [**patch_config**](docs/ConfigApi.md#patch_config) | **PATCH** /config | Modify the config +*ContainersApi* | [**delete_container**](docs/ContainersApi.md#delete_container) | **DELETE** /{entity_type}/{id}/containers/{subid} | Delete a container. +*ContainersApi* | [**patch_container**](docs/ContainersApi.md#patch_container) | **PATCH** /{entity_type}/{id}/containers/{subid} | Modify a container. +*ContainersApi* | [**post_container**](docs/ContainersApi.md#post_container) | **POST** /{entity_type}/{id}/containers/{subid} | Create a container for this entity. +*ContainersApi* | [**read_container**](docs/ContainersApi.md#read_container) | **GET** /{entity_type}/{id}/containers/{subid} | Read a container. +*ContainersApi* | [**read_containers**](docs/ContainersApi.md#read_containers) | **GET** /{entity_type}/{id}/containers | Read all containers for this entity. +*CustomFieldsKeysApi* | [**custom_fields_keys**](docs/CustomFieldsKeysApi.md#custom_fields_keys) | **GET** /extra_fields_keys | Read custom fields keys. +*DSpaceApi* | [**dspace_create**](docs/DSpaceApi.md#dspace_create) | **POST** /dspace | Create a new DSpace workspace item. +*DSpaceApi* | [**dspace_read**](docs/DSpaceApi.md#dspace_read) | **GET** /dspace | Read DSpace information. +*DSpaceApi* | [**dspace_submit**](docs/DSpaceApi.md#dspace_submit) | **PATCH** /dspace | Submit an eLabFTW entry to DSpace. +*EventsApi* | [**delete_event**](docs/EventsApi.md#delete_event) | **DELETE** /event/{id} | Delete a booking slot. +*EventsApi* | [**patch_event**](docs/EventsApi.md#patch_event) | **PATCH** /event/{id} | Modify a booking slot. +*EventsApi* | [**post_events**](docs/EventsApi.md#post_events) | **POST** /events/{id} | Create an event for the item specified as id. +*EventsApi* | [**read_event**](docs/EventsApi.md#read_event) | **GET** /event/{id} | Read a booking slot. +*EventsApi* | [**read_events**](docs/EventsApi.md#read_events) | **GET** /events | Read all events in the team. +*ExperimentsApi* | [**delete_experiment**](docs/ExperimentsApi.md#delete_experiment) | **DELETE** /experiments/{id} | Delete an experiment. +*ExperimentsApi* | [**get_experiment**](docs/ExperimentsApi.md#get_experiment) | **GET** /experiments/{id} | Read an experiment +*ExperimentsApi* | [**patch_experiment**](docs/ExperimentsApi.md#patch_experiment) | **PATCH** /experiments/{id} | Modify an experiment +*ExperimentsApi* | [**post_experiment**](docs/ExperimentsApi.md#post_experiment) | **POST** /experiments | Create an experiment +*ExperimentsApi* | [**post_experiment_by_id**](docs/ExperimentsApi.md#post_experiment_by_id) | **POST** /experiments/{id} | Duplicate an experiment with its ID +*ExperimentsApi* | [**read_experiments**](docs/ExperimentsApi.md#read_experiments) | **GET** /experiments | Read all experiments that are accessible +*ExperimentsCategoriesApi* | [**delete_expcat**](docs/ExperimentsCategoriesApi.md#delete_expcat) | **DELETE** /teams/{id}/experiments_categories/{subid} | Delete a category. +*ExperimentsCategoriesApi* | [**patch_expcat**](docs/ExperimentsCategoriesApi.md#patch_expcat) | **PATCH** /teams/{id}/experiments_categories/{subid} | Modify a category. +*ExperimentsCategoriesApi* | [**post_team_one_expcat**](docs/ExperimentsCategoriesApi.md#post_team_one_expcat) | **POST** /teams/{id}/experiments_categories | Create a new category for experiments. +*ExperimentsCategoriesApi* | [**read_team_experiments_categories**](docs/ExperimentsCategoriesApi.md#read_team_experiments_categories) | **GET** /teams/{id}/experiments_categories | Read experiments categories of a team. +*ExperimentsCategoriesApi* | [**read_team_one_expcat**](docs/ExperimentsCategoriesApi.md#read_team_one_expcat) | **GET** /teams/{id}/experiments_categories/{subid} | Read a category. +*ExperimentsStatusApi* | [**delete_expstatus**](docs/ExperimentsStatusApi.md#delete_expstatus) | **DELETE** /teams/{id}/experiments_status/{subid} | Delete a status. +*ExperimentsStatusApi* | [**patch_expstatus**](docs/ExperimentsStatusApi.md#patch_expstatus) | **PATCH** /teams/{id}/experiments_status/{subid} | Modify a status. +*ExperimentsStatusApi* | [**post_team_one_expstatus**](docs/ExperimentsStatusApi.md#post_team_one_expstatus) | **POST** /teams/{id}/experiments_status | Create a new experiments status. +*ExperimentsStatusApi* | [**read_team_experiments_status**](docs/ExperimentsStatusApi.md#read_team_experiments_status) | **GET** /teams/{id}/experiments_status | Read experiments status of a team. +*ExperimentsStatusApi* | [**read_team_one_expstatus**](docs/ExperimentsStatusApi.md#read_team_one_expstatus) | **GET** /teams/{id}/experiments_status/{subid} | Read a status. +*ExperimentsTemplatesApi* | [**delete_experiment_template**](docs/ExperimentsTemplatesApi.md#delete_experiment_template) | **DELETE** /experiments_templates/{id} | Delete an experiment template. +*ExperimentsTemplatesApi* | [**get_experiment_template**](docs/ExperimentsTemplatesApi.md#get_experiment_template) | **GET** /experiments_templates/{id} | Read an experiment template +*ExperimentsTemplatesApi* | [**patch_experiment_template**](docs/ExperimentsTemplatesApi.md#patch_experiment_template) | **PATCH** /experiments_templates/{id} | Modify an experiment template +*ExperimentsTemplatesApi* | [**post_experiment_template**](docs/ExperimentsTemplatesApi.md#post_experiment_template) | **POST** /experiments_templates | Create an experiment template +*ExperimentsTemplatesApi* | [**post_experiment_template_by_id**](docs/ExperimentsTemplatesApi.md#post_experiment_template_by_id) | **POST** /experiments_templates/{id} | Duplicate an experiment template with its ID +*ExperimentsTemplatesApi* | [**read_experiments_templates**](docs/ExperimentsTemplatesApi.md#read_experiments_templates) | **GET** /experiments_templates | Read all experiments_templates that are accessible +*ExportsApi* | [**delete_export**](docs/ExportsApi.md#delete_export) | **DELETE** /exports/{id} | Remove an export request and its associated file +*ExportsApi* | [**post_export**](docs/ExportsApi.md#post_export) | **POST** /exports | Register an export request +*ExportsApi* | [**read_export**](docs/ExportsApi.md#read_export) | **GET** /exports/{id} | Get export +*ExportsApi* | [**readall_exports**](docs/ExportsApi.md#readall_exports) | **GET** /exports | List exports +*FavoriteTagsApi* | [**delete_favtag**](docs/FavoriteTagsApi.md#delete_favtag) | **DELETE** /favtags/{id} | Unfavorite a tag. +*FavoriteTagsApi* | [**post_favtags**](docs/FavoriteTagsApi.md#post_favtags) | **POST** /favtags | Add a tag as favorite. +*FavoriteTagsApi* | [**read_favtags**](docs/FavoriteTagsApi.md#read_favtags) | **GET** /favtags | Read all favorite tags for the user. +*IdpsApi* | [**delete_idp**](docs/IdpsApi.md#delete_idp) | **DELETE** /idps/{id} | Delete an idp. +*IdpsApi* | [**delete_idp_cert**](docs/IdpsApi.md#delete_idp_cert) | **DELETE** /idps/{id}/certs/{cert_id} | Delete an idp cert. +*IdpsApi* | [**delete_idp_endpoint**](docs/IdpsApi.md#delete_idp_endpoint) | **DELETE** /idps/{id}/endpoints/{endpoint_id} | Delete an idp endpoint. +*IdpsApi* | [**patch_idp**](docs/IdpsApi.md#patch_idp) | **PATCH** /idps/{id} | Actions on an idp. +*IdpsApi* | [**post_idp**](docs/IdpsApi.md#post_idp) | **POST** /idps | Create an idp. +*IdpsApi* | [**post_idp_cert**](docs/IdpsApi.md#post_idp_cert) | **POST** /idps/{id}/certs | Add a cert to this IdP. +*IdpsApi* | [**post_idp_endpoint**](docs/IdpsApi.md#post_idp_endpoint) | **POST** /idps/{id}/endpoints | Add an endpoint to this IdP. +*IdpsApi* | [**read_idp**](docs/IdpsApi.md#read_idp) | **GET** /idps/{id} | Read an idp. +*IdpsApi* | [**read_idp_cert**](docs/IdpsApi.md#read_idp_cert) | **GET** /idps/{id}/certs/{cert_id} | Read a cert for an IdP. +*IdpsApi* | [**read_idp_certs**](docs/IdpsApi.md#read_idp_certs) | **GET** /idps/{id}/certs | Read all certs for an IdP. +*IdpsApi* | [**read_idp_endpoint**](docs/IdpsApi.md#read_idp_endpoint) | **GET** /idps/{id}/endpoints/{endpoint_id} | Read an endpoint for an IdP. +*IdpsApi* | [**read_idp_endpoints**](docs/IdpsApi.md#read_idp_endpoints) | **GET** /idps/{id}/endpoints | Read all endpoints for an IdP. +*IdpsApi* | [**read_idps**](docs/IdpsApi.md#read_idps) | **GET** /idps | Read all IDPs. +*IdpsSourcesApi* | [**delete_idps_source**](docs/IdpsSourcesApi.md#delete_idps_source) | **DELETE** /idps_sources/{id} | Delete an idp source. +*IdpsSourcesApi* | [**patch_idps_source**](docs/IdpsSourcesApi.md#patch_idps_source) | **PATCH** /idps_sources/{id} | Patch an idp source. +*IdpsSourcesApi* | [**post_idp_source**](docs/IdpsSourcesApi.md#post_idp_source) | **POST** /idps_sources | Create an idp source. +*IdpsSourcesApi* | [**read_idps_source**](docs/IdpsSourcesApi.md#read_idps_source) | **GET** /idps_sources/{id} | Read an IdPs source +*IdpsSourcesApi* | [**read_idps_sources**](docs/IdpsSourcesApi.md#read_idps_sources) | **GET** /idps_sources | Read all IDPs sources +*ImportApi* | [**post_import**](docs/ImportApi.md#post_import) | **POST** /import | Send a file to import +*ImportApi* | [**read_import**](docs/ImportApi.md#read_import) | **GET** /import | Get information about this endpoint +*InfoApi* | [**get_info**](docs/InfoApi.md#get_info) | **GET** /info | Get information about the instance. +*InstanceApi* | [**post_instance**](docs/InstanceApi.md#post_instance) | **POST** /instance | Run an instance level action. +*ItemsApi* | [**delete_item**](docs/ItemsApi.md#delete_item) | **DELETE** /items/{id} | Delete an item. +*ItemsApi* | [**get_item**](docs/ItemsApi.md#get_item) | **GET** /items/{id} | Read an item +*ItemsApi* | [**patch_item**](docs/ItemsApi.md#patch_item) | **PATCH** /items/{id} | Modify an item +*ItemsApi* | [**post_item**](docs/ItemsApi.md#post_item) | **POST** /items | Create an item +*ItemsApi* | [**post_item_by_id**](docs/ItemsApi.md#post_item_by_id) | **POST** /items/{id} | Duplicate an item with its ID +*ItemsApi* | [**read_items**](docs/ItemsApi.md#read_items) | **GET** /items | Read all items that are accessible +*ItemsTypesResourcesTemplatesApi* | [**delete_items_type**](docs/ItemsTypesResourcesTemplatesApi.md#delete_items_type) | **DELETE** /items_types/{id} | Delete a resource template. +*ItemsTypesResourcesTemplatesApi* | [**get_items_type**](docs/ItemsTypesResourcesTemplatesApi.md#get_items_type) | **GET** /items_types/{id} | Read a resource template +*ItemsTypesResourcesTemplatesApi* | [**patch_items_type**](docs/ItemsTypesResourcesTemplatesApi.md#patch_items_type) | **PATCH** /items_types/{id} | Modify a resource template +*ItemsTypesResourcesTemplatesApi* | [**post_items_types**](docs/ItemsTypesResourcesTemplatesApi.md#post_items_types) | **POST** /items_types | Create a resource template +*ItemsTypesResourcesTemplatesApi* | [**post_items_types_by_id**](docs/ItemsTypesResourcesTemplatesApi.md#post_items_types_by_id) | **POST** /items_types/{id} | Duplicate a resource template with its ID +*ItemsTypesResourcesTemplatesApi* | [**read_items_types**](docs/ItemsTypesResourcesTemplatesApi.md#read_items_types) | **GET** /items_types | Read all resources templates that are accessible +*LinksToCompoundsApi* | [**delete_entity_compounds_link**](docs/LinksToCompoundsApi.md#delete_entity_compounds_link) | **DELETE** /{entity_type}/{id}/compounds_links/{subid} | Delete a compound link. +*LinksToCompoundsApi* | [**post_entity_compounds_links**](docs/LinksToCompoundsApi.md#post_entity_compounds_links) | **POST** /{entity_type}/{id}/compounds_links/{subid} | Link an entity to a compound. +*LinksToCompoundsApi* | [**read_entity_compounds_links**](docs/LinksToCompoundsApi.md#read_entity_compounds_links) | **GET** /{entity_type}/{id}/compounds_links | Read all compounds links of that entity. +*LinksToExperimentsApi* | [**delete_entity_experiments_link**](docs/LinksToExperimentsApi.md#delete_entity_experiments_link) | **DELETE** /{entity_type}/{id}/experiments_links/{subid} | Delete an experiment link. +*LinksToExperimentsApi* | [**post_entity_experiments_links**](docs/LinksToExperimentsApi.md#post_entity_experiments_links) | **POST** /{entity_type}/{id}/experiments_links/{subid} | Create or import a link. +*LinksToExperimentsApi* | [**read_entity_experiments_links**](docs/LinksToExperimentsApi.md#read_entity_experiments_links) | **GET** /{entity_type}/{id}/experiments_links | Read all experiments links of that entity. +*LinksToItemsApi* | [**delete_entitiy_items_link**](docs/LinksToItemsApi.md#delete_entitiy_items_link) | **DELETE** /{entity_type}/{id}/items_links/{subid} | Delete an item link. +*LinksToItemsApi* | [**post_entity_items_links**](docs/LinksToItemsApi.md#post_entity_items_links) | **POST** /{entity_type}/{id}/items_links/{subid} | Create or import a link. +*LinksToItemsApi* | [**read_entity_items_links**](docs/LinksToItemsApi.md#read_entity_items_links) | **GET** /{entity_type}/{id}/items_links | Read all items links of that entity. +*NotificationsApi* | [**delete_notifications**](docs/NotificationsApi.md#delete_notifications) | **DELETE** /users/{id}/notifications | Delete all notifications of the user. +*NotificationsApi* | [**patch_notification**](docs/NotificationsApi.md#patch_notification) | **PATCH** /users/{id}/notifications/{subid} | Update the acknowledgment status of a notification. +*NotificationsApi* | [**read_notification**](docs/NotificationsApi.md#read_notification) | **GET** /users/{id}/notifications/{subid} | Read a notification. +*NotificationsApi* | [**read_notifications**](docs/NotificationsApi.md#read_notifications) | **GET** /users/{id}/notifications | Read notifications of a user. +*ReportsApi* | [**get_reports**](docs/ReportsApi.md#get_reports) | **GET** /reports | Get usage reports +*ResourcesCategoriesApi* | [**delete_rescat**](docs/ResourcesCategoriesApi.md#delete_rescat) | **DELETE** /teams/{id}/resources_categories/{subid} | Delete a category. +*ResourcesCategoriesApi* | [**patch_rescat**](docs/ResourcesCategoriesApi.md#patch_rescat) | **PATCH** /teams/{id}/resources_categories/{subid} | Modify a category. +*ResourcesCategoriesApi* | [**post_team_one_rescat**](docs/ResourcesCategoriesApi.md#post_team_one_rescat) | **POST** /teams/{id}/resources_categories | Create a new category for resources. +*ResourcesCategoriesApi* | [**read_team_one_rescat**](docs/ResourcesCategoriesApi.md#read_team_one_rescat) | **GET** /teams/{id}/resources_categories/{subid} | Read a category. +*ResourcesCategoriesApi* | [**read_team_resources_categories**](docs/ResourcesCategoriesApi.md#read_team_resources_categories) | **GET** /teams/{id}/resources_categories | Read resources categories of a team. +*ResourcesStatusApi* | [**delete_resstatus**](docs/ResourcesStatusApi.md#delete_resstatus) | **DELETE** /teams/{id}/items_status/{subid} | Delete a status. +*ResourcesStatusApi* | [**patch_resstatus**](docs/ResourcesStatusApi.md#patch_resstatus) | **PATCH** /teams/{id}/items_status/{subid} | Modify a status. +*ResourcesStatusApi* | [**post_team_one_resstat**](docs/ResourcesStatusApi.md#post_team_one_resstat) | **POST** /teams/{id}/items_status | Create a new status for resources. +*ResourcesStatusApi* | [**read_team_items_status**](docs/ResourcesStatusApi.md#read_team_items_status) | **GET** /teams/{id}/items_status | Read resources status of a team. +*ResourcesStatusApi* | [**read_team_one_resstatus**](docs/ResourcesStatusApi.md#read_team_one_resstatus) | **GET** /teams/{id}/items_status/{subid} | Read a status. +*RevisionsApi* | [**patch_entity_revision**](docs/RevisionsApi.md#patch_entity_revision) | **PATCH** /{entity_type}/{id}/revisions/{subid} | Restore a revision. +*RevisionsApi* | [**read_entity_revision**](docs/RevisionsApi.md#read_entity_revision) | **GET** /{entity_type}/{id}/revisions/{subid} | Read a revision of that entity. +*RevisionsApi* | [**read_entity_revisions**](docs/RevisionsApi.md#read_entity_revisions) | **GET** /{entity_type}/{id}/revisions | Read all revisions of that entity. +*StepsApi* | [**delete_step**](docs/StepsApi.md#delete_step) | **DELETE** /{entity_type}/{id}/steps/{subid} | Delete a step. +*StepsApi* | [**patch_step**](docs/StepsApi.md#patch_step) | **PATCH** /{entity_type}/{id}/steps/{subid} | Actions on a step. +*StepsApi* | [**post_step**](docs/StepsApi.md#post_step) | **POST** /{entity_type}/{id}/steps | Create a step. +*StepsApi* | [**read_steps**](docs/StepsApi.md#read_steps) | **GET** /{entity_type}/{id}/steps | Read all steps of that entity. +*StorageUnitsApi* | [**delete_storage_unit**](docs/StorageUnitsApi.md#delete_storage_unit) | **DELETE** /storage_units/{id} | Delete a storage unit. +*StorageUnitsApi* | [**patch_storage_unit**](docs/StorageUnitsApi.md#patch_storage_unit) | **PATCH** /storage_units/{id} | Modify a storage unit. +*StorageUnitsApi* | [**post_storage_unit**](docs/StorageUnitsApi.md#post_storage_unit) | **POST** /storage_units | Create a new storage unit. +*StorageUnitsApi* | [**read_storage_unit**](docs/StorageUnitsApi.md#read_storage_unit) | **GET** /storage_units/{id} | Read a storage unit. +*StorageUnitsApi* | [**read_storage_units**](docs/StorageUnitsApi.md#read_storage_units) | **GET** /storage_units | Read all containers, or the storage unit hierarchy when `?hierarchy=true`. +*TagsApi* | [**delete_tag**](docs/TagsApi.md#delete_tag) | **DELETE** /{entity_type}/{id}/tags | Delete all tags. +*TagsApi* | [**patch_tag**](docs/TagsApi.md#patch_tag) | **PATCH** /{entity_type}/{id}/tags/{subid} | Actions on a tag (like removing it from the entity). +*TagsApi* | [**post_tag**](docs/TagsApi.md#post_tag) | **POST** /{entity_type}/{id}/tags | Create a tag. +*TagsApi* | [**read_tag**](docs/TagsApi.md#read_tag) | **GET** /{entity_type}/{id}/tags/{subid} | Read a tag. +*TagsApi* | [**read_tags**](docs/TagsApi.md#read_tags) | **GET** /{entity_type}/{id}/tags | Read all tags of that entity. +*TeamTagsApi* | [**delete_team_tag**](docs/TeamTagsApi.md#delete_team_tag) | **DELETE** /teams/{id}/tags/{subid} | Delete a tag. +*TeamTagsApi* | [**patch_team_tag**](docs/TeamTagsApi.md#patch_team_tag) | **PATCH** /teams/{id}/tags/{subid} | Actions on a tag. +*TeamTagsApi* | [**post_team_tag**](docs/TeamTagsApi.md#post_team_tag) | **POST** /teams/{id}/tags | Create a tag in the team. +*TeamTagsApi* | [**read_team_tag**](docs/TeamTagsApi.md#read_team_tag) | **GET** /teams/{id}/tags/{subid} | Read a tag. +*TeamTagsApi* | [**read_team_tags**](docs/TeamTagsApi.md#read_team_tags) | **GET** /teams/{id}/tags | Read all tags for the team. +*TeamgroupsApi* | [**delete_teamgroup**](docs/TeamgroupsApi.md#delete_teamgroup) | **DELETE** /teams/{id}/teamgroups/{subid} | Delete a teamgroup. +*TeamgroupsApi* | [**patch_teamgroup**](docs/TeamgroupsApi.md#patch_teamgroup) | **PATCH** /teams/{id}/teamgroups/{subid} | Modify a teamgroup. +*TeamgroupsApi* | [**post_teamgroups**](docs/TeamgroupsApi.md#post_teamgroups) | **POST** /teams/{id}/teamgroups | Create a new teamgroup. +*TeamgroupsApi* | [**read_team_teamgroups**](docs/TeamgroupsApi.md#read_team_teamgroups) | **GET** /teams/{id}/teamgroups | Read teamgroups of a team. +*TeamgroupsApi* | [**read_teamgroup**](docs/TeamgroupsApi.md#read_teamgroup) | **GET** /teams/{id}/teamgroups/{subid} | Read a teamgroup. +*TeamsApi* | [**patch_team**](docs/TeamsApi.md#patch_team) | **PATCH** /teams/{id} | Actions on a team. +*TeamsApi* | [**post_teams**](docs/TeamsApi.md#post_teams) | **POST** /teams | Create a new team. +*TeamsApi* | [**read_team**](docs/TeamsApi.md#read_team) | **GET** /teams/{id} | Read a team. Requires Admin permissions. +*TeamsApi* | [**read_teams**](docs/TeamsApi.md#read_teams) | **GET** /teams | Read all teams. Requires Sysadmin permissions. +*TodolistApi* | [**delete_todoitem**](docs/TodolistApi.md#delete_todoitem) | **DELETE** /todolist/{id} | Delete a todoitem. +*TodolistApi* | [**patch_todoitem**](docs/TodolistApi.md#patch_todoitem) | **PATCH** /todolist/{id} | Actions on a todoitem. +*TodolistApi* | [**post_todolist**](docs/TodolistApi.md#post_todolist) | **POST** /todolist | Create a todo item +*TodolistApi* | [**read_todoitem**](docs/TodolistApi.md#read_todoitem) | **GET** /todolist/{id} | Read a todo entry. +*TodolistApi* | [**read_todolist**](docs/TodolistApi.md#read_todolist) | **GET** /todolist | Read all todoitems. +*UnfinishedStepsApi* | [**read_unfinished_steps**](docs/UnfinishedStepsApi.md#read_unfinished_steps) | **GET** /unfinished_steps | Read all unfinished steps. +*UploadsApi* | [**delete_upload**](docs/UploadsApi.md#delete_upload) | **DELETE** /{entity_type}/{id}/uploads/{subid} | Delete an upload. +*UploadsApi* | [**patch_upload**](docs/UploadsApi.md#patch_upload) | **PATCH** /{entity_type}/{id}/uploads/{subid} | Modify attributes such as \"real_name\", \"comment\" or \"state\" of an upload. +*UploadsApi* | [**post_upload**](docs/UploadsApi.md#post_upload) | **POST** /{entity_type}/{id}/uploads | Create an upload. +*UploadsApi* | [**post_upload_replace**](docs/UploadsApi.md#post_upload_replace) | **POST** /{entity_type}/{id}/uploads/{subid} | Replace an existing uploaded file. The existing file will be archived and the new one will be added. +*UploadsApi* | [**read_upload**](docs/UploadsApi.md#read_upload) | **GET** /{entity_type}/{id}/uploads/{subid} | Read an upload. +*UploadsApi* | [**read_uploads**](docs/UploadsApi.md#read_uploads) | **GET** /{entity_type}/{id}/uploads | Read attached files of that entity. +*UserUploadsApi* | [**read_user_uploads**](docs/UserUploadsApi.md#read_user_uploads) | **GET** /users/{id}/uploads | Read attached files from a user +*UsersApi* | [**patch_user**](docs/UsersApi.md#patch_user) | **PATCH** /users/{id} | Modify a user. +*UsersApi* | [**post_user**](docs/UsersApi.md#post_user) | **POST** /users | Create a new user. +*UsersApi* | [**read_user**](docs/UsersApi.md#read_user) | **GET** /users/{id} | Read information of a user. +*UsersApi* | [**read_users**](docs/UsersApi.md#read_users) | **GET** /users | Read users from instance. + +## Documentation For Models + + - [AllOfentityEditableMetadatamerge](docs/AllOfentityEditableMetadatamerge.md) + - [AnyOfuploadsSubidBody1](docs/AnyOfuploadsSubidBody1.md) + - [Apikey](docs/Apikey.md) + - [ApikeysBody](docs/ApikeysBody.md) + - [BrandingIdBody](docs/BrandingIdBody.md) + - [Changelog](docs/Changelog.md) + - [Comment](docs/Comment.md) + - [Compound](docs/Compound.md) + - [CompoundCreateRequest](docs/CompoundCreateRequest.md) + - [CompoundDuplicateRequest](docs/CompoundDuplicateRequest.md) + - [CompoundsBody](docs/CompoundsBody.md) + - [CompoundsLinksSubidBody](docs/CompoundsLinksSubidBody.md) + - [Config](docs/Config.md) + - [Container](docs/Container.md) + - [ContainersSubidBody](docs/ContainersSubidBody.md) + - [ContainersSubidBody1](docs/ContainersSubidBody1.md) + - [DspaceBody](docs/DspaceBody.md) + - [DspaceBody1](docs/DspaceBody1.md) + - [DspaceEntity](docs/DspaceEntity.md) + - [DspaceMetadata](docs/DspaceMetadata.md) + - [DspaceMetadata1](docs/DspaceMetadata1.md) + - [Entity](docs/Entity.md) + - [EntityAndItemEditable](docs/EntityAndItemEditable.md) + - [EntityDuplicate](docs/EntityDuplicate.md) + - [EntityEditable](docs/EntityEditable.md) + - [EntityTemplate](docs/EntityTemplate.md) + - [EntityTemplateEditable](docs/EntityTemplateEditable.md) + - [Error](docs/Error.md) + - [Event](docs/Event.md) + - [EventIdBody](docs/EventIdBody.md) + - [EventidDelta](docs/EventidDelta.md) + - [EventsIdBody](docs/EventsIdBody.md) + - [ExclusiveEditMode](docs/ExclusiveEditMode.md) + - [Experiment](docs/Experiment.md) + - [ExperimentsLinksSubidBody](docs/ExperimentsLinksSubidBody.md) + - [ExperimentsTemplatesIdBody](docs/ExperimentsTemplatesIdBody.md) + - [Export](docs/Export.md) + - [ExportsBody](docs/ExportsBody.md) + - [ExtraFieldsKeys](docs/ExtraFieldsKeys.md) + - [FavtagsBody](docs/FavtagsBody.md) + - [Id](docs/Id.md) + - [Id1](docs/Id1.md) + - [Id2](docs/Id2.md) + - [Id3](docs/Id3.md) + - [Id4](docs/Id4.md) + - [IdCertsBody](docs/IdCertsBody.md) + - [IdCommentsBody](docs/IdCommentsBody.md) + - [IdEndpointsBody](docs/IdEndpointsBody.md) + - [IdExperimentsCategoriesBody](docs/IdExperimentsCategoriesBody.md) + - [IdExperimentsStatusBody](docs/IdExperimentsStatusBody.md) + - [IdItemsStatusBody](docs/IdItemsStatusBody.md) + - [IdResourcesCategoriesBody](docs/IdResourcesCategoriesBody.md) + - [IdStepsBody](docs/IdStepsBody.md) + - [IdTagsBody](docs/IdTagsBody.md) + - [IdTagsBody1](docs/IdTagsBody1.md) + - [IdTeamgroupsBody](docs/IdTeamgroupsBody.md) + - [IdUploadsBody](docs/IdUploadsBody.md) + - [Idp](docs/Idp.md) + - [IdpCert](docs/IdpCert.md) + - [IdpEndpoint](docs/IdpEndpoint.md) + - [IdpSource](docs/IdpSource.md) + - [IdpsBody](docs/IdpsBody.md) + - [IdpsIdBody](docs/IdpsIdBody.md) + - [IdpsSourcesBody](docs/IdpsSourcesBody.md) + - [IdpsSourcesIdBody](docs/IdpsSourcesIdBody.md) + - [ImportBody](docs/ImportBody.md) + - [InlineResponse200](docs/InlineResponse200.md) + - [InlineResponse2001](docs/InlineResponse2001.md) + - [InlineResponse20010](docs/InlineResponse20010.md) + - [InlineResponse2001Experiments](docs/InlineResponse2001Experiments.md) + - [InlineResponse2001Items](docs/InlineResponse2001Items.md) + - [InlineResponse2001Users](docs/InlineResponse2001Users.md) + - [InlineResponse2002](docs/InlineResponse2002.md) + - [InlineResponse2003](docs/InlineResponse2003.md) + - [InlineResponse2004](docs/InlineResponse2004.md) + - [InlineResponse2004QueryParameters](docs/InlineResponse2004QueryParameters.md) + - [InlineResponse2005](docs/InlineResponse2005.md) + - [InlineResponse2006](docs/InlineResponse2006.md) + - [InlineResponse2007](docs/InlineResponse2007.md) + - [InlineResponse2008](docs/InlineResponse2008.md) + - [InlineResponse2009](docs/InlineResponse2009.md) + - [InlineResponse2009Embedded](docs/InlineResponse2009Embedded.md) + - [InlineResponse2009EmbeddedEntries](docs/InlineResponse2009EmbeddedEntries.md) + - [InstanceBody](docs/InstanceBody.md) + - [Item](docs/Item.md) + - [ItemEditable](docs/ItemEditable.md) + - [ItemsLinksSubidBody](docs/ItemsLinksSubidBody.md) + - [ItemsTypesIdBody](docs/ItemsTypesIdBody.md) + - [Link](docs/Link.md) + - [Metadata](docs/Metadata.md) + - [MetadataElabftw](docs/MetadataElabftw.md) + - [MetadataElabftwExtraFieldsGroups](docs/MetadataElabftwExtraFieldsGroups.md) + - [MetadataExtraFields](docs/MetadataExtraFields.md) + - [Notification](docs/Notification.md) + - [NotificationsSubidBody](docs/NotificationsSubidBody.md) + - [PatchAction](docs/PatchAction.md) + - [Revision](docs/Revision.md) + - [RevisionsSubidBody](docs/RevisionsSubidBody.md) + - [Statuslike](docs/Statuslike.md) + - [Step](docs/Step.md) + - [StepsSubidBody](docs/StepsSubidBody.md) + - [StorageUnit](docs/StorageUnit.md) + - [StorageUnitsBody](docs/StorageUnitsBody.md) + - [StorageUnitsIdBody](docs/StorageUnitsIdBody.md) + - [Tag](docs/Tag.md) + - [TagsSubidBody](docs/TagsSubidBody.md) + - [TagsSubidBody1](docs/TagsSubidBody1.md) + - [Team](docs/Team.md) + - [Teamgroup](docs/Teamgroup.md) + - [TeamgroupUsers](docs/TeamgroupUsers.md) + - [TeamgroupsSubidBody](docs/TeamgroupsSubidBody.md) + - [TeamsBody](docs/TeamsBody.md) + - [TeamsIdBody](docs/TeamsIdBody.md) + - [Todoitem](docs/Todoitem.md) + - [TodolistBody](docs/TodolistBody.md) + - [TodolistIdBody](docs/TodolistIdBody.md) + - [UnfinishedStep](docs/UnfinishedStep.md) + - [UnfinishedSteps](docs/UnfinishedSteps.md) + - [Upload](docs/Upload.md) + - [UploadsSubidBody](docs/UploadsSubidBody.md) + - [UploadsSubidBody1](docs/UploadsSubidBody1.md) + - [Users](docs/Users.md) + - [UsersBody](docs/UsersBody.md) + - [UsersFull](docs/UsersFull.md) + - [UsersFullTeams](docs/UsersFullTeams.md) + - [UsersIdBody](docs/UsersIdBody.md) + +## Documentation For Authorization + + +## token + +- **Type**: API key +- **API key parameter name**: Authorization +- **Location**: HTTP header + + +## Author + + diff --git a/vendor/elabapi-python/elabapi_python.egg-info/PKG-INFO b/vendor/elabapi-python/elabapi_python.egg-info/PKG-INFO new file mode 100644 index 0000000..2d9de4d --- /dev/null +++ b/vendor/elabapi-python/elabapi_python.egg-info/PKG-INFO @@ -0,0 +1,19 @@ +Metadata-Version: 2.4 +Name: elabapi-python +Version: 5.6.1 +Summary: eLabFTW REST API v2 Documentation +Home-page: https://github.com/elabftw/elabapi-python +Author-email: +Keywords: Swagger,eLabFTW REST API v2 Documentation +Requires-Dist: urllib3>=1.15 +Requires-Dist: six>=1.10 +Requires-Dist: certifi +Requires-Dist: python-dateutil +Dynamic: description +Dynamic: home-page +Dynamic: keywords +Dynamic: requires-dist +Dynamic: summary + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + diff --git a/vendor/elabapi-python/elabapi_python.egg-info/SOURCES.txt b/vendor/elabapi-python/elabapi_python.egg-info/SOURCES.txt new file mode 100644 index 0000000..3e9f6c0 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python.egg-info/SOURCES.txt @@ -0,0 +1,348 @@ +README.md +setup.py +elabapi_python/__init__.py +elabapi_python/api_client.py +elabapi_python/configuration.py +elabapi_python/rest.py +elabapi_python.egg-info/PKG-INFO +elabapi_python.egg-info/SOURCES.txt +elabapi_python.egg-info/dependency_links.txt +elabapi_python.egg-info/requires.txt +elabapi_python.egg-info/top_level.txt +elabapi_python/api/__init__.py +elabapi_python/api/api_keys_api.py +elabapi_python/api/branding_api.py +elabapi_python/api/comments_api.py +elabapi_python/api/compounds_api.py +elabapi_python/api/config_api.py +elabapi_python/api/containers_api.py +elabapi_python/api/custom_fields_keys_api.py +elabapi_python/api/d_space_api.py +elabapi_python/api/events_api.py +elabapi_python/api/experiments_api.py +elabapi_python/api/experiments_categories_api.py +elabapi_python/api/experiments_status_api.py +elabapi_python/api/experiments_templates_api.py +elabapi_python/api/exports_api.py +elabapi_python/api/favorite_tags_api.py +elabapi_python/api/idps_api.py +elabapi_python/api/idps_sources_api.py +elabapi_python/api/import_api.py +elabapi_python/api/info_api.py +elabapi_python/api/instance_api.py +elabapi_python/api/items_api.py +elabapi_python/api/items_types__resources_templates_api.py +elabapi_python/api/links_to_compounds_api.py +elabapi_python/api/links_to_experiments_api.py +elabapi_python/api/links_to_items_api.py +elabapi_python/api/notifications_api.py +elabapi_python/api/reports_api.py +elabapi_python/api/resources_categories_api.py +elabapi_python/api/resources_status_api.py +elabapi_python/api/revisions_api.py +elabapi_python/api/steps_api.py +elabapi_python/api/storage_units_api.py +elabapi_python/api/tags_api.py +elabapi_python/api/team_tags_api.py +elabapi_python/api/teamgroups_api.py +elabapi_python/api/teams_api.py +elabapi_python/api/todolist_api.py +elabapi_python/api/unfinished_steps_api.py +elabapi_python/api/uploads_api.py +elabapi_python/api/user_uploads_api.py +elabapi_python/api/users_api.py +elabapi_python/models/__init__.py +elabapi_python/models/all_ofentity_editable_metadatamerge.py +elabapi_python/models/any_ofuploads_subid_body1.py +elabapi_python/models/apikey.py +elabapi_python/models/apikeys_body.py +elabapi_python/models/branding_id_body.py +elabapi_python/models/changelog.py +elabapi_python/models/comment.py +elabapi_python/models/compound.py +elabapi_python/models/compound_create_request.py +elabapi_python/models/compound_duplicate_request.py +elabapi_python/models/compounds_body.py +elabapi_python/models/compounds_links_subid_body.py +elabapi_python/models/config.py +elabapi_python/models/container.py +elabapi_python/models/containers_subid_body.py +elabapi_python/models/containers_subid_body1.py +elabapi_python/models/dspace_body.py +elabapi_python/models/dspace_body1.py +elabapi_python/models/dspace_entity.py +elabapi_python/models/dspace_metadata.py +elabapi_python/models/dspace_metadata1.py +elabapi_python/models/entity.py +elabapi_python/models/entity_and_item_editable.py +elabapi_python/models/entity_duplicate.py +elabapi_python/models/entity_editable.py +elabapi_python/models/entity_template.py +elabapi_python/models/entity_template_editable.py +elabapi_python/models/error.py +elabapi_python/models/event.py +elabapi_python/models/event_id_body.py +elabapi_python/models/eventid_delta.py +elabapi_python/models/events_id_body.py +elabapi_python/models/exclusive_edit_mode.py +elabapi_python/models/experiment.py +elabapi_python/models/experiments_links_subid_body.py +elabapi_python/models/experiments_templates_id_body.py +elabapi_python/models/export.py +elabapi_python/models/exports_body.py +elabapi_python/models/extra_fields_keys.py +elabapi_python/models/favtags_body.py +elabapi_python/models/id.py +elabapi_python/models/id1.py +elabapi_python/models/id2.py +elabapi_python/models/id3.py +elabapi_python/models/id4.py +elabapi_python/models/id_certs_body.py +elabapi_python/models/id_comments_body.py +elabapi_python/models/id_endpoints_body.py +elabapi_python/models/id_experiments_categories_body.py +elabapi_python/models/id_experiments_status_body.py +elabapi_python/models/id_items_status_body.py +elabapi_python/models/id_resources_categories_body.py +elabapi_python/models/id_steps_body.py +elabapi_python/models/id_tags_body.py +elabapi_python/models/id_tags_body1.py +elabapi_python/models/id_teamgroups_body.py +elabapi_python/models/id_uploads_body.py +elabapi_python/models/idp.py +elabapi_python/models/idp_cert.py +elabapi_python/models/idp_endpoint.py +elabapi_python/models/idp_source.py +elabapi_python/models/idps_body.py +elabapi_python/models/idps_id_body.py +elabapi_python/models/idps_sources_body.py +elabapi_python/models/idps_sources_id_body.py +elabapi_python/models/import_body.py +elabapi_python/models/inline_response200.py +elabapi_python/models/inline_response2001.py +elabapi_python/models/inline_response20010.py +elabapi_python/models/inline_response2001_experiments.py +elabapi_python/models/inline_response2001_items.py +elabapi_python/models/inline_response2001_users.py +elabapi_python/models/inline_response2002.py +elabapi_python/models/inline_response2003.py +elabapi_python/models/inline_response2004.py +elabapi_python/models/inline_response2004_query_parameters.py +elabapi_python/models/inline_response2005.py +elabapi_python/models/inline_response2006.py +elabapi_python/models/inline_response2007.py +elabapi_python/models/inline_response2008.py +elabapi_python/models/inline_response2009.py +elabapi_python/models/inline_response2009_embedded.py +elabapi_python/models/inline_response2009_embedded_entries.py +elabapi_python/models/instance_body.py +elabapi_python/models/item.py +elabapi_python/models/item_editable.py +elabapi_python/models/items_links_subid_body.py +elabapi_python/models/items_types_id_body.py +elabapi_python/models/link.py +elabapi_python/models/metadata.py +elabapi_python/models/metadata_elabftw.py +elabapi_python/models/metadata_elabftw_extra_fields_groups.py +elabapi_python/models/metadata_extra_fields.py +elabapi_python/models/notification.py +elabapi_python/models/notifications_subid_body.py +elabapi_python/models/patch_action.py +elabapi_python/models/revision.py +elabapi_python/models/revisions_subid_body.py +elabapi_python/models/statuslike.py +elabapi_python/models/step.py +elabapi_python/models/steps_subid_body.py +elabapi_python/models/storage_unit.py +elabapi_python/models/storage_units_body.py +elabapi_python/models/storage_units_id_body.py +elabapi_python/models/tag.py +elabapi_python/models/tags_subid_body.py +elabapi_python/models/tags_subid_body1.py +elabapi_python/models/team.py +elabapi_python/models/teamgroup.py +elabapi_python/models/teamgroup_users.py +elabapi_python/models/teamgroups_subid_body.py +elabapi_python/models/teams_body.py +elabapi_python/models/teams_id_body.py +elabapi_python/models/todoitem.py +elabapi_python/models/todolist_body.py +elabapi_python/models/todolist_id_body.py +elabapi_python/models/unfinished_step.py +elabapi_python/models/unfinished_steps.py +elabapi_python/models/upload.py +elabapi_python/models/uploads_subid_body.py +elabapi_python/models/uploads_subid_body1.py +elabapi_python/models/users.py +elabapi_python/models/users_body.py +elabapi_python/models/users_full.py +elabapi_python/models/users_full_teams.py +elabapi_python/models/users_id_body.py +test/__init__.py +test/test_all_ofentity_editable_metadatamerge.py +test/test_any_ofuploads_subid_body1.py +test/test_api_keys_api.py +test/test_apikey.py +test/test_apikeys_body.py +test/test_branding_api.py +test/test_branding_id_body.py +test/test_changelog.py +test/test_comment.py +test/test_comments_api.py +test/test_compound.py +test/test_compound_create_request.py +test/test_compound_duplicate_request.py +test/test_compounds_api.py +test/test_compounds_body.py +test/test_compounds_links_subid_body.py +test/test_config.py +test/test_config_api.py +test/test_container.py +test/test_containers_api.py +test/test_containers_subid_body.py +test/test_containers_subid_body1.py +test/test_custom_fields_keys_api.py +test/test_d_space_api.py +test/test_dspace_body.py +test/test_dspace_body1.py +test/test_dspace_entity.py +test/test_dspace_metadata.py +test/test_dspace_metadata1.py +test/test_entity.py +test/test_entity_and_item_editable.py +test/test_entity_duplicate.py +test/test_entity_editable.py +test/test_entity_template.py +test/test_entity_template_editable.py +test/test_error.py +test/test_event.py +test/test_event_id_body.py +test/test_eventid_delta.py +test/test_events_api.py +test/test_events_id_body.py +test/test_exclusive_edit_mode.py +test/test_experiment.py +test/test_experiments_api.py +test/test_experiments_categories_api.py +test/test_experiments_links_subid_body.py +test/test_experiments_status_api.py +test/test_experiments_templates_api.py +test/test_experiments_templates_id_body.py +test/test_export.py +test/test_exports_api.py +test/test_exports_body.py +test/test_extra_fields_keys.py +test/test_favorite_tags_api.py +test/test_favtags_body.py +test/test_id.py +test/test_id1.py +test/test_id2.py +test/test_id3.py +test/test_id4.py +test/test_id_certs_body.py +test/test_id_comments_body.py +test/test_id_endpoints_body.py +test/test_id_experiments_categories_body.py +test/test_id_experiments_status_body.py +test/test_id_items_status_body.py +test/test_id_resources_categories_body.py +test/test_id_steps_body.py +test/test_id_tags_body.py +test/test_id_tags_body1.py +test/test_id_teamgroups_body.py +test/test_id_uploads_body.py +test/test_idp.py +test/test_idp_cert.py +test/test_idp_endpoint.py +test/test_idp_source.py +test/test_idps_api.py +test/test_idps_body.py +test/test_idps_id_body.py +test/test_idps_sources_api.py +test/test_idps_sources_body.py +test/test_idps_sources_id_body.py +test/test_import_api.py +test/test_import_body.py +test/test_info_api.py +test/test_inline_response200.py +test/test_inline_response2001.py +test/test_inline_response20010.py +test/test_inline_response2001_experiments.py +test/test_inline_response2001_items.py +test/test_inline_response2001_users.py +test/test_inline_response2002.py +test/test_inline_response2003.py +test/test_inline_response2004.py +test/test_inline_response2004_query_parameters.py +test/test_inline_response2005.py +test/test_inline_response2006.py +test/test_inline_response2007.py +test/test_inline_response2008.py +test/test_inline_response2009.py +test/test_inline_response2009_embedded.py +test/test_inline_response2009_embedded_entries.py +test/test_instance_api.py +test/test_instance_body.py +test/test_item.py +test/test_item_editable.py +test/test_items_api.py +test/test_items_links_subid_body.py +test/test_items_types__resources_templates_api.py +test/test_items_types_id_body.py +test/test_link.py +test/test_links_to_compounds_api.py +test/test_links_to_experiments_api.py +test/test_links_to_items_api.py +test/test_metadata.py +test/test_metadata_elabftw.py +test/test_metadata_elabftw_extra_fields_groups.py +test/test_metadata_extra_fields.py +test/test_notification.py +test/test_notifications_api.py +test/test_notifications_subid_body.py +test/test_patch_action.py +test/test_reports_api.py +test/test_resources_categories_api.py +test/test_resources_status_api.py +test/test_revision.py +test/test_revisions_api.py +test/test_revisions_subid_body.py +test/test_statuslike.py +test/test_step.py +test/test_steps_api.py +test/test_steps_subid_body.py +test/test_storage_unit.py +test/test_storage_units_api.py +test/test_storage_units_body.py +test/test_storage_units_id_body.py +test/test_tag.py +test/test_tags_api.py +test/test_tags_subid_body.py +test/test_tags_subid_body1.py +test/test_team.py +test/test_team_tags_api.py +test/test_teamgroup.py +test/test_teamgroup_users.py +test/test_teamgroups_api.py +test/test_teamgroups_subid_body.py +test/test_teams_api.py +test/test_teams_body.py +test/test_teams_id_body.py +test/test_todoitem.py +test/test_todolist_api.py +test/test_todolist_body.py +test/test_todolist_id_body.py +test/test_unfinished_step.py +test/test_unfinished_steps.py +test/test_unfinished_steps_api.py +test/test_upload.py +test/test_uploads_api.py +test/test_uploads_subid_body.py +test/test_uploads_subid_body1.py +test/test_user_uploads_api.py +test/test_users.py +test/test_users_api.py +test/test_users_body.py +test/test_users_full.py +test/test_users_full_teams.py +test/test_users_id_body.py \ No newline at end of file diff --git a/vendor/elabapi-python/elabapi_python.egg-info/dependency_links.txt b/vendor/elabapi-python/elabapi_python.egg-info/dependency_links.txt new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/vendor/elabapi-python/elabapi_python.egg-info/requires.txt b/vendor/elabapi-python/elabapi_python.egg-info/requires.txt new file mode 100644 index 0000000..17318e9 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python.egg-info/requires.txt @@ -0,0 +1,4 @@ +urllib3>=1.15 +six>=1.10 +certifi +python-dateutil diff --git a/vendor/elabapi-python/elabapi_python.egg-info/top_level.txt b/vendor/elabapi-python/elabapi_python.egg-info/top_level.txt new file mode 100644 index 0000000..00f89ed --- /dev/null +++ b/vendor/elabapi-python/elabapi_python.egg-info/top_level.txt @@ -0,0 +1,2 @@ +elabapi_python +test diff --git a/vendor/elabapi-python/elabapi_python/__init__.py b/vendor/elabapi-python/elabapi_python/__init__.py new file mode 100644 index 0000000..4c63c0a --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/__init__.py @@ -0,0 +1,188 @@ +# coding: utf-8 + +# flake8: noqa + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +# import apis into sdk package +from elabapi_python.api.api_keys_api import ApiKeysApi +from elabapi_python.api.branding_api import BrandingApi +from elabapi_python.api.comments_api import CommentsApi +from elabapi_python.api.compounds_api import CompoundsApi +from elabapi_python.api.config_api import ConfigApi +from elabapi_python.api.containers_api import ContainersApi +from elabapi_python.api.custom_fields_keys_api import CustomFieldsKeysApi +from elabapi_python.api.d_space_api import DSpaceApi +from elabapi_python.api.events_api import EventsApi +from elabapi_python.api.experiments_api import ExperimentsApi +from elabapi_python.api.experiments_categories_api import ExperimentsCategoriesApi +from elabapi_python.api.experiments_status_api import ExperimentsStatusApi +from elabapi_python.api.experiments_templates_api import ExperimentsTemplatesApi +from elabapi_python.api.exports_api import ExportsApi +from elabapi_python.api.favorite_tags_api import FavoriteTagsApi +from elabapi_python.api.idps_api import IdpsApi +from elabapi_python.api.idps_sources_api import IdpsSourcesApi +from elabapi_python.api.import_api import ImportApi +from elabapi_python.api.info_api import InfoApi +from elabapi_python.api.instance_api import InstanceApi +from elabapi_python.api.items_api import ItemsApi +from elabapi_python.api.items_types__resources_templates_api import ItemsTypesResourcesTemplatesApi +from elabapi_python.api.links_to_compounds_api import LinksToCompoundsApi +from elabapi_python.api.links_to_experiments_api import LinksToExperimentsApi +from elabapi_python.api.links_to_items_api import LinksToItemsApi +from elabapi_python.api.notifications_api import NotificationsApi +from elabapi_python.api.reports_api import ReportsApi +from elabapi_python.api.resources_categories_api import ResourcesCategoriesApi +from elabapi_python.api.resources_status_api import ResourcesStatusApi +from elabapi_python.api.revisions_api import RevisionsApi +from elabapi_python.api.steps_api import StepsApi +from elabapi_python.api.storage_units_api import StorageUnitsApi +from elabapi_python.api.tags_api import TagsApi +from elabapi_python.api.team_tags_api import TeamTagsApi +from elabapi_python.api.teamgroups_api import TeamgroupsApi +from elabapi_python.api.teams_api import TeamsApi +from elabapi_python.api.todolist_api import TodolistApi +from elabapi_python.api.unfinished_steps_api import UnfinishedStepsApi +from elabapi_python.api.uploads_api import UploadsApi +from elabapi_python.api.user_uploads_api import UserUploadsApi +from elabapi_python.api.users_api import UsersApi +# import ApiClient +from elabapi_python.api_client import ApiClient +from elabapi_python.configuration import Configuration +# import models into sdk package +from elabapi_python.models.all_ofentity_editable_metadatamerge import AllOfentityEditableMetadatamerge +from elabapi_python.models.any_ofuploads_subid_body1 import AnyOfuploadsSubidBody1 +from elabapi_python.models.apikey import Apikey +from elabapi_python.models.apikeys_body import ApikeysBody +from elabapi_python.models.branding_id_body import BrandingIdBody +from elabapi_python.models.changelog import Changelog +from elabapi_python.models.comment import Comment +from elabapi_python.models.compound import Compound +from elabapi_python.models.compound_create_request import CompoundCreateRequest +from elabapi_python.models.compound_duplicate_request import CompoundDuplicateRequest +from elabapi_python.models.compounds_body import CompoundsBody +from elabapi_python.models.compounds_links_subid_body import CompoundsLinksSubidBody +from elabapi_python.models.config import Config +from elabapi_python.models.container import Container +from elabapi_python.models.containers_subid_body import ContainersSubidBody +from elabapi_python.models.containers_subid_body1 import ContainersSubidBody1 +from elabapi_python.models.dspace_body import DspaceBody +from elabapi_python.models.dspace_body1 import DspaceBody1 +from elabapi_python.models.dspace_entity import DspaceEntity +from elabapi_python.models.dspace_metadata import DspaceMetadata +from elabapi_python.models.dspace_metadata1 import DspaceMetadata1 +from elabapi_python.models.entity import Entity +from elabapi_python.models.entity_and_item_editable import EntityAndItemEditable +from elabapi_python.models.entity_duplicate import EntityDuplicate +from elabapi_python.models.entity_editable import EntityEditable +from elabapi_python.models.entity_template import EntityTemplate +from elabapi_python.models.entity_template_editable import EntityTemplateEditable +from elabapi_python.models.error import Error +from elabapi_python.models.event import Event +from elabapi_python.models.event_id_body import EventIdBody +from elabapi_python.models.eventid_delta import EventidDelta +from elabapi_python.models.events_id_body import EventsIdBody +from elabapi_python.models.exclusive_edit_mode import ExclusiveEditMode +from elabapi_python.models.experiment import Experiment +from elabapi_python.models.experiments_links_subid_body import ExperimentsLinksSubidBody +from elabapi_python.models.experiments_templates_id_body import ExperimentsTemplatesIdBody +from elabapi_python.models.export import Export +from elabapi_python.models.exports_body import ExportsBody +from elabapi_python.models.extra_fields_keys import ExtraFieldsKeys +from elabapi_python.models.favtags_body import FavtagsBody +from elabapi_python.models.id import Id +from elabapi_python.models.id1 import Id1 +from elabapi_python.models.id2 import Id2 +from elabapi_python.models.id3 import Id3 +from elabapi_python.models.id4 import Id4 +from elabapi_python.models.id_certs_body import IdCertsBody +from elabapi_python.models.id_comments_body import IdCommentsBody +from elabapi_python.models.id_endpoints_body import IdEndpointsBody +from elabapi_python.models.id_experiments_categories_body import IdExperimentsCategoriesBody +from elabapi_python.models.id_experiments_status_body import IdExperimentsStatusBody +from elabapi_python.models.id_items_status_body import IdItemsStatusBody +from elabapi_python.models.id_resources_categories_body import IdResourcesCategoriesBody +from elabapi_python.models.id_steps_body import IdStepsBody +from elabapi_python.models.id_tags_body import IdTagsBody +from elabapi_python.models.id_tags_body1 import IdTagsBody1 +from elabapi_python.models.id_teamgroups_body import IdTeamgroupsBody +from elabapi_python.models.id_uploads_body import IdUploadsBody +from elabapi_python.models.idp import Idp +from elabapi_python.models.idp_cert import IdpCert +from elabapi_python.models.idp_endpoint import IdpEndpoint +from elabapi_python.models.idp_source import IdpSource +from elabapi_python.models.idps_body import IdpsBody +from elabapi_python.models.idps_id_body import IdpsIdBody +from elabapi_python.models.idps_sources_body import IdpsSourcesBody +from elabapi_python.models.idps_sources_id_body import IdpsSourcesIdBody +from elabapi_python.models.import_body import ImportBody +from elabapi_python.models.inline_response200 import InlineResponse200 +from elabapi_python.models.inline_response2001 import InlineResponse2001 +from elabapi_python.models.inline_response20010 import InlineResponse20010 +from elabapi_python.models.inline_response2001_experiments import InlineResponse2001Experiments +from elabapi_python.models.inline_response2001_items import InlineResponse2001Items +from elabapi_python.models.inline_response2001_users import InlineResponse2001Users +from elabapi_python.models.inline_response2002 import InlineResponse2002 +from elabapi_python.models.inline_response2003 import InlineResponse2003 +from elabapi_python.models.inline_response2004 import InlineResponse2004 +from elabapi_python.models.inline_response2004_query_parameters import InlineResponse2004QueryParameters +from elabapi_python.models.inline_response2005 import InlineResponse2005 +from elabapi_python.models.inline_response2006 import InlineResponse2006 +from elabapi_python.models.inline_response2007 import InlineResponse2007 +from elabapi_python.models.inline_response2008 import InlineResponse2008 +from elabapi_python.models.inline_response2009 import InlineResponse2009 +from elabapi_python.models.inline_response2009_embedded import InlineResponse2009Embedded +from elabapi_python.models.inline_response2009_embedded_entries import InlineResponse2009EmbeddedEntries +from elabapi_python.models.instance_body import InstanceBody +from elabapi_python.models.item import Item +from elabapi_python.models.item_editable import ItemEditable +from elabapi_python.models.items_links_subid_body import ItemsLinksSubidBody +from elabapi_python.models.items_types_id_body import ItemsTypesIdBody +from elabapi_python.models.link import Link +from elabapi_python.models.metadata import Metadata +from elabapi_python.models.metadata_elabftw import MetadataElabftw +from elabapi_python.models.metadata_elabftw_extra_fields_groups import MetadataElabftwExtraFieldsGroups +from elabapi_python.models.metadata_extra_fields import MetadataExtraFields +from elabapi_python.models.notification import Notification +from elabapi_python.models.notifications_subid_body import NotificationsSubidBody +from elabapi_python.models.patch_action import PatchAction +from elabapi_python.models.revision import Revision +from elabapi_python.models.revisions_subid_body import RevisionsSubidBody +from elabapi_python.models.statuslike import Statuslike +from elabapi_python.models.step import Step +from elabapi_python.models.steps_subid_body import StepsSubidBody +from elabapi_python.models.storage_unit import StorageUnit +from elabapi_python.models.storage_units_body import StorageUnitsBody +from elabapi_python.models.storage_units_id_body import StorageUnitsIdBody +from elabapi_python.models.tag import Tag +from elabapi_python.models.tags_subid_body import TagsSubidBody +from elabapi_python.models.tags_subid_body1 import TagsSubidBody1 +from elabapi_python.models.team import Team +from elabapi_python.models.teamgroup import Teamgroup +from elabapi_python.models.teamgroup_users import TeamgroupUsers +from elabapi_python.models.teamgroups_subid_body import TeamgroupsSubidBody +from elabapi_python.models.teams_body import TeamsBody +from elabapi_python.models.teams_id_body import TeamsIdBody +from elabapi_python.models.todoitem import Todoitem +from elabapi_python.models.todolist_body import TodolistBody +from elabapi_python.models.todolist_id_body import TodolistIdBody +from elabapi_python.models.unfinished_step import UnfinishedStep +from elabapi_python.models.unfinished_steps import UnfinishedSteps +from elabapi_python.models.upload import Upload +from elabapi_python.models.uploads_subid_body import UploadsSubidBody +from elabapi_python.models.uploads_subid_body1 import UploadsSubidBody1 +from elabapi_python.models.users import Users +from elabapi_python.models.users_body import UsersBody +from elabapi_python.models.users_full import UsersFull +from elabapi_python.models.users_full_teams import UsersFullTeams +from elabapi_python.models.users_id_body import UsersIdBody diff --git a/vendor/elabapi-python/elabapi_python/__pycache__/__init__.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000..3989882 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/__pycache__/__init__.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/__pycache__/api_client.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/__pycache__/api_client.cpython-313.pyc new file mode 100644 index 0000000..aeb2948 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/__pycache__/api_client.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/__pycache__/configuration.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/__pycache__/configuration.cpython-313.pyc new file mode 100644 index 0000000..6c25696 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/__pycache__/configuration.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/__pycache__/rest.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/__pycache__/rest.cpython-313.pyc new file mode 100644 index 0000000..f9bc09f Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/__pycache__/rest.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__init__.py b/vendor/elabapi-python/elabapi_python/api/__init__.py new file mode 100644 index 0000000..8a3dcc7 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/__init__.py @@ -0,0 +1,46 @@ +from __future__ import absolute_import + +# flake8: noqa + +# import apis into api package +from elabapi_python.api.api_keys_api import ApiKeysApi +from elabapi_python.api.branding_api import BrandingApi +from elabapi_python.api.comments_api import CommentsApi +from elabapi_python.api.compounds_api import CompoundsApi +from elabapi_python.api.config_api import ConfigApi +from elabapi_python.api.containers_api import ContainersApi +from elabapi_python.api.custom_fields_keys_api import CustomFieldsKeysApi +from elabapi_python.api.d_space_api import DSpaceApi +from elabapi_python.api.events_api import EventsApi +from elabapi_python.api.experiments_api import ExperimentsApi +from elabapi_python.api.experiments_categories_api import ExperimentsCategoriesApi +from elabapi_python.api.experiments_status_api import ExperimentsStatusApi +from elabapi_python.api.experiments_templates_api import ExperimentsTemplatesApi +from elabapi_python.api.exports_api import ExportsApi +from elabapi_python.api.favorite_tags_api import FavoriteTagsApi +from elabapi_python.api.idps_api import IdpsApi +from elabapi_python.api.idps_sources_api import IdpsSourcesApi +from elabapi_python.api.import_api import ImportApi +from elabapi_python.api.info_api import InfoApi +from elabapi_python.api.instance_api import InstanceApi +from elabapi_python.api.items_api import ItemsApi +from elabapi_python.api.items_types__resources_templates_api import ItemsTypesResourcesTemplatesApi +from elabapi_python.api.links_to_compounds_api import LinksToCompoundsApi +from elabapi_python.api.links_to_experiments_api import LinksToExperimentsApi +from elabapi_python.api.links_to_items_api import LinksToItemsApi +from elabapi_python.api.notifications_api import NotificationsApi +from elabapi_python.api.reports_api import ReportsApi +from elabapi_python.api.resources_categories_api import ResourcesCategoriesApi +from elabapi_python.api.resources_status_api import ResourcesStatusApi +from elabapi_python.api.revisions_api import RevisionsApi +from elabapi_python.api.steps_api import StepsApi +from elabapi_python.api.storage_units_api import StorageUnitsApi +from elabapi_python.api.tags_api import TagsApi +from elabapi_python.api.team_tags_api import TeamTagsApi +from elabapi_python.api.teamgroups_api import TeamgroupsApi +from elabapi_python.api.teams_api import TeamsApi +from elabapi_python.api.todolist_api import TodolistApi +from elabapi_python.api.unfinished_steps_api import UnfinishedStepsApi +from elabapi_python.api.uploads_api import UploadsApi +from elabapi_python.api.user_uploads_api import UserUploadsApi +from elabapi_python.api.users_api import UsersApi diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/__init__.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000..d81e53c Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/__init__.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/api_keys_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/api_keys_api.cpython-313.pyc new file mode 100644 index 0000000..5247583 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/api_keys_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/branding_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/branding_api.cpython-313.pyc new file mode 100644 index 0000000..b4306d7 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/branding_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/comments_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/comments_api.cpython-313.pyc new file mode 100644 index 0000000..d8173ce Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/comments_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/compounds_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/compounds_api.cpython-313.pyc new file mode 100644 index 0000000..9f509f4 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/compounds_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/config_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/config_api.cpython-313.pyc new file mode 100644 index 0000000..ad518d3 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/config_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/containers_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/containers_api.cpython-313.pyc new file mode 100644 index 0000000..a651894 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/containers_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/custom_fields_keys_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/custom_fields_keys_api.cpython-313.pyc new file mode 100644 index 0000000..41ad4bd Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/custom_fields_keys_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/d_space_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/d_space_api.cpython-313.pyc new file mode 100644 index 0000000..fef5cf0 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/d_space_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/events_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/events_api.cpython-313.pyc new file mode 100644 index 0000000..602aa56 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/events_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/experiments_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/experiments_api.cpython-313.pyc new file mode 100644 index 0000000..9e0b008 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/experiments_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/experiments_categories_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/experiments_categories_api.cpython-313.pyc new file mode 100644 index 0000000..f09a8a1 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/experiments_categories_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/experiments_status_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/experiments_status_api.cpython-313.pyc new file mode 100644 index 0000000..7e0f99a Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/experiments_status_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/experiments_templates_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/experiments_templates_api.cpython-313.pyc new file mode 100644 index 0000000..2a7cdc0 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/experiments_templates_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/exports_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/exports_api.cpython-313.pyc new file mode 100644 index 0000000..4dd9cf8 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/exports_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/favorite_tags_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/favorite_tags_api.cpython-313.pyc new file mode 100644 index 0000000..b4725b7 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/favorite_tags_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/idps_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/idps_api.cpython-313.pyc new file mode 100644 index 0000000..f8cb317 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/idps_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/idps_sources_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/idps_sources_api.cpython-313.pyc new file mode 100644 index 0000000..5fea04a Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/idps_sources_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/import_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/import_api.cpython-313.pyc new file mode 100644 index 0000000..1092b7f Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/import_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/info_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/info_api.cpython-313.pyc new file mode 100644 index 0000000..a7197d5 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/info_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/instance_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/instance_api.cpython-313.pyc new file mode 100644 index 0000000..8eb1108 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/instance_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/items_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/items_api.cpython-313.pyc new file mode 100644 index 0000000..4535704 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/items_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/items_types__resources_templates_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/items_types__resources_templates_api.cpython-313.pyc new file mode 100644 index 0000000..5f0e5bb Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/items_types__resources_templates_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/links_to_compounds_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/links_to_compounds_api.cpython-313.pyc new file mode 100644 index 0000000..f9087ec Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/links_to_compounds_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/links_to_experiments_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/links_to_experiments_api.cpython-313.pyc new file mode 100644 index 0000000..54493d2 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/links_to_experiments_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/links_to_items_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/links_to_items_api.cpython-313.pyc new file mode 100644 index 0000000..1a4cdd8 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/links_to_items_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/notifications_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/notifications_api.cpython-313.pyc new file mode 100644 index 0000000..d7d17b3 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/notifications_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/reports_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/reports_api.cpython-313.pyc new file mode 100644 index 0000000..607b6b1 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/reports_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/resources_categories_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/resources_categories_api.cpython-313.pyc new file mode 100644 index 0000000..2223775 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/resources_categories_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/resources_status_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/resources_status_api.cpython-313.pyc new file mode 100644 index 0000000..2e1e563 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/resources_status_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/revisions_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/revisions_api.cpython-313.pyc new file mode 100644 index 0000000..1c4507f Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/revisions_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/steps_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/steps_api.cpython-313.pyc new file mode 100644 index 0000000..248aab2 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/steps_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/storage_units_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/storage_units_api.cpython-313.pyc new file mode 100644 index 0000000..c819583 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/storage_units_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/tags_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/tags_api.cpython-313.pyc new file mode 100644 index 0000000..ea953f4 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/tags_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/team_tags_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/team_tags_api.cpython-313.pyc new file mode 100644 index 0000000..01ae68e Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/team_tags_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/teamgroups_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/teamgroups_api.cpython-313.pyc new file mode 100644 index 0000000..9483868 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/teamgroups_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/teams_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/teams_api.cpython-313.pyc new file mode 100644 index 0000000..dedce58 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/teams_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/todolist_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/todolist_api.cpython-313.pyc new file mode 100644 index 0000000..543500f Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/todolist_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/unfinished_steps_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/unfinished_steps_api.cpython-313.pyc new file mode 100644 index 0000000..8c1355d Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/unfinished_steps_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/uploads_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/uploads_api.cpython-313.pyc new file mode 100644 index 0000000..be085a6 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/uploads_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/user_uploads_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/user_uploads_api.cpython-313.pyc new file mode 100644 index 0000000..617374d Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/user_uploads_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/__pycache__/users_api.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/api/__pycache__/users_api.cpython-313.pyc new file mode 100644 index 0000000..148fb02 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/api/__pycache__/users_api.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/api/api_keys_api.py b/vendor/elabapi-python/elabapi_python/api/api_keys_api.py new file mode 100644 index 0000000..66399ed --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/api_keys_api.py @@ -0,0 +1,310 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class ApiKeysApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_apikey(self, id, **kwargs): # noqa: E501 + """Delete an API key. # noqa: E501 + + Delete an API key # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_apikey(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the API key (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_apikey_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.delete_apikey_with_http_info(id, **kwargs) # noqa: E501 + return data + + def delete_apikey_with_http_info(self, id, **kwargs): # noqa: E501 + """Delete an API key. # noqa: E501 + + Delete an API key # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_apikey_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the API key (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_apikey" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_apikey`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/apikeys/{id}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def get_apikeys(self, **kwargs): # noqa: E501 + """Read API keys # noqa: E501 + + Get list of API keys for currently logged in user. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_apikeys(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[Apikey] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.get_apikeys_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.get_apikeys_with_http_info(**kwargs) # noqa: E501 + return data + + def get_apikeys_with_http_info(self, **kwargs): # noqa: E501 + """Read API keys # noqa: E501 + + Get list of API keys for currently logged in user. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_apikeys_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[Apikey] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method get_apikeys" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/apikeys', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Apikey]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_apikeys(self, **kwargs): # noqa: E501 + """Create an API key # noqa: E501 + + Create an API key. The cleartext key is sent back in the location header. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_apikeys(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param ApikeysBody body: + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_apikeys_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.post_apikeys_with_http_info(**kwargs) # noqa: E501 + return data + + def post_apikeys_with_http_info(self, **kwargs): # noqa: E501 + """Create an API key # noqa: E501 + + Create an API key. The cleartext key is sent back in the location header. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_apikeys_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param ApikeysBody body: + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_apikeys" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/apikeys', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/branding_api.py b/vendor/elabapi-python/elabapi_python/api/branding_api.py new file mode 100644 index 0000000..2de750e --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/branding_api.py @@ -0,0 +1,247 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class BrandingApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def get_instance_branding(self, id, format, **kwargs): # noqa: E501 + """Read a branding asset as a binary file. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_instance_branding(id, format, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: Branding id. (required) + :param str format: Use binary format to retrieve the branding asset. (required) + :return: str + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.get_instance_branding_with_http_info(id, format, **kwargs) # noqa: E501 + else: + (data) = self.get_instance_branding_with_http_info(id, format, **kwargs) # noqa: E501 + return data + + def get_instance_branding_with_http_info(self, id, format, **kwargs): # noqa: E501 + """Read a branding asset as a binary file. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_instance_branding_with_http_info(id, format, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: Branding id. (required) + :param str format: Use binary format to retrieve the branding asset. (required) + :return: str + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'format'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method get_instance_branding" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `get_instance_branding`") # noqa: E501 + # verify the required parameter 'format' is set + if ('format' not in params or + params['format'] is None): + raise ValueError("Missing the required parameter `format` when calling `get_instance_branding`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + if 'format' in params: + query_params.append(('format', params['format'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['image/svg+xml', 'image/png', 'image/jpeg', 'image/webp', 'image/x-icon', 'image/vnd.microsoft.icon', 'application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/instance/branding/{id}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='str', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_instance_branding(self, action, file, id, **kwargs): # noqa: E501 + """Update a branding asset. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_instance_branding(action, file, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str action: (required) + :param str file: (required) + :param int id: Branding id. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_instance_branding_with_http_info(action, file, id, **kwargs) # noqa: E501 + else: + (data) = self.post_instance_branding_with_http_info(action, file, id, **kwargs) # noqa: E501 + return data + + def post_instance_branding_with_http_info(self, action, file, id, **kwargs): # noqa: E501 + """Update a branding asset. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_instance_branding_with_http_info(action, file, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str action: (required) + :param str file: (required) + :param int id: Branding id. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['action', 'file', 'id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_instance_branding" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'action' is set + if ('action' not in params or + params['action'] is None): + raise ValueError("Missing the required parameter `action` when calling `post_instance_branding`") # noqa: E501 + # verify the required parameter 'file' is set + if ('file' not in params or + params['file'] is None): + raise ValueError("Missing the required parameter `file` when calling `post_instance_branding`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_instance_branding`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + if 'action' in params: + form_params.append(('action', params['action'])) # noqa: E501 + if 'file' in params: + local_var_files['file'] = params['file'] # noqa: E501 + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['multipart/form-data']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/instance/branding/{id}', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/comments_api.py b/vendor/elabapi-python/elabapi_python/api/comments_api.py new file mode 100644 index 0000000..ae9e8ba --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/comments_api.py @@ -0,0 +1,580 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class CommentsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_entity_comment(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Delete an entity comment. # noqa: E501 + + The comment gets deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_entity_comment(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the comment (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_entity_comment_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.delete_entity_comment_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def delete_entity_comment_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Delete an entity comment. # noqa: E501 + + The comment gets deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_entity_comment_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the comment (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_entity_comment" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `delete_entity_comment`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_entity_comment`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `delete_entity_comment`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/comments/{subid}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def patch_entity_comment(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Modify an entity comment. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_entity_comment(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the comment (required) + :param Comment body: Parameters for patching an entity comment. + :return: Comment + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_entity_comment_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.patch_entity_comment_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def patch_entity_comment_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Modify an entity comment. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_entity_comment_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the comment (required) + :param Comment body: Parameters for patching an entity comment. + :return: Comment + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_entity_comment" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `patch_entity_comment`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_entity_comment`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `patch_entity_comment`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/comments/{subid}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Comment', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_entity_comments(self, entity_type, id, **kwargs): # noqa: E501 + """Create a comment. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_entity_comments(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param IdCommentsBody body: Parameters for creating a comment + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_entity_comments_with_http_info(entity_type, id, **kwargs) # noqa: E501 + else: + (data) = self.post_entity_comments_with_http_info(entity_type, id, **kwargs) # noqa: E501 + return data + + def post_entity_comments_with_http_info(self, entity_type, id, **kwargs): # noqa: E501 + """Create a comment. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_entity_comments_with_http_info(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param IdCommentsBody body: Parameters for creating a comment + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_entity_comments" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `post_entity_comments`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_entity_comments`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/comments', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_entity_comment(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Read a comment of that entity. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_entity_comment(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the comment (required) + :return: Comment + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_entity_comment_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.read_entity_comment_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def read_entity_comment_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Read a comment of that entity. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_entity_comment_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the comment (required) + :return: Comment + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_entity_comment" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `read_entity_comment`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_entity_comment`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `read_entity_comment`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/comments/{subid}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Comment', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_entity_comments(self, entity_type, id, **kwargs): # noqa: E501 + """Read all comments of that entity. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_entity_comments(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :return: list[Comment] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_entity_comments_with_http_info(entity_type, id, **kwargs) # noqa: E501 + else: + (data) = self.read_entity_comments_with_http_info(entity_type, id, **kwargs) # noqa: E501 + return data + + def read_entity_comments_with_http_info(self, entity_type, id, **kwargs): # noqa: E501 + """Read all comments of that entity. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_entity_comments_with_http_info(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :return: list[Comment] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_entity_comments" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `read_entity_comments`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_entity_comments`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/comments', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Comment]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/compounds_api.py b/vendor/elabapi-python/elabapi_python/api/compounds_api.py new file mode 100644 index 0000000..025dbe7 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/compounds_api.py @@ -0,0 +1,409 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class CompoundsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_compound(self, id, **kwargs): # noqa: E501 + """Soft-delete a compound # noqa: E501 + + The compound gets marked as deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_compound(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the compound (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_compound_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.delete_compound_with_http_info(id, **kwargs) # noqa: E501 + return data + + def delete_compound_with_http_info(self, id, **kwargs): # noqa: E501 + """Soft-delete a compound # noqa: E501 + + The compound gets marked as deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_compound_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the compound (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_compound" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_compound`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/compounds/{id}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def get_compound(self, id, **kwargs): # noqa: E501 + """Get a single compound # noqa: E501 + + Retrieve one compound by its ID # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_compound(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the compound (required) + :return: Compound + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.get_compound_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.get_compound_with_http_info(id, **kwargs) # noqa: E501 + return data + + def get_compound_with_http_info(self, id, **kwargs): # noqa: E501 + """Get a single compound # noqa: E501 + + Retrieve one compound by its ID # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_compound_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the compound (required) + :return: Compound + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method get_compound" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `get_compound`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/compounds/{id}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Compound', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def get_compounds(self, **kwargs): # noqa: E501 + """Read compounds # noqa: E501 + + Get the list of all compounds # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_compounds(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[Compound] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.get_compounds_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.get_compounds_with_http_info(**kwargs) # noqa: E501 + return data + + def get_compounds_with_http_info(self, **kwargs): # noqa: E501 + """Read compounds # noqa: E501 + + Get the list of all compounds # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_compounds_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[Compound] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method get_compounds" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/compounds', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Compound]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_compounds(self, body, **kwargs): # noqa: E501 + """Create or import a compound # noqa: E501 + + - If `action=duplicate`, import (or match) a compound from PubChem using `cid` or `cas`. If both parameters are present, only the `cid` is used. - Otherwise, create a compound directly from the provided fields. - If a compound with the same unique identifier already exists (e.g `cas_number`, `pubchem_cid`), the API will return the existing compound instead of creating a new one. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_compounds(body, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param CompoundsBody body: (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_compounds_with_http_info(body, **kwargs) # noqa: E501 + else: + (data) = self.post_compounds_with_http_info(body, **kwargs) # noqa: E501 + return data + + def post_compounds_with_http_info(self, body, **kwargs): # noqa: E501 + """Create or import a compound # noqa: E501 + + - If `action=duplicate`, import (or match) a compound from PubChem using `cid` or `cas`. If both parameters are present, only the `cid` is used. - Otherwise, create a compound directly from the provided fields. - If a compound with the same unique identifier already exists (e.g `cas_number`, `pubchem_cid`), the API will return the existing compound instead of creating a new one. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_compounds_with_http_info(body, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param CompoundsBody body: (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_compounds" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'body' is set + if ('body' not in params or + params['body'] is None): + raise ValueError("Missing the required parameter `body` when calling `post_compounds`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/compounds', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/config_api.py b/vendor/elabapi-python/elabapi_python/api/config_api.py new file mode 100644 index 0000000..da81fee --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/config_api.py @@ -0,0 +1,296 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class ConfigApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_config(self, **kwargs): # noqa: E501 + """Reset the config to default values # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_config(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_config_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.delete_config_with_http_info(**kwargs) # noqa: E501 + return data + + def delete_config_with_http_info(self, **kwargs): # noqa: E501 + """Reset the config to default values # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_config_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_config" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/config', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def get_config(self, **kwargs): # noqa: E501 + """Read the config # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_config(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: Config + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.get_config_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.get_config_with_http_info(**kwargs) # noqa: E501 + return data + + def get_config_with_http_info(self, **kwargs): # noqa: E501 + """Read the config # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_config_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: Config + If the method is called asynchronously, + returns the request thread. + """ + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method get_config" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/config', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Config', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def patch_config(self, **kwargs): # noqa: E501 + """Modify the config # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_config(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param Config body: The config values to change. + :return: Config + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_config_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.patch_config_with_http_info(**kwargs) # noqa: E501 + return data + + def patch_config_with_http_info(self, **kwargs): # noqa: E501 + """Modify the config # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_config_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param Config body: The config values to change. + :return: Config + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_config" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/config', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Config', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/containers_api.py b/vendor/elabapi-python/elabapi_python/api/containers_api.py new file mode 100644 index 0000000..edf94aa --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/containers_api.py @@ -0,0 +1,596 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class ContainersApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_container(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Delete a container. # noqa: E501 + + Remove an entity from a storage unit. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_container(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the container (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_container_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.delete_container_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def delete_container_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Delete a container. # noqa: E501 + + Remove an entity from a storage unit. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_container_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the container (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_container" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `delete_container`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_container`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `delete_container`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/containers/{subid}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def patch_container(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Modify a container. # noqa: E501 + + Update the quantity stored, the unit, or the storage location of a container. Setting `storage_id` moves the container to a different storage unit while preserving its `id` and `created_at`. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_container(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the container (required) + :param ContainersSubidBody1 body: Parameters for modifying a container. + :return: Container + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_container_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.patch_container_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def patch_container_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Modify a container. # noqa: E501 + + Update the quantity stored, the unit, or the storage location of a container. Setting `storage_id` moves the container to a different storage unit while preserving its `id` and `created_at`. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_container_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the container (required) + :param ContainersSubidBody1 body: Parameters for modifying a container. + :return: Container + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_container" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `patch_container`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_container`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `patch_container`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/containers/{subid}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Container', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_container(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Create a container for this entity. # noqa: E501 + + Store this entity in a storage unit with a specified quantity. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_container(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the container (required) + :param ContainersSubidBody body: Parameters for creating a container. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_container_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.post_container_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def post_container_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Create a container for this entity. # noqa: E501 + + Store this entity in a storage unit with a specified quantity. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_container_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the container (required) + :param ContainersSubidBody body: Parameters for creating a container. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_container" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `post_container`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_container`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `post_container`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/containers/{subid}', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_container(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Read a container. # noqa: E501 + + Get details of a specific container entry. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_container(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the container (required) + :return: Container + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_container_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.read_container_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def read_container_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Read a container. # noqa: E501 + + Get details of a specific container entry. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_container_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the container (required) + :return: Container + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_container" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `read_container`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_container`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `read_container`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/containers/{subid}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Container', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_containers(self, entity_type, id, **kwargs): # noqa: E501 + """Read all containers for this entity. # noqa: E501 + + Get a list of all storage locations (containers) where this entity is stored. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_containers(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :return: list[Container] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_containers_with_http_info(entity_type, id, **kwargs) # noqa: E501 + else: + (data) = self.read_containers_with_http_info(entity_type, id, **kwargs) # noqa: E501 + return data + + def read_containers_with_http_info(self, entity_type, id, **kwargs): # noqa: E501 + """Read all containers for this entity. # noqa: E501 + + Get a list of all storage locations (containers) where this entity is stored. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_containers_with_http_info(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :return: list[Container] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_containers" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `read_containers`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_containers`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/containers', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Container]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/custom_fields_keys_api.py b/vendor/elabapi-python/elabapi_python/api/custom_fields_keys_api.py new file mode 100644 index 0000000..f91927a --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/custom_fields_keys_api.py @@ -0,0 +1,126 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class CustomFieldsKeysApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def custom_fields_keys(self, **kwargs): # noqa: E501 + """Read custom fields keys. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.custom_fields_keys(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str q: Search for a term in the custom fields keys. + :param int limit: Number of custom fields keys that will be returned. Value >= -1; -1: no limit, 0: users default setting from UCP. + :return: list[ExtraFieldsKeys] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.custom_fields_keys_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.custom_fields_keys_with_http_info(**kwargs) # noqa: E501 + return data + + def custom_fields_keys_with_http_info(self, **kwargs): # noqa: E501 + """Read custom fields keys. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.custom_fields_keys_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str q: Search for a term in the custom fields keys. + :param int limit: Number of custom fields keys that will be returned. Value >= -1; -1: no limit, 0: users default setting from UCP. + :return: list[ExtraFieldsKeys] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['q', 'limit'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method custom_fields_keys" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'q' in params: + query_params.append(('q', params['q'])) # noqa: E501 + if 'limit' in params: + query_params.append(('limit', params['limit'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/extra_fields_keys', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[ExtraFieldsKeys]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/d_space_api.py b/vendor/elabapi-python/elabapi_python/api/d_space_api.py new file mode 100644 index 0000000..d68584e --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/d_space_api.py @@ -0,0 +1,320 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class DSpaceApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def dspace_create(self, body, **kwargs): # noqa: E501 + """Create a new DSpace workspace item. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.dspace_create(body, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param DspaceBody body: (required) + :return: str + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.dspace_create_with_http_info(body, **kwargs) # noqa: E501 + else: + (data) = self.dspace_create_with_http_info(body, **kwargs) # noqa: E501 + return data + + def dspace_create_with_http_info(self, body, **kwargs): # noqa: E501 + """Create a new DSpace workspace item. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.dspace_create_with_http_info(body, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param DspaceBody body: (required) + :return: str + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method dspace_create" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'body' is set + if ('body' not in params or + params['body'] is None): + raise ValueError("Missing the required parameter `body` when calling `dspace_create`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['text/html', 'application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/dspace', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='str', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def dspace_read(self, action, **kwargs): # noqa: E501 + """Read DSpace information. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.dspace_read(action, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str action: Action to perform: - `getcollections`: list available DSpace collections. - `gettypes`: list DSpace item types (submission vocabularies). If omitted or invalid, the endpoint returns an error explaining valid usage. (required) + :return: InlineResponse2009 + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.dspace_read_with_http_info(action, **kwargs) # noqa: E501 + else: + (data) = self.dspace_read_with_http_info(action, **kwargs) # noqa: E501 + return data + + def dspace_read_with_http_info(self, action, **kwargs): # noqa: E501 + """Read DSpace information. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.dspace_read_with_http_info(action, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str action: Action to perform: - `getcollections`: list available DSpace collections. - `gettypes`: list DSpace item types (submission vocabularies). If omitted or invalid, the endpoint returns an error explaining valid usage. (required) + :return: InlineResponse2009 + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['action'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method dspace_read" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'action' is set + if ('action' not in params or + params['action'] is None): + raise ValueError("Missing the required parameter `action` when calling `dspace_read`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'action' in params: + query_params.append(('action', params['action'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/dspace', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='InlineResponse2009', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def dspace_submit(self, body, **kwargs): # noqa: E501 + """Submit an eLabFTW entry to DSpace. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.dspace_submit(body, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param DspaceBody1 body: (required) + :return: InlineResponse20010 + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.dspace_submit_with_http_info(body, **kwargs) # noqa: E501 + else: + (data) = self.dspace_submit_with_http_info(body, **kwargs) # noqa: E501 + return data + + def dspace_submit_with_http_info(self, body, **kwargs): # noqa: E501 + """Submit an eLabFTW entry to DSpace. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.dspace_submit_with_http_info(body, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param DspaceBody1 body: (required) + :return: InlineResponse20010 + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method dspace_submit" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'body' is set + if ('body' not in params or + params['body'] is None): + raise ValueError("Missing the required parameter `body` when calling `dspace_submit`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/dspace', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='InlineResponse20010', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/events_api.py b/vendor/elabapi-python/elabapi_python/api/events_api.py new file mode 100644 index 0000000..b0d2967 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/events_api.py @@ -0,0 +1,510 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class EventsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_event(self, id, **kwargs): # noqa: E501 + """Delete a booking slot. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_event(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the event to modify. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_event_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.delete_event_with_http_info(id, **kwargs) # noqa: E501 + return data + + def delete_event_with_http_info(self, id, **kwargs): # noqa: E501 + """Delete a booking slot. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_event_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the event to modify. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_event" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_event`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/event/{id}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def patch_event(self, body, id, **kwargs): # noqa: E501 + """Modify a booking slot. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_event(body, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param EventIdBody body: Parameters for modifying an event. (required) + :param int id: ID of the event to modify. (required) + :return: Event + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_event_with_http_info(body, id, **kwargs) # noqa: E501 + else: + (data) = self.patch_event_with_http_info(body, id, **kwargs) # noqa: E501 + return data + + def patch_event_with_http_info(self, body, id, **kwargs): # noqa: E501 + """Modify a booking slot. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_event_with_http_info(body, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param EventIdBody body: Parameters for modifying an event. (required) + :param int id: ID of the event to modify. (required) + :return: Event + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['body', 'id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_event" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'body' is set + if ('body' not in params or + params['body'] is None): + raise ValueError("Missing the required parameter `body` when calling `patch_event`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_event`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/event/{id}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Event', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_events(self, id, **kwargs): # noqa: E501 + """Create an event for the item specified as id. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_events(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the item to book. (required) + :param EventsIdBody body: Parameters for creating an event. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_events_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.post_events_with_http_info(id, **kwargs) # noqa: E501 + return data + + def post_events_with_http_info(self, id, **kwargs): # noqa: E501 + """Create an event for the item specified as id. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_events_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the item to book. (required) + :param EventsIdBody body: Parameters for creating an event. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_events" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_events`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/events/{id}', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_event(self, id, **kwargs): # noqa: E501 + """Read a booking slot. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_event(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the event to modify. (required) + :return: Event + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_event_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.read_event_with_http_info(id, **kwargs) # noqa: E501 + return data + + def read_event_with_http_info(self, id, **kwargs): # noqa: E501 + """Read a booking slot. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_event_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the event to modify. (required) + :return: Event + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_event" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_event`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/event/{id}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Event', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_events(self, **kwargs): # noqa: E501 + """Read all events in the team. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_events(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[Event] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_events_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.read_events_with_http_info(**kwargs) # noqa: E501 + return data + + def read_events_with_http_info(self, **kwargs): # noqa: E501 + """Read all events in the team. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_events_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[Event] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_events" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/events', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Event]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/experiments_api.py b/vendor/elabapi-python/elabapi_python/api/experiments_api.py new file mode 100644 index 0000000..7f5633a --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/experiments_api.py @@ -0,0 +1,686 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class ExperimentsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_experiment(self, id, **kwargs): # noqa: E501 + """Delete an experiment. # noqa: E501 + + The experiment gets soft-deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_experiment(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the experiment (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_experiment_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.delete_experiment_with_http_info(id, **kwargs) # noqa: E501 + return data + + def delete_experiment_with_http_info(self, id, **kwargs): # noqa: E501 + """Delete an experiment. # noqa: E501 + + The experiment gets soft-deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_experiment_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the experiment (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_experiment" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_experiment`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/experiments/{id}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def get_experiment(self, id, **kwargs): # noqa: E501 + """Read an experiment # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_experiment(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the experiment (required) + :param str format: Get the entity in a different format like csv, pdf, eln or zip. \"pdfa\" means archive pdf (PDF/A), same with \"zipa\". + :param bool json: Include a full JSON export in the ZIP archive. Only applicable if format is zip(a). + :param bool with_title: Include the title in the QR code. Only applicable if format is qrpng. + :param int size: Specify the size of the QR code in pixels. Only applicable if format is qrpng. + :param bool changelog: Toggles if the changelog should be included in PDF exports (pdf, pdfa, zip, zipa). Changelog is by default included if the export provides PDF/A, otherwise not. + :return: Entity + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.get_experiment_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.get_experiment_with_http_info(id, **kwargs) # noqa: E501 + return data + + def get_experiment_with_http_info(self, id, **kwargs): # noqa: E501 + """Read an experiment # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_experiment_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the experiment (required) + :param str format: Get the entity in a different format like csv, pdf, eln or zip. \"pdfa\" means archive pdf (PDF/A), same with \"zipa\". + :param bool json: Include a full JSON export in the ZIP archive. Only applicable if format is zip(a). + :param bool with_title: Include the title in the QR code. Only applicable if format is qrpng. + :param int size: Specify the size of the QR code in pixels. Only applicable if format is qrpng. + :param bool changelog: Toggles if the changelog should be included in PDF exports (pdf, pdfa, zip, zipa). Changelog is by default included if the export provides PDF/A, otherwise not. + :return: Entity + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'format', 'json', 'with_title', 'size', 'changelog'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method get_experiment" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `get_experiment`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + if 'format' in params: + query_params.append(('format', params['format'])) # noqa: E501 + if 'json' in params: + query_params.append(('json', params['json'])) # noqa: E501 + if 'with_title' in params: + query_params.append(('withTitle', params['with_title'])) # noqa: E501 + if 'size' in params: + query_params.append(('size', params['size'])) # noqa: E501 + if 'changelog' in params: + query_params.append(('changelog', params['changelog'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/experiments/{id}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Entity', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def patch_experiment(self, body, id, **kwargs): # noqa: E501 + """Modify an experiment # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_experiment(body, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param object body: Parameters for patching an entity (required) + :param int id: ID of the experiment (required) + :return: Experiment + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_experiment_with_http_info(body, id, **kwargs) # noqa: E501 + else: + (data) = self.patch_experiment_with_http_info(body, id, **kwargs) # noqa: E501 + return data + + def patch_experiment_with_http_info(self, body, id, **kwargs): # noqa: E501 + """Modify an experiment # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_experiment_with_http_info(body, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param object body: Parameters for patching an entity (required) + :param int id: ID of the experiment (required) + :return: Experiment + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['body', 'id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_experiment" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'body' is set + if ('body' not in params or + params['body'] is None): + raise ValueError("Missing the required parameter `body` when calling `patch_experiment`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_experiment`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/experiments/{id}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Experiment', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_experiment(self, **kwargs): # noqa: E501 + """Create an experiment # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_experiment(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param EntityEditable body: Parameters for creating an experiment + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_experiment_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.post_experiment_with_http_info(**kwargs) # noqa: E501 + return data + + def post_experiment_with_http_info(self, **kwargs): # noqa: E501 + """Create an experiment # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_experiment_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param EntityEditable body: Parameters for creating an experiment + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_experiment" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/experiments', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_experiment_by_id(self, id, **kwargs): # noqa: E501 + """Duplicate an experiment with its ID # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_experiment_by_id(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: The unique identifier of the experiment to duplicate. (required) + :param EntityDuplicate body: Parameters for duplicating an experiment + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_experiment_by_id_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.post_experiment_by_id_with_http_info(id, **kwargs) # noqa: E501 + return data + + def post_experiment_by_id_with_http_info(self, id, **kwargs): # noqa: E501 + """Duplicate an experiment with its ID # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_experiment_by_id_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: The unique identifier of the experiment to duplicate. (required) + :param EntityDuplicate body: Parameters for duplicating an experiment + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_experiment_by_id" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_experiment_by_id`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/experiments/{id}', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_experiments(self, **kwargs): # noqa: E501 + """Read all experiments that are accessible # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_experiments(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str q: Search for a term in title, body or elabid. + :param str extended: Extended search (advanced query). + :param int related: Look only for entries linked to this entry id. + :param str related_origin: When using the \"related\" query parameter, select the type of the related ID (experiments or items) + :param str category: Add a filter on the Category. Supports comma separated list of numbers, including \"null\". + :param str status: Add a filter on the Status. Supports comma separated list of numbers, including \"null\". + :param list[str] tags: An array of tags for filtering results containing all of these tags. + :param int limit: Limit the number of results. + :param int offset: Skip a number of results. Use with limit to work the pagination. + :param str owner: Filter results by author (user id) + :param int scope: Set the scope for the results. 1: self, 2: team, 3: everything. It defaults to the user value stored in preferences. + :param str order: Change the ordering of the results. + :param str sort: Change the sorting of results: ascending or descending. + :param str state: Filter results based on their state: 1 (Normal), 2 (Archived), 3 (Deleted). Supports comma separated values. + :param int full: Return all columns of each entry when set to 1. + :return: list[Experiment] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_experiments_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.read_experiments_with_http_info(**kwargs) # noqa: E501 + return data + + def read_experiments_with_http_info(self, **kwargs): # noqa: E501 + """Read all experiments that are accessible # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_experiments_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str q: Search for a term in title, body or elabid. + :param str extended: Extended search (advanced query). + :param int related: Look only for entries linked to this entry id. + :param str related_origin: When using the \"related\" query parameter, select the type of the related ID (experiments or items) + :param str category: Add a filter on the Category. Supports comma separated list of numbers, including \"null\". + :param str status: Add a filter on the Status. Supports comma separated list of numbers, including \"null\". + :param list[str] tags: An array of tags for filtering results containing all of these tags. + :param int limit: Limit the number of results. + :param int offset: Skip a number of results. Use with limit to work the pagination. + :param str owner: Filter results by author (user id) + :param int scope: Set the scope for the results. 1: self, 2: team, 3: everything. It defaults to the user value stored in preferences. + :param str order: Change the ordering of the results. + :param str sort: Change the sorting of results: ascending or descending. + :param str state: Filter results based on their state: 1 (Normal), 2 (Archived), 3 (Deleted). Supports comma separated values. + :param int full: Return all columns of each entry when set to 1. + :return: list[Experiment] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['q', 'extended', 'related', 'related_origin', 'category', 'status', 'tags', 'limit', 'offset', 'owner', 'scope', 'order', 'sort', 'state', 'full'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_experiments" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'q' in params: + query_params.append(('q', params['q'])) # noqa: E501 + if 'extended' in params: + query_params.append(('extended', params['extended'])) # noqa: E501 + if 'related' in params: + query_params.append(('related', params['related'])) # noqa: E501 + if 'related_origin' in params: + query_params.append(('related_origin', params['related_origin'])) # noqa: E501 + if 'category' in params: + query_params.append(('category', params['category'])) # noqa: E501 + if 'status' in params: + query_params.append(('status', params['status'])) # noqa: E501 + if 'tags' in params: + query_params.append(('tags[]', params['tags'])) # noqa: E501 + collection_formats['tags[]'] = 'multi' # noqa: E501 + if 'limit' in params: + query_params.append(('limit', params['limit'])) # noqa: E501 + if 'offset' in params: + query_params.append(('offset', params['offset'])) # noqa: E501 + if 'owner' in params: + query_params.append(('owner', params['owner'])) # noqa: E501 + if 'scope' in params: + query_params.append(('scope', params['scope'])) # noqa: E501 + if 'order' in params: + query_params.append(('order', params['order'])) # noqa: E501 + if 'sort' in params: + query_params.append(('sort', params['sort'])) # noqa: E501 + if 'state' in params: + query_params.append(('state', params['state'])) # noqa: E501 + if 'full' in params: + query_params.append(('full', params['full'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/experiments', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Experiment]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/experiments_categories_api.py b/vendor/elabapi-python/elabapi_python/api/experiments_categories_api.py new file mode 100644 index 0000000..0a65bed --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/experiments_categories_api.py @@ -0,0 +1,538 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class ExperimentsCategoriesApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_expcat(self, id, subid, **kwargs): # noqa: E501 + """Delete a category. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_expcat(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the category. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_expcat_with_http_info(id, subid, **kwargs) # noqa: E501 + else: + (data) = self.delete_expcat_with_http_info(id, subid, **kwargs) # noqa: E501 + return data + + def delete_expcat_with_http_info(self, id, subid, **kwargs): # noqa: E501 + """Delete a category. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_expcat_with_http_info(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the category. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_expcat" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_expcat`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `delete_expcat`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/experiments_categories/{subid}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def patch_expcat(self, id, subid, **kwargs): # noqa: E501 + """Modify a category. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_expcat(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the category. (required) + :param Statuslike body: Parameters for modifying a category. + :return: Statuslike + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_expcat_with_http_info(id, subid, **kwargs) # noqa: E501 + else: + (data) = self.patch_expcat_with_http_info(id, subid, **kwargs) # noqa: E501 + return data + + def patch_expcat_with_http_info(self, id, subid, **kwargs): # noqa: E501 + """Modify a category. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_expcat_with_http_info(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the category. (required) + :param Statuslike body: Parameters for modifying a category. + :return: Statuslike + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'subid', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_expcat" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_expcat`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `patch_expcat`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/experiments_categories/{subid}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Statuslike', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_team_one_expcat(self, id, **kwargs): # noqa: E501 + """Create a new category for experiments. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_team_one_expcat(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param IdExperimentsCategoriesBody body: Parameters for creating a category. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_team_one_expcat_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.post_team_one_expcat_with_http_info(id, **kwargs) # noqa: E501 + return data + + def post_team_one_expcat_with_http_info(self, id, **kwargs): # noqa: E501 + """Create a new category for experiments. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_team_one_expcat_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param IdExperimentsCategoriesBody body: Parameters for creating a category. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_team_one_expcat" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_team_one_expcat`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/experiments_categories', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_team_experiments_categories(self, id, **kwargs): # noqa: E501 + """Read experiments categories of a team. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_experiments_categories(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :return: list[Statuslike] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_team_experiments_categories_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.read_team_experiments_categories_with_http_info(id, **kwargs) # noqa: E501 + return data + + def read_team_experiments_categories_with_http_info(self, id, **kwargs): # noqa: E501 + """Read experiments categories of a team. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_experiments_categories_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :return: list[Statuslike] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_team_experiments_categories" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_team_experiments_categories`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/experiments_categories', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Statuslike]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_team_one_expcat(self, id, subid, **kwargs): # noqa: E501 + """Read a category. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_one_expcat(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the category. (required) + :return: Statuslike + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_team_one_expcat_with_http_info(id, subid, **kwargs) # noqa: E501 + else: + (data) = self.read_team_one_expcat_with_http_info(id, subid, **kwargs) # noqa: E501 + return data + + def read_team_one_expcat_with_http_info(self, id, subid, **kwargs): # noqa: E501 + """Read a category. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_one_expcat_with_http_info(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the category. (required) + :return: Statuslike + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_team_one_expcat" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_team_one_expcat`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `read_team_one_expcat`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/experiments_categories/{subid}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Statuslike', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/experiments_status_api.py b/vendor/elabapi-python/elabapi_python/api/experiments_status_api.py new file mode 100644 index 0000000..58d1137 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/experiments_status_api.py @@ -0,0 +1,538 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class ExperimentsStatusApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_expstatus(self, id, subid, **kwargs): # noqa: E501 + """Delete a status. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_expstatus(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the status (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_expstatus_with_http_info(id, subid, **kwargs) # noqa: E501 + else: + (data) = self.delete_expstatus_with_http_info(id, subid, **kwargs) # noqa: E501 + return data + + def delete_expstatus_with_http_info(self, id, subid, **kwargs): # noqa: E501 + """Delete a status. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_expstatus_with_http_info(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the status (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_expstatus" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_expstatus`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `delete_expstatus`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/experiments_status/{subid}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def patch_expstatus(self, id, subid, **kwargs): # noqa: E501 + """Modify a status. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_expstatus(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the status (required) + :param Statuslike body: Parameters for modifying a status. + :return: Statuslike + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_expstatus_with_http_info(id, subid, **kwargs) # noqa: E501 + else: + (data) = self.patch_expstatus_with_http_info(id, subid, **kwargs) # noqa: E501 + return data + + def patch_expstatus_with_http_info(self, id, subid, **kwargs): # noqa: E501 + """Modify a status. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_expstatus_with_http_info(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the status (required) + :param Statuslike body: Parameters for modifying a status. + :return: Statuslike + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'subid', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_expstatus" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_expstatus`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `patch_expstatus`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/experiments_status/{subid}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Statuslike', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_team_one_expstatus(self, id, **kwargs): # noqa: E501 + """Create a new experiments status. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_team_one_expstatus(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param IdExperimentsStatusBody body: Parameters for creating a status. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_team_one_expstatus_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.post_team_one_expstatus_with_http_info(id, **kwargs) # noqa: E501 + return data + + def post_team_one_expstatus_with_http_info(self, id, **kwargs): # noqa: E501 + """Create a new experiments status. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_team_one_expstatus_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param IdExperimentsStatusBody body: Parameters for creating a status. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_team_one_expstatus" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_team_one_expstatus`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/experiments_status', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_team_experiments_status(self, id, **kwargs): # noqa: E501 + """Read experiments status of a team. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_experiments_status(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :return: list[Statuslike] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_team_experiments_status_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.read_team_experiments_status_with_http_info(id, **kwargs) # noqa: E501 + return data + + def read_team_experiments_status_with_http_info(self, id, **kwargs): # noqa: E501 + """Read experiments status of a team. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_experiments_status_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :return: list[Statuslike] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_team_experiments_status" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_team_experiments_status`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/experiments_status', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Statuslike]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_team_one_expstatus(self, id, subid, **kwargs): # noqa: E501 + """Read a status. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_one_expstatus(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the status (required) + :return: Statuslike + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_team_one_expstatus_with_http_info(id, subid, **kwargs) # noqa: E501 + else: + (data) = self.read_team_one_expstatus_with_http_info(id, subid, **kwargs) # noqa: E501 + return data + + def read_team_one_expstatus_with_http_info(self, id, subid, **kwargs): # noqa: E501 + """Read a status. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_one_expstatus_with_http_info(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the status (required) + :return: Statuslike + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_team_one_expstatus" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_team_one_expstatus`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `read_team_one_expstatus`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/experiments_status/{subid}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Statuslike', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/experiments_templates_api.py b/vendor/elabapi-python/elabapi_python/api/experiments_templates_api.py new file mode 100644 index 0000000..ca34c87 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/experiments_templates_api.py @@ -0,0 +1,662 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class ExperimentsTemplatesApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_experiment_template(self, id, **kwargs): # noqa: E501 + """Delete an experiment template. # noqa: E501 + + The experiment template gets soft-deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_experiment_template(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the experiment template (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_experiment_template_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.delete_experiment_template_with_http_info(id, **kwargs) # noqa: E501 + return data + + def delete_experiment_template_with_http_info(self, id, **kwargs): # noqa: E501 + """Delete an experiment template. # noqa: E501 + + The experiment template gets soft-deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_experiment_template_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the experiment template (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_experiment_template" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_experiment_template`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/experiments_templates/{id}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def get_experiment_template(self, id, **kwargs): # noqa: E501 + """Read an experiment template # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_experiment_template(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the experiment template (required) + :return: EntityTemplate + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.get_experiment_template_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.get_experiment_template_with_http_info(id, **kwargs) # noqa: E501 + return data + + def get_experiment_template_with_http_info(self, id, **kwargs): # noqa: E501 + """Read an experiment template # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_experiment_template_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the experiment template (required) + :return: EntityTemplate + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method get_experiment_template" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `get_experiment_template`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/experiments_templates/{id}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='EntityTemplate', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def patch_experiment_template(self, id, **kwargs): # noqa: E501 + """Modify an experiment template # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_experiment_template(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the experiment template (required) + :param ExperimentsTemplatesIdBody body: Parameters for modifying an experiment template + :return: EntityTemplate + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_experiment_template_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.patch_experiment_template_with_http_info(id, **kwargs) # noqa: E501 + return data + + def patch_experiment_template_with_http_info(self, id, **kwargs): # noqa: E501 + """Modify an experiment template # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_experiment_template_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the experiment template (required) + :param ExperimentsTemplatesIdBody body: Parameters for modifying an experiment template + :return: EntityTemplate + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_experiment_template" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_experiment_template`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/experiments_templates/{id}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='EntityTemplate', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_experiment_template(self, **kwargs): # noqa: E501 + """Create an experiment template # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_experiment_template(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param EntityTemplateEditable body: Parameters for creating an experiment template + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_experiment_template_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.post_experiment_template_with_http_info(**kwargs) # noqa: E501 + return data + + def post_experiment_template_with_http_info(self, **kwargs): # noqa: E501 + """Create an experiment template # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_experiment_template_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param EntityTemplateEditable body: Parameters for creating an experiment template + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_experiment_template" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/experiments_templates', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_experiment_template_by_id(self, id, **kwargs): # noqa: E501 + """Duplicate an experiment template with its ID # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_experiment_template_by_id(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: The unique identifier of the experiment template to duplicate. (required) + :param EntityDuplicate body: Parameters for duplicating an experiment template + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_experiment_template_by_id_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.post_experiment_template_by_id_with_http_info(id, **kwargs) # noqa: E501 + return data + + def post_experiment_template_by_id_with_http_info(self, id, **kwargs): # noqa: E501 + """Duplicate an experiment template with its ID # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_experiment_template_by_id_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: The unique identifier of the experiment template to duplicate. (required) + :param EntityDuplicate body: Parameters for duplicating an experiment template + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_experiment_template_by_id" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_experiment_template_by_id`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/experiments_templates/{id}', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_experiments_templates(self, **kwargs): # noqa: E501 + """Read all experiments_templates that are accessible # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_experiments_templates(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str q: Search for a term in title, body or elabid. + :param str extended: Extended search (advanced query). + :param int related: Look only for entries linked to this entry id. + :param str related_origin: When using the \"related\" query parameter, select the type of the related ID (experiments or items) + :param str category: Add a filter on the Category. Supports comma separated list of numbers, including \"null\". + :param str status: Add a filter on the Status. Supports comma separated list of numbers, including \"null\". + :param list[str] tags: An array of tags for filtering results containing all of these tags. + :param int limit: Limit the number of results. + :param int offset: Skip a number of results. Use with limit to work the pagination. + :param str owner: Filter results by author (user id) + :param int scope: Set the scope for the results. 1: self, 2: team, 3: everything. It defaults to the user value stored in preferences. + :param str order: Change the ordering of the results. + :param str sort: Change the sorting of results: ascending or descending. + :param str state: Filter results based on their state: 1 (Normal), 2 (Archived), 3 (Deleted). Supports comma separated values. + :param int full: Return all columns of each entry when set to 1. + :return: list[EntityTemplate] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_experiments_templates_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.read_experiments_templates_with_http_info(**kwargs) # noqa: E501 + return data + + def read_experiments_templates_with_http_info(self, **kwargs): # noqa: E501 + """Read all experiments_templates that are accessible # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_experiments_templates_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str q: Search for a term in title, body or elabid. + :param str extended: Extended search (advanced query). + :param int related: Look only for entries linked to this entry id. + :param str related_origin: When using the \"related\" query parameter, select the type of the related ID (experiments or items) + :param str category: Add a filter on the Category. Supports comma separated list of numbers, including \"null\". + :param str status: Add a filter on the Status. Supports comma separated list of numbers, including \"null\". + :param list[str] tags: An array of tags for filtering results containing all of these tags. + :param int limit: Limit the number of results. + :param int offset: Skip a number of results. Use with limit to work the pagination. + :param str owner: Filter results by author (user id) + :param int scope: Set the scope for the results. 1: self, 2: team, 3: everything. It defaults to the user value stored in preferences. + :param str order: Change the ordering of the results. + :param str sort: Change the sorting of results: ascending or descending. + :param str state: Filter results based on their state: 1 (Normal), 2 (Archived), 3 (Deleted). Supports comma separated values. + :param int full: Return all columns of each entry when set to 1. + :return: list[EntityTemplate] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['q', 'extended', 'related', 'related_origin', 'category', 'status', 'tags', 'limit', 'offset', 'owner', 'scope', 'order', 'sort', 'state', 'full'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_experiments_templates" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'q' in params: + query_params.append(('q', params['q'])) # noqa: E501 + if 'extended' in params: + query_params.append(('extended', params['extended'])) # noqa: E501 + if 'related' in params: + query_params.append(('related', params['related'])) # noqa: E501 + if 'related_origin' in params: + query_params.append(('related_origin', params['related_origin'])) # noqa: E501 + if 'category' in params: + query_params.append(('category', params['category'])) # noqa: E501 + if 'status' in params: + query_params.append(('status', params['status'])) # noqa: E501 + if 'tags' in params: + query_params.append(('tags[]', params['tags'])) # noqa: E501 + collection_formats['tags[]'] = 'multi' # noqa: E501 + if 'limit' in params: + query_params.append(('limit', params['limit'])) # noqa: E501 + if 'offset' in params: + query_params.append(('offset', params['offset'])) # noqa: E501 + if 'owner' in params: + query_params.append(('owner', params['owner'])) # noqa: E501 + if 'scope' in params: + query_params.append(('scope', params['scope'])) # noqa: E501 + if 'order' in params: + query_params.append(('order', params['order'])) # noqa: E501 + if 'sort' in params: + query_params.append(('sort', params['sort'])) # noqa: E501 + if 'state' in params: + query_params.append(('state', params['state'])) # noqa: E501 + if 'full' in params: + query_params.append(('full', params['full'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/experiments_templates', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[EntityTemplate]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/exports_api.py b/vendor/elabapi-python/elabapi_python/api/exports_api.py new file mode 100644 index 0000000..8342d7d --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/exports_api.py @@ -0,0 +1,399 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class ExportsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_export(self, id, **kwargs): # noqa: E501 + """Remove an export request and its associated file # noqa: E501 + + This method will remove the file from the server temporary storage and clear the export request. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_export(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the export request (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_export_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.delete_export_with_http_info(id, **kwargs) # noqa: E501 + return data + + def delete_export_with_http_info(self, id, **kwargs): # noqa: E501 + """Remove an export request and its associated file # noqa: E501 + + This method will remove the file from the server temporary storage and clear the export request. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_export_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the export request (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_export" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_export`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/exports/{id}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_export(self, **kwargs): # noqa: E501 + """Register an export request # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_export(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param ExportsBody body: + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_export_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.post_export_with_http_info(**kwargs) # noqa: E501 + return data + + def post_export_with_http_info(self, **kwargs): # noqa: E501 + """Register an export request # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_export_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param ExportsBody body: + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_export" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/exports', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_export(self, id, **kwargs): # noqa: E501 + """Get export # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_export(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the export request (required) + :return: list[Export] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_export_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.read_export_with_http_info(id, **kwargs) # noqa: E501 + return data + + def read_export_with_http_info(self, id, **kwargs): # noqa: E501 + """Get export # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_export_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the export request (required) + :return: list[Export] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_export" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_export`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/exports/{id}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Export]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def readall_exports(self, **kwargs): # noqa: E501 + """List exports # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.readall_exports(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[Export] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.readall_exports_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.readall_exports_with_http_info(**kwargs) # noqa: E501 + return data + + def readall_exports_with_http_info(self, **kwargs): # noqa: E501 + """List exports # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.readall_exports_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[Export] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method readall_exports" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/exports', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Export]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/favorite_tags_api.py b/vendor/elabapi-python/elabapi_python/api/favorite_tags_api.py new file mode 100644 index 0000000..f4996c0 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/favorite_tags_api.py @@ -0,0 +1,304 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class FavoriteTagsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_favtag(self, id, **kwargs): # noqa: E501 + """Unfavorite a tag. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_favtag(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the tag. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_favtag_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.delete_favtag_with_http_info(id, **kwargs) # noqa: E501 + return data + + def delete_favtag_with_http_info(self, id, **kwargs): # noqa: E501 + """Unfavorite a tag. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_favtag_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the tag. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_favtag" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_favtag`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/favtags/{id}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_favtags(self, **kwargs): # noqa: E501 + """Add a tag as favorite. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_favtags(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param FavtagsBody body: Parameters for adding a favorite tag. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_favtags_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.post_favtags_with_http_info(**kwargs) # noqa: E501 + return data + + def post_favtags_with_http_info(self, **kwargs): # noqa: E501 + """Add a tag as favorite. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_favtags_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param FavtagsBody body: Parameters for adding a favorite tag. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_favtags" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/favtags', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_favtags(self, **kwargs): # noqa: E501 + """Read all favorite tags for the user. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_favtags(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: InlineResponse2003 + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_favtags_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.read_favtags_with_http_info(**kwargs) # noqa: E501 + return data + + def read_favtags_with_http_info(self, **kwargs): # noqa: E501 + """Read all favorite tags for the user. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_favtags_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: InlineResponse2003 + If the method is called asynchronously, + returns the request thread. + """ + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_favtags" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/favtags', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='InlineResponse2003', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/idps_api.py b/vendor/elabapi-python/elabapi_python/api/idps_api.py new file mode 100644 index 0000000..135a38f --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/idps_api.py @@ -0,0 +1,1296 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class IdpsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_idp(self, id, **kwargs): # noqa: E501 + """Delete an idp. # noqa: E501 + + The idp gets deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_idp(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idp (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_idp_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.delete_idp_with_http_info(id, **kwargs) # noqa: E501 + return data + + def delete_idp_with_http_info(self, id, **kwargs): # noqa: E501 + """Delete an idp. # noqa: E501 + + The idp gets deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_idp_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idp (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_idp" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_idp`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/idps/{id}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def delete_idp_cert(self, id, cert_id, **kwargs): # noqa: E501 + """Delete an idp cert. # noqa: E501 + + The idp cert gets deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_idp_cert(id, cert_id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idp (required) + :param int cert_id: ID of the idp cert (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_idp_cert_with_http_info(id, cert_id, **kwargs) # noqa: E501 + else: + (data) = self.delete_idp_cert_with_http_info(id, cert_id, **kwargs) # noqa: E501 + return data + + def delete_idp_cert_with_http_info(self, id, cert_id, **kwargs): # noqa: E501 + """Delete an idp cert. # noqa: E501 + + The idp cert gets deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_idp_cert_with_http_info(id, cert_id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idp (required) + :param int cert_id: ID of the idp cert (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'cert_id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_idp_cert" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_idp_cert`") # noqa: E501 + # verify the required parameter 'cert_id' is set + if ('cert_id' not in params or + params['cert_id'] is None): + raise ValueError("Missing the required parameter `cert_id` when calling `delete_idp_cert`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'cert_id' in params: + path_params['cert_id'] = params['cert_id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/idps/{id}/certs/{cert_id}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def delete_idp_endpoint(self, id, endpoint_id, **kwargs): # noqa: E501 + """Delete an idp endpoint. # noqa: E501 + + The idp endpoint gets deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_idp_endpoint(id, endpoint_id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idp (required) + :param int endpoint_id: ID of the idp endpoint (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_idp_endpoint_with_http_info(id, endpoint_id, **kwargs) # noqa: E501 + else: + (data) = self.delete_idp_endpoint_with_http_info(id, endpoint_id, **kwargs) # noqa: E501 + return data + + def delete_idp_endpoint_with_http_info(self, id, endpoint_id, **kwargs): # noqa: E501 + """Delete an idp endpoint. # noqa: E501 + + The idp endpoint gets deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_idp_endpoint_with_http_info(id, endpoint_id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idp (required) + :param int endpoint_id: ID of the idp endpoint (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'endpoint_id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_idp_endpoint" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_idp_endpoint`") # noqa: E501 + # verify the required parameter 'endpoint_id' is set + if ('endpoint_id' not in params or + params['endpoint_id'] is None): + raise ValueError("Missing the required parameter `endpoint_id` when calling `delete_idp_endpoint`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'endpoint_id' in params: + path_params['endpoint_id'] = params['endpoint_id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/idps/{id}/endpoints/{endpoint_id}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def patch_idp(self, id, **kwargs): # noqa: E501 + """Actions on an idp. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_idp(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idp (required) + :param IdpsIdBody body: Parameters for modifying an idp. + :return: Idp + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_idp_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.patch_idp_with_http_info(id, **kwargs) # noqa: E501 + return data + + def patch_idp_with_http_info(self, id, **kwargs): # noqa: E501 + """Actions on an idp. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_idp_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idp (required) + :param IdpsIdBody body: Parameters for modifying an idp. + :return: Idp + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_idp" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_idp`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/idps/{id}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Idp', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_idp(self, **kwargs): # noqa: E501 + """Create an idp. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_idp(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param IdpsBody body: Parameters for creating an idp. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_idp_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.post_idp_with_http_info(**kwargs) # noqa: E501 + return data + + def post_idp_with_http_info(self, **kwargs): # noqa: E501 + """Create an idp. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_idp_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param IdpsBody body: Parameters for creating an idp. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_idp" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/idps', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_idp_cert(self, id, **kwargs): # noqa: E501 + """Add a cert to this IdP. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_idp_cert(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idp (required) + :param IdCertsBody body: Parameters for adding a cert to an IdP. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_idp_cert_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.post_idp_cert_with_http_info(id, **kwargs) # noqa: E501 + return data + + def post_idp_cert_with_http_info(self, id, **kwargs): # noqa: E501 + """Add a cert to this IdP. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_idp_cert_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idp (required) + :param IdCertsBody body: Parameters for adding a cert to an IdP. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_idp_cert" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_idp_cert`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/idps/{id}/certs', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_idp_endpoint(self, id, **kwargs): # noqa: E501 + """Add an endpoint to this IdP. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_idp_endpoint(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idp (required) + :param IdEndpointsBody body: Parameters for adding an endpoint to an IdP. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_idp_endpoint_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.post_idp_endpoint_with_http_info(id, **kwargs) # noqa: E501 + return data + + def post_idp_endpoint_with_http_info(self, id, **kwargs): # noqa: E501 + """Add an endpoint to this IdP. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_idp_endpoint_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idp (required) + :param IdEndpointsBody body: Parameters for adding an endpoint to an IdP. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_idp_endpoint" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_idp_endpoint`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/idps/{id}/endpoints', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_idp(self, id, **kwargs): # noqa: E501 + """Read an idp. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_idp(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idp (required) + :return: Idp + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_idp_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.read_idp_with_http_info(id, **kwargs) # noqa: E501 + return data + + def read_idp_with_http_info(self, id, **kwargs): # noqa: E501 + """Read an idp. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_idp_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idp (required) + :return: Idp + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_idp" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_idp`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/idps/{id}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Idp', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_idp_cert(self, id, cert_id, **kwargs): # noqa: E501 + """Read a cert for an IdP. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_idp_cert(id, cert_id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idp (required) + :param int cert_id: ID of the idp cert (required) + :return: IdpCert + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_idp_cert_with_http_info(id, cert_id, **kwargs) # noqa: E501 + else: + (data) = self.read_idp_cert_with_http_info(id, cert_id, **kwargs) # noqa: E501 + return data + + def read_idp_cert_with_http_info(self, id, cert_id, **kwargs): # noqa: E501 + """Read a cert for an IdP. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_idp_cert_with_http_info(id, cert_id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idp (required) + :param int cert_id: ID of the idp cert (required) + :return: IdpCert + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'cert_id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_idp_cert" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_idp_cert`") # noqa: E501 + # verify the required parameter 'cert_id' is set + if ('cert_id' not in params or + params['cert_id'] is None): + raise ValueError("Missing the required parameter `cert_id` when calling `read_idp_cert`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'cert_id' in params: + path_params['cert_id'] = params['cert_id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/idps/{id}/certs/{cert_id}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='IdpCert', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_idp_certs(self, id, **kwargs): # noqa: E501 + """Read all certs for an IdP. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_idp_certs(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idp (required) + :return: list[IdpCert] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_idp_certs_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.read_idp_certs_with_http_info(id, **kwargs) # noqa: E501 + return data + + def read_idp_certs_with_http_info(self, id, **kwargs): # noqa: E501 + """Read all certs for an IdP. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_idp_certs_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idp (required) + :return: list[IdpCert] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_idp_certs" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_idp_certs`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/idps/{id}/certs', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[IdpCert]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_idp_endpoint(self, id, endpoint_id, **kwargs): # noqa: E501 + """Read an endpoint for an IdP. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_idp_endpoint(id, endpoint_id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idp (required) + :param int endpoint_id: ID of the idp endpoint (required) + :return: IdpEndpoint + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_idp_endpoint_with_http_info(id, endpoint_id, **kwargs) # noqa: E501 + else: + (data) = self.read_idp_endpoint_with_http_info(id, endpoint_id, **kwargs) # noqa: E501 + return data + + def read_idp_endpoint_with_http_info(self, id, endpoint_id, **kwargs): # noqa: E501 + """Read an endpoint for an IdP. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_idp_endpoint_with_http_info(id, endpoint_id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idp (required) + :param int endpoint_id: ID of the idp endpoint (required) + :return: IdpEndpoint + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'endpoint_id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_idp_endpoint" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_idp_endpoint`") # noqa: E501 + # verify the required parameter 'endpoint_id' is set + if ('endpoint_id' not in params or + params['endpoint_id'] is None): + raise ValueError("Missing the required parameter `endpoint_id` when calling `read_idp_endpoint`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'endpoint_id' in params: + path_params['endpoint_id'] = params['endpoint_id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/idps/{id}/endpoints/{endpoint_id}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='IdpEndpoint', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_idp_endpoints(self, id, **kwargs): # noqa: E501 + """Read all endpoints for an IdP. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_idp_endpoints(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idp (required) + :return: list[IdpEndpoint] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_idp_endpoints_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.read_idp_endpoints_with_http_info(id, **kwargs) # noqa: E501 + return data + + def read_idp_endpoints_with_http_info(self, id, **kwargs): # noqa: E501 + """Read all endpoints for an IdP. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_idp_endpoints_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idp (required) + :return: list[IdpEndpoint] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_idp_endpoints" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_idp_endpoints`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/idps/{id}/endpoints', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[IdpEndpoint]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_idps(self, **kwargs): # noqa: E501 + """Read all IDPs. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_idps(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[Idp] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_idps_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.read_idps_with_http_info(**kwargs) # noqa: E501 + return data + + def read_idps_with_http_info(self, **kwargs): # noqa: E501 + """Read all IDPs. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_idps_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[Idp] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_idps" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/idps', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Idp]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/idps_sources_api.py b/vendor/elabapi-python/elabapi_python/api/idps_sources_api.py new file mode 100644 index 0000000..113d5a0 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/idps_sources_api.py @@ -0,0 +1,500 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class IdpsSourcesApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_idps_source(self, id, **kwargs): # noqa: E501 + """Delete an idp source. # noqa: E501 + + The idp source gets deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_idps_source(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idps source (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_idps_source_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.delete_idps_source_with_http_info(id, **kwargs) # noqa: E501 + return data + + def delete_idps_source_with_http_info(self, id, **kwargs): # noqa: E501 + """Delete an idp source. # noqa: E501 + + The idp source gets deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_idps_source_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idps source (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_idps_source" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_idps_source`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/idps_sources/{id}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def patch_idps_source(self, id, **kwargs): # noqa: E501 + """Patch an idp source. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_idps_source(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idps source (required) + :param IdpsSourcesIdBody body: Parameters for patching an idp source. + :return: IdpSource + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_idps_source_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.patch_idps_source_with_http_info(id, **kwargs) # noqa: E501 + return data + + def patch_idps_source_with_http_info(self, id, **kwargs): # noqa: E501 + """Patch an idp source. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_idps_source_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idps source (required) + :param IdpsSourcesIdBody body: Parameters for patching an idp source. + :return: IdpSource + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_idps_source" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_idps_source`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/idps_sources/{id}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='IdpSource', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_idp_source(self, **kwargs): # noqa: E501 + """Create an idp source. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_idp_source(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param IdpsSourcesBody body: Parameters for creating an idp source. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_idp_source_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.post_idp_source_with_http_info(**kwargs) # noqa: E501 + return data + + def post_idp_source_with_http_info(self, **kwargs): # noqa: E501 + """Create an idp source. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_idp_source_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param IdpsSourcesBody body: Parameters for creating an idp source. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_idp_source" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/idps_sources', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_idps_source(self, id, **kwargs): # noqa: E501 + """Read an IdPs source # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_idps_source(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idps source (required) + :return: IdpSource + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_idps_source_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.read_idps_source_with_http_info(id, **kwargs) # noqa: E501 + return data + + def read_idps_source_with_http_info(self, id, **kwargs): # noqa: E501 + """Read an IdPs source # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_idps_source_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the idps source (required) + :return: IdpSource + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_idps_source" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_idps_source`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/idps_sources/{id}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='IdpSource', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_idps_sources(self, **kwargs): # noqa: E501 + """Read all IDPs sources # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_idps_sources(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[IdpSource] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_idps_sources_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.read_idps_sources_with_http_info(**kwargs) # noqa: E501 + return data + + def read_idps_sources_with_http_info(self, **kwargs): # noqa: E501 + """Read all IDPs sources # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_idps_sources_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[IdpSource] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_idps_sources" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/idps_sources', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[IdpSource]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/import_api.py b/vendor/elabapi-python/elabapi_python/api/import_api.py new file mode 100644 index 0000000..72a8e8b --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/import_api.py @@ -0,0 +1,231 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class ImportApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def post_import(self, **kwargs): # noqa: E501 + """Send a file to import # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_import(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str file: + :param str entity_type: + :param int category: + :param float canread_base: + :param float canwrite_base: + :param int owner: + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_import_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.post_import_with_http_info(**kwargs) # noqa: E501 + return data + + def post_import_with_http_info(self, **kwargs): # noqa: E501 + """Send a file to import # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_import_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str file: + :param str entity_type: + :param int category: + :param float canread_base: + :param float canwrite_base: + :param int owner: + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['file', 'entity_type', 'category', 'canread_base', 'canwrite_base', 'owner'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_import" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + if 'file' in params: + local_var_files['file'] = params['file'] # noqa: E501 + if 'entity_type' in params: + form_params.append(('entity_type', params['entity_type'])) # noqa: E501 + if 'category' in params: + form_params.append(('category', params['category'])) # noqa: E501 + if 'canread_base' in params: + form_params.append(('canread_base', params['canread_base'])) # noqa: E501 + if 'canwrite_base' in params: + form_params.append(('canwrite_base', params['canwrite_base'])) # noqa: E501 + if 'owner' in params: + form_params.append(('owner', params['owner'])) # noqa: E501 + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['multipart/form-data']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/import', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_import(self, **kwargs): # noqa: E501 + """Get information about this endpoint # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_import(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: InlineResponse2002 + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_import_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.read_import_with_http_info(**kwargs) # noqa: E501 + return data + + def read_import_with_http_info(self, **kwargs): # noqa: E501 + """Get information about this endpoint # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_import_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: InlineResponse2002 + If the method is called asynchronously, + returns the request thread. + """ + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_import" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/import', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='InlineResponse2002', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/info_api.py b/vendor/elabapi-python/elabapi_python/api/info_api.py new file mode 100644 index 0000000..6ac7223 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/info_api.py @@ -0,0 +1,128 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class InfoApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def get_info(self, **kwargs): # noqa: E501 + """Get information about the instance. # noqa: E501 + + Get information about the instance. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param bool hist: Get usage information about the instance. If `hist` is present, returns cumulative histogram data for experiments, items (resources), and users. + :param int columns: Number of columns (buckets) to display in histogram outputs. + :return: InlineResponse2001 + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.get_info_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.get_info_with_http_info(**kwargs) # noqa: E501 + return data + + def get_info_with_http_info(self, **kwargs): # noqa: E501 + """Get information about the instance. # noqa: E501 + + Get information about the instance. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_info_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param bool hist: Get usage information about the instance. If `hist` is present, returns cumulative histogram data for experiments, items (resources), and users. + :param int columns: Number of columns (buckets) to display in histogram outputs. + :return: InlineResponse2001 + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['hist', 'columns'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method get_info" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'hist' in params: + query_params.append(('hist', params['hist'])) # noqa: E501 + if 'columns' in params: + query_params.append(('columns', params['columns'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/info', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='InlineResponse2001', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/instance_api.py b/vendor/elabapi-python/elabapi_python/api/instance_api.py new file mode 100644 index 0000000..c3adc4b --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/instance_api.py @@ -0,0 +1,130 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class InstanceApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def post_instance(self, body, **kwargs): # noqa: E501 + """Run an instance level action. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_instance(body, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param InstanceBody body: Parameters for the instance action. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_instance_with_http_info(body, **kwargs) # noqa: E501 + else: + (data) = self.post_instance_with_http_info(body, **kwargs) # noqa: E501 + return data + + def post_instance_with_http_info(self, body, **kwargs): # noqa: E501 + """Run an instance level action. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_instance_with_http_info(body, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param InstanceBody body: Parameters for the instance action. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_instance" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'body' is set + if ('body' not in params or + params['body'] is None): + raise ValueError("Missing the required parameter `body` when calling `post_instance`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/instance', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/items_api.py b/vendor/elabapi-python/elabapi_python/api/items_api.py new file mode 100644 index 0000000..3a2a6f3 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/items_api.py @@ -0,0 +1,686 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class ItemsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_item(self, id, **kwargs): # noqa: E501 + """Delete an item. # noqa: E501 + + The item gets soft-deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_item(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the item (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_item_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.delete_item_with_http_info(id, **kwargs) # noqa: E501 + return data + + def delete_item_with_http_info(self, id, **kwargs): # noqa: E501 + """Delete an item. # noqa: E501 + + The item gets soft-deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_item_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the item (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_item" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_item`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/items/{id}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def get_item(self, id, **kwargs): # noqa: E501 + """Read an item # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_item(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the item (required) + :param str format: Get the entity in a different format like csv, pdf, eln or zip. \"pdfa\" means archive pdf (PDF/A), same with \"zipa\". + :param bool json: Include a full JSON export in the ZIP archive. Only applicable if format is zip(a). + :param bool with_title: Include the title in the QR code. Only applicable if format is qrpng. + :param int size: Specify the size of the QR code in pixels. Only applicable if format is qrpng. + :param bool changelog: Toggles if the changelog should be included in PDF exports (pdf, pdfa, zip, zipa). Changelog is by default included if the export provides PDF/A, otherwise not. + :return: Entity + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.get_item_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.get_item_with_http_info(id, **kwargs) # noqa: E501 + return data + + def get_item_with_http_info(self, id, **kwargs): # noqa: E501 + """Read an item # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_item_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the item (required) + :param str format: Get the entity in a different format like csv, pdf, eln or zip. \"pdfa\" means archive pdf (PDF/A), same with \"zipa\". + :param bool json: Include a full JSON export in the ZIP archive. Only applicable if format is zip(a). + :param bool with_title: Include the title in the QR code. Only applicable if format is qrpng. + :param int size: Specify the size of the QR code in pixels. Only applicable if format is qrpng. + :param bool changelog: Toggles if the changelog should be included in PDF exports (pdf, pdfa, zip, zipa). Changelog is by default included if the export provides PDF/A, otherwise not. + :return: Entity + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'format', 'json', 'with_title', 'size', 'changelog'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method get_item" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `get_item`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + if 'format' in params: + query_params.append(('format', params['format'])) # noqa: E501 + if 'json' in params: + query_params.append(('json', params['json'])) # noqa: E501 + if 'with_title' in params: + query_params.append(('withTitle', params['with_title'])) # noqa: E501 + if 'size' in params: + query_params.append(('size', params['size'])) # noqa: E501 + if 'changelog' in params: + query_params.append(('changelog', params['changelog'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/items/{id}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Entity', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def patch_item(self, body, id, **kwargs): # noqa: E501 + """Modify an item # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_item(body, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param object body: Parameters for patching an item (required) + :param int id: ID of the item (required) + :return: Item + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_item_with_http_info(body, id, **kwargs) # noqa: E501 + else: + (data) = self.patch_item_with_http_info(body, id, **kwargs) # noqa: E501 + return data + + def patch_item_with_http_info(self, body, id, **kwargs): # noqa: E501 + """Modify an item # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_item_with_http_info(body, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param object body: Parameters for patching an item (required) + :param int id: ID of the item (required) + :return: Item + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['body', 'id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_item" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'body' is set + if ('body' not in params or + params['body'] is None): + raise ValueError("Missing the required parameter `body` when calling `patch_item`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_item`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/items/{id}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Item', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_item(self, **kwargs): # noqa: E501 + """Create an item # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_item(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param EntityEditable body: Parameters for creating an item + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_item_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.post_item_with_http_info(**kwargs) # noqa: E501 + return data + + def post_item_with_http_info(self, **kwargs): # noqa: E501 + """Create an item # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_item_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param EntityEditable body: Parameters for creating an item + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_item" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/items', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_item_by_id(self, id, **kwargs): # noqa: E501 + """Duplicate an item with its ID # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_item_by_id(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: The unique identifier of the item to duplicate. (required) + :param EntityDuplicate body: Parameters for duplicating an item + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_item_by_id_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.post_item_by_id_with_http_info(id, **kwargs) # noqa: E501 + return data + + def post_item_by_id_with_http_info(self, id, **kwargs): # noqa: E501 + """Duplicate an item with its ID # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_item_by_id_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: The unique identifier of the item to duplicate. (required) + :param EntityDuplicate body: Parameters for duplicating an item + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_item_by_id" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_item_by_id`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/items/{id}', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_items(self, **kwargs): # noqa: E501 + """Read all items that are accessible # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_items(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str q: Search for a term in title, body or elabid. + :param str extended: Extended search (advanced query). + :param int related: Look only for entries linked to this entry id. + :param str related_origin: When using the \"related\" query parameter, select the type of the related ID (experiments or items) + :param str category: Add a filter on the Category. Supports comma separated list of numbers, including \"null\". + :param str status: Add a filter on the Status. Supports comma separated list of numbers, including \"null\". + :param list[str] tags: An array of tags for filtering results containing all of these tags. + :param int limit: Limit the number of results. + :param int offset: Skip a number of results. Use with limit to work the pagination. + :param str owner: Filter results by author (user id) + :param int scope: Set the scope for the results. 1: self, 2: team, 3: everything. It defaults to the user value stored in preferences. + :param str order: Change the ordering of the results. + :param str sort: Change the sorting of results: ascending or descending. + :param str state: Filter results based on their state: 1 (Normal), 2 (Archived), 3 (Deleted). Supports comma separated values. + :param int full: Return all columns of each entry when set to 1. + :return: list[Item] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_items_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.read_items_with_http_info(**kwargs) # noqa: E501 + return data + + def read_items_with_http_info(self, **kwargs): # noqa: E501 + """Read all items that are accessible # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_items_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str q: Search for a term in title, body or elabid. + :param str extended: Extended search (advanced query). + :param int related: Look only for entries linked to this entry id. + :param str related_origin: When using the \"related\" query parameter, select the type of the related ID (experiments or items) + :param str category: Add a filter on the Category. Supports comma separated list of numbers, including \"null\". + :param str status: Add a filter on the Status. Supports comma separated list of numbers, including \"null\". + :param list[str] tags: An array of tags for filtering results containing all of these tags. + :param int limit: Limit the number of results. + :param int offset: Skip a number of results. Use with limit to work the pagination. + :param str owner: Filter results by author (user id) + :param int scope: Set the scope for the results. 1: self, 2: team, 3: everything. It defaults to the user value stored in preferences. + :param str order: Change the ordering of the results. + :param str sort: Change the sorting of results: ascending or descending. + :param str state: Filter results based on their state: 1 (Normal), 2 (Archived), 3 (Deleted). Supports comma separated values. + :param int full: Return all columns of each entry when set to 1. + :return: list[Item] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['q', 'extended', 'related', 'related_origin', 'category', 'status', 'tags', 'limit', 'offset', 'owner', 'scope', 'order', 'sort', 'state', 'full'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_items" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'q' in params: + query_params.append(('q', params['q'])) # noqa: E501 + if 'extended' in params: + query_params.append(('extended', params['extended'])) # noqa: E501 + if 'related' in params: + query_params.append(('related', params['related'])) # noqa: E501 + if 'related_origin' in params: + query_params.append(('related_origin', params['related_origin'])) # noqa: E501 + if 'category' in params: + query_params.append(('category', params['category'])) # noqa: E501 + if 'status' in params: + query_params.append(('status', params['status'])) # noqa: E501 + if 'tags' in params: + query_params.append(('tags[]', params['tags'])) # noqa: E501 + collection_formats['tags[]'] = 'multi' # noqa: E501 + if 'limit' in params: + query_params.append(('limit', params['limit'])) # noqa: E501 + if 'offset' in params: + query_params.append(('offset', params['offset'])) # noqa: E501 + if 'owner' in params: + query_params.append(('owner', params['owner'])) # noqa: E501 + if 'scope' in params: + query_params.append(('scope', params['scope'])) # noqa: E501 + if 'order' in params: + query_params.append(('order', params['order'])) # noqa: E501 + if 'sort' in params: + query_params.append(('sort', params['sort'])) # noqa: E501 + if 'state' in params: + query_params.append(('state', params['state'])) # noqa: E501 + if 'full' in params: + query_params.append(('full', params['full'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/items', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Item]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/items_types__resources_templates_api.py b/vendor/elabapi-python/elabapi_python/api/items_types__resources_templates_api.py new file mode 100644 index 0000000..09f64ab --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/items_types__resources_templates_api.py @@ -0,0 +1,662 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class ItemsTypesResourcesTemplatesApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_items_type(self, id, **kwargs): # noqa: E501 + """Delete a resource template. # noqa: E501 + + The resource template gets soft-deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_items_type(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the resource template (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_items_type_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.delete_items_type_with_http_info(id, **kwargs) # noqa: E501 + return data + + def delete_items_type_with_http_info(self, id, **kwargs): # noqa: E501 + """Delete a resource template. # noqa: E501 + + The resource template gets soft-deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_items_type_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the resource template (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_items_type" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_items_type`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/items_types/{id}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def get_items_type(self, id, **kwargs): # noqa: E501 + """Read a resource template # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_items_type(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the resource template (required) + :return: EntityTemplate + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.get_items_type_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.get_items_type_with_http_info(id, **kwargs) # noqa: E501 + return data + + def get_items_type_with_http_info(self, id, **kwargs): # noqa: E501 + """Read a resource template # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_items_type_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the resource template (required) + :return: EntityTemplate + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method get_items_type" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `get_items_type`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/items_types/{id}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='EntityTemplate', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def patch_items_type(self, id, **kwargs): # noqa: E501 + """Modify a resource template # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_items_type(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the resource template (required) + :param ItemsTypesIdBody body: Parameters for modifying a resource template + :return: EntityTemplate + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_items_type_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.patch_items_type_with_http_info(id, **kwargs) # noqa: E501 + return data + + def patch_items_type_with_http_info(self, id, **kwargs): # noqa: E501 + """Modify a resource template # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_items_type_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the resource template (required) + :param ItemsTypesIdBody body: Parameters for modifying a resource template + :return: EntityTemplate + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_items_type" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_items_type`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/items_types/{id}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='EntityTemplate', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_items_types(self, **kwargs): # noqa: E501 + """Create a resource template # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_items_types(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param EntityTemplateEditable body: Parameters for creating a resource template + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_items_types_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.post_items_types_with_http_info(**kwargs) # noqa: E501 + return data + + def post_items_types_with_http_info(self, **kwargs): # noqa: E501 + """Create a resource template # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_items_types_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param EntityTemplateEditable body: Parameters for creating a resource template + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_items_types" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/items_types', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_items_types_by_id(self, id, **kwargs): # noqa: E501 + """Duplicate a resource template with its ID # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_items_types_by_id(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: The unique identifier of the resource template to duplicate. (required) + :param EntityDuplicate body: Parameters for duplicating a resource template + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_items_types_by_id_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.post_items_types_by_id_with_http_info(id, **kwargs) # noqa: E501 + return data + + def post_items_types_by_id_with_http_info(self, id, **kwargs): # noqa: E501 + """Duplicate a resource template with its ID # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_items_types_by_id_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: The unique identifier of the resource template to duplicate. (required) + :param EntityDuplicate body: Parameters for duplicating a resource template + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_items_types_by_id" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_items_types_by_id`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/items_types/{id}', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_items_types(self, **kwargs): # noqa: E501 + """Read all resources templates that are accessible # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_items_types(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str q: Search for a term in title, body or elabid. + :param str extended: Extended search (advanced query). + :param int related: Look only for entries linked to this entry id. + :param str related_origin: When using the \"related\" query parameter, select the type of the related ID (experiments or items) + :param str category: Add a filter on the Category. Supports comma separated list of numbers, including \"null\". + :param str status: Add a filter on the Status. Supports comma separated list of numbers, including \"null\". + :param list[str] tags: An array of tags for filtering results containing all of these tags. + :param int limit: Limit the number of results. + :param int offset: Skip a number of results. Use with limit to work the pagination. + :param str owner: Filter results by author (user id) + :param int scope: Set the scope for the results. 1: self, 2: team, 3: everything. It defaults to the user value stored in preferences. + :param str order: Change the ordering of the results. + :param str sort: Change the sorting of results: ascending or descending. + :param str state: Filter results based on their state: 1 (Normal), 2 (Archived), 3 (Deleted). Supports comma separated values. + :param int full: Return all columns of each entry when set to 1. + :return: list[EntityTemplate] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_items_types_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.read_items_types_with_http_info(**kwargs) # noqa: E501 + return data + + def read_items_types_with_http_info(self, **kwargs): # noqa: E501 + """Read all resources templates that are accessible # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_items_types_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str q: Search for a term in title, body or elabid. + :param str extended: Extended search (advanced query). + :param int related: Look only for entries linked to this entry id. + :param str related_origin: When using the \"related\" query parameter, select the type of the related ID (experiments or items) + :param str category: Add a filter on the Category. Supports comma separated list of numbers, including \"null\". + :param str status: Add a filter on the Status. Supports comma separated list of numbers, including \"null\". + :param list[str] tags: An array of tags for filtering results containing all of these tags. + :param int limit: Limit the number of results. + :param int offset: Skip a number of results. Use with limit to work the pagination. + :param str owner: Filter results by author (user id) + :param int scope: Set the scope for the results. 1: self, 2: team, 3: everything. It defaults to the user value stored in preferences. + :param str order: Change the ordering of the results. + :param str sort: Change the sorting of results: ascending or descending. + :param str state: Filter results based on their state: 1 (Normal), 2 (Archived), 3 (Deleted). Supports comma separated values. + :param int full: Return all columns of each entry when set to 1. + :return: list[EntityTemplate] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['q', 'extended', 'related', 'related_origin', 'category', 'status', 'tags', 'limit', 'offset', 'owner', 'scope', 'order', 'sort', 'state', 'full'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_items_types" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'q' in params: + query_params.append(('q', params['q'])) # noqa: E501 + if 'extended' in params: + query_params.append(('extended', params['extended'])) # noqa: E501 + if 'related' in params: + query_params.append(('related', params['related'])) # noqa: E501 + if 'related_origin' in params: + query_params.append(('related_origin', params['related_origin'])) # noqa: E501 + if 'category' in params: + query_params.append(('category', params['category'])) # noqa: E501 + if 'status' in params: + query_params.append(('status', params['status'])) # noqa: E501 + if 'tags' in params: + query_params.append(('tags[]', params['tags'])) # noqa: E501 + collection_formats['tags[]'] = 'multi' # noqa: E501 + if 'limit' in params: + query_params.append(('limit', params['limit'])) # noqa: E501 + if 'offset' in params: + query_params.append(('offset', params['offset'])) # noqa: E501 + if 'owner' in params: + query_params.append(('owner', params['owner'])) # noqa: E501 + if 'scope' in params: + query_params.append(('scope', params['scope'])) # noqa: E501 + if 'order' in params: + query_params.append(('order', params['order'])) # noqa: E501 + if 'sort' in params: + query_params.append(('sort', params['sort'])) # noqa: E501 + if 'state' in params: + query_params.append(('state', params['state'])) # noqa: E501 + if 'full' in params: + query_params.append(('full', params['full'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/items_types', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[EntityTemplate]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/links_to_compounds_api.py b/vendor/elabapi-python/elabapi_python/api/links_to_compounds_api.py new file mode 100644 index 0000000..74ca249 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/links_to_compounds_api.py @@ -0,0 +1,362 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class LinksToCompoundsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_entity_compounds_link(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Delete a compound link. # noqa: E501 + + The link gets deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_entity_compounds_link(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the compound linked (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_entity_compounds_link_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.delete_entity_compounds_link_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def delete_entity_compounds_link_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Delete a compound link. # noqa: E501 + + The link gets deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_entity_compounds_link_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the compound linked (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_entity_compounds_link" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `delete_entity_compounds_link`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_entity_compounds_link`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `delete_entity_compounds_link`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/compounds_links/{subid}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_entity_compounds_links(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Link an entity to a compound. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_entity_compounds_links(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the compound linked (required) + :param CompoundsLinksSubidBody body: Parameters for creating a link. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_entity_compounds_links_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.post_entity_compounds_links_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def post_entity_compounds_links_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Link an entity to a compound. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_entity_compounds_links_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the compound linked (required) + :param CompoundsLinksSubidBody body: Parameters for creating a link. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_entity_compounds_links" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `post_entity_compounds_links`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_entity_compounds_links`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `post_entity_compounds_links`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/compounds_links/{subid}', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_entity_compounds_links(self, entity_type, id, **kwargs): # noqa: E501 + """Read all compounds links of that entity. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_entity_compounds_links(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :return: list[Link] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_entity_compounds_links_with_http_info(entity_type, id, **kwargs) # noqa: E501 + else: + (data) = self.read_entity_compounds_links_with_http_info(entity_type, id, **kwargs) # noqa: E501 + return data + + def read_entity_compounds_links_with_http_info(self, entity_type, id, **kwargs): # noqa: E501 + """Read all compounds links of that entity. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_entity_compounds_links_with_http_info(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :return: list[Link] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_entity_compounds_links" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `read_entity_compounds_links`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_entity_compounds_links`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/compounds_links', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Link]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/links_to_experiments_api.py b/vendor/elabapi-python/elabapi_python/api/links_to_experiments_api.py new file mode 100644 index 0000000..e5c5bb0 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/links_to_experiments_api.py @@ -0,0 +1,362 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class LinksToExperimentsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_entity_experiments_link(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Delete an experiment link. # noqa: E501 + + The link gets deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_entity_experiments_link(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the experiment linked (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_entity_experiments_link_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.delete_entity_experiments_link_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def delete_entity_experiments_link_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Delete an experiment link. # noqa: E501 + + The link gets deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_entity_experiments_link_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the experiment linked (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_entity_experiments_link" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `delete_entity_experiments_link`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_entity_experiments_link`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `delete_entity_experiments_link`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/experiments_links/{subid}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_entity_experiments_links(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Create or import a link. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_entity_experiments_links(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the experiment linked (required) + :param ExperimentsLinksSubidBody body: Parameters for creating or importing a link. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_entity_experiments_links_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.post_entity_experiments_links_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def post_entity_experiments_links_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Create or import a link. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_entity_experiments_links_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the experiment linked (required) + :param ExperimentsLinksSubidBody body: Parameters for creating or importing a link. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_entity_experiments_links" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `post_entity_experiments_links`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_entity_experiments_links`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `post_entity_experiments_links`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/experiments_links/{subid}', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_entity_experiments_links(self, entity_type, id, **kwargs): # noqa: E501 + """Read all experiments links of that entity. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_entity_experiments_links(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :return: list[Link] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_entity_experiments_links_with_http_info(entity_type, id, **kwargs) # noqa: E501 + else: + (data) = self.read_entity_experiments_links_with_http_info(entity_type, id, **kwargs) # noqa: E501 + return data + + def read_entity_experiments_links_with_http_info(self, entity_type, id, **kwargs): # noqa: E501 + """Read all experiments links of that entity. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_entity_experiments_links_with_http_info(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :return: list[Link] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_entity_experiments_links" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `read_entity_experiments_links`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_entity_experiments_links`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/experiments_links', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Link]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/links_to_items_api.py b/vendor/elabapi-python/elabapi_python/api/links_to_items_api.py new file mode 100644 index 0000000..9ea7014 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/links_to_items_api.py @@ -0,0 +1,362 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class LinksToItemsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_entitiy_items_link(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Delete an item link. # noqa: E501 + + The link gets deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_entitiy_items_link(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the item (link) (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_entitiy_items_link_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.delete_entitiy_items_link_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def delete_entitiy_items_link_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Delete an item link. # noqa: E501 + + The link gets deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_entitiy_items_link_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the item (link) (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_entitiy_items_link" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `delete_entitiy_items_link`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_entitiy_items_link`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `delete_entitiy_items_link`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/items_links/{subid}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_entity_items_links(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Create or import a link. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_entity_items_links(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the item (link) (required) + :param ItemsLinksSubidBody body: Parameters for creating or importing a link. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_entity_items_links_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.post_entity_items_links_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def post_entity_items_links_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Create or import a link. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_entity_items_links_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the item (link) (required) + :param ItemsLinksSubidBody body: Parameters for creating or importing a link. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_entity_items_links" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `post_entity_items_links`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_entity_items_links`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `post_entity_items_links`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/items_links/{subid}', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_entity_items_links(self, entity_type, id, **kwargs): # noqa: E501 + """Read all items links of that entity. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_entity_items_links(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :return: list[Link] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_entity_items_links_with_http_info(entity_type, id, **kwargs) # noqa: E501 + else: + (data) = self.read_entity_items_links_with_http_info(entity_type, id, **kwargs) # noqa: E501 + return data + + def read_entity_items_links_with_http_info(self, entity_type, id, **kwargs): # noqa: E501 + """Read all items links of that entity. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_entity_items_links_with_http_info(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :return: list[Link] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_entity_items_links" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `read_entity_items_links`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_entity_items_links`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/items_links', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Link]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/notifications_api.py b/vendor/elabapi-python/elabapi_python/api/notifications_api.py new file mode 100644 index 0000000..43370a9 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/notifications_api.py @@ -0,0 +1,431 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class NotificationsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_notifications(self, id, **kwargs): # noqa: E501 + """Delete all notifications of the user. # noqa: E501 + + All notifications for the user are deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_notifications(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param Id3 id: ID of the user or `me`. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_notifications_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.delete_notifications_with_http_info(id, **kwargs) # noqa: E501 + return data + + def delete_notifications_with_http_info(self, id, **kwargs): # noqa: E501 + """Delete all notifications of the user. # noqa: E501 + + All notifications for the user are deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_notifications_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param Id3 id: ID of the user or `me`. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_notifications" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_notifications`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/users/{id}/notifications', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def patch_notification(self, id, subid, **kwargs): # noqa: E501 + """Update the acknowledgment status of a notification. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_notification(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param Id4 id: ID of the user or `me`. (required) + :param int subid: ID of the notification. (required) + :param NotificationsSubidBody body: Defines whether the notification is acknowledged. + :return: Notification + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_notification_with_http_info(id, subid, **kwargs) # noqa: E501 + else: + (data) = self.patch_notification_with_http_info(id, subid, **kwargs) # noqa: E501 + return data + + def patch_notification_with_http_info(self, id, subid, **kwargs): # noqa: E501 + """Update the acknowledgment status of a notification. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_notification_with_http_info(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param Id4 id: ID of the user or `me`. (required) + :param int subid: ID of the notification. (required) + :param NotificationsSubidBody body: Defines whether the notification is acknowledged. + :return: Notification + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'subid', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_notification" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_notification`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `patch_notification`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/users/{id}/notifications/{subid}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Notification', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_notification(self, id, subid, **kwargs): # noqa: E501 + """Read a notification. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_notification(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param Id4 id: ID of the user or `me`. (required) + :param int subid: ID of the notification. (required) + :return: Notification + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_notification_with_http_info(id, subid, **kwargs) # noqa: E501 + else: + (data) = self.read_notification_with_http_info(id, subid, **kwargs) # noqa: E501 + return data + + def read_notification_with_http_info(self, id, subid, **kwargs): # noqa: E501 + """Read a notification. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_notification_with_http_info(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param Id4 id: ID of the user or `me`. (required) + :param int subid: ID of the notification. (required) + :return: Notification + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_notification" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_notification`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `read_notification`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/users/{id}/notifications/{subid}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Notification', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_notifications(self, id, **kwargs): # noqa: E501 + """Read notifications of a user. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_notifications(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param Id3 id: ID of the user or `me`. (required) + :return: InlineResponse2007 + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_notifications_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.read_notifications_with_http_info(id, **kwargs) # noqa: E501 + return data + + def read_notifications_with_http_info(self, id, **kwargs): # noqa: E501 + """Read notifications of a user. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_notifications_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param Id3 id: ID of the user or `me`. (required) + :return: InlineResponse2007 + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_notifications" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_notifications`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/users/{id}/notifications', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='InlineResponse2007', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/reports_api.py b/vendor/elabapi-python/elabapi_python/api/reports_api.py new file mode 100644 index 0000000..818011e --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/reports_api.py @@ -0,0 +1,136 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class ReportsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def get_reports(self, **kwargs): # noqa: E501 + """Get usage reports # noqa: E501 + + Get usage reports at the instance or team level. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_reports(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str format: Select the output format + :param str scope: Select the scope. Instance is for sysadmins only. Team will generate report for the current team. If scope is `compounds_history`, you can also provide `start` and `end` (format `YYYY-MM-DD`). + :param date start: Start date (YYYY-MM-DD). Only used when scope is `compounds_history`. + :param date end: End date (YYYY-MM-DD). Only used when scope is `compounds_history`. + :return: InlineResponse2004 + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.get_reports_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.get_reports_with_http_info(**kwargs) # noqa: E501 + return data + + def get_reports_with_http_info(self, **kwargs): # noqa: E501 + """Get usage reports # noqa: E501 + + Get usage reports at the instance or team level. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_reports_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str format: Select the output format + :param str scope: Select the scope. Instance is for sysadmins only. Team will generate report for the current team. If scope is `compounds_history`, you can also provide `start` and `end` (format `YYYY-MM-DD`). + :param date start: Start date (YYYY-MM-DD). Only used when scope is `compounds_history`. + :param date end: End date (YYYY-MM-DD). Only used when scope is `compounds_history`. + :return: InlineResponse2004 + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['format', 'scope', 'start', 'end'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method get_reports" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'format' in params: + query_params.append(('format', params['format'])) # noqa: E501 + if 'scope' in params: + query_params.append(('scope', params['scope'])) # noqa: E501 + if 'start' in params: + query_params.append(('start', params['start'])) # noqa: E501 + if 'end' in params: + query_params.append(('end', params['end'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json', 'text/csv']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/reports', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='InlineResponse2004', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/resources_categories_api.py b/vendor/elabapi-python/elabapi_python/api/resources_categories_api.py new file mode 100644 index 0000000..5f13a96 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/resources_categories_api.py @@ -0,0 +1,538 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class ResourcesCategoriesApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_rescat(self, id, subid, **kwargs): # noqa: E501 + """Delete a category. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_rescat(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the category. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_rescat_with_http_info(id, subid, **kwargs) # noqa: E501 + else: + (data) = self.delete_rescat_with_http_info(id, subid, **kwargs) # noqa: E501 + return data + + def delete_rescat_with_http_info(self, id, subid, **kwargs): # noqa: E501 + """Delete a category. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_rescat_with_http_info(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the category. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_rescat" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_rescat`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `delete_rescat`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/resources_categories/{subid}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def patch_rescat(self, id, subid, **kwargs): # noqa: E501 + """Modify a category. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_rescat(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the category. (required) + :param Statuslike body: Parameters for modifying a resource category. + :return: Statuslike + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_rescat_with_http_info(id, subid, **kwargs) # noqa: E501 + else: + (data) = self.patch_rescat_with_http_info(id, subid, **kwargs) # noqa: E501 + return data + + def patch_rescat_with_http_info(self, id, subid, **kwargs): # noqa: E501 + """Modify a category. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_rescat_with_http_info(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the category. (required) + :param Statuslike body: Parameters for modifying a resource category. + :return: Statuslike + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'subid', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_rescat" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_rescat`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `patch_rescat`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/resources_categories/{subid}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Statuslike', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_team_one_rescat(self, id, **kwargs): # noqa: E501 + """Create a new category for resources. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_team_one_rescat(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param IdResourcesCategoriesBody body: Parameters for creating a resource category. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_team_one_rescat_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.post_team_one_rescat_with_http_info(id, **kwargs) # noqa: E501 + return data + + def post_team_one_rescat_with_http_info(self, id, **kwargs): # noqa: E501 + """Create a new category for resources. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_team_one_rescat_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param IdResourcesCategoriesBody body: Parameters for creating a resource category. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_team_one_rescat" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_team_one_rescat`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/resources_categories', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_team_one_rescat(self, id, subid, **kwargs): # noqa: E501 + """Read a category. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_one_rescat(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the category. (required) + :return: Statuslike + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_team_one_rescat_with_http_info(id, subid, **kwargs) # noqa: E501 + else: + (data) = self.read_team_one_rescat_with_http_info(id, subid, **kwargs) # noqa: E501 + return data + + def read_team_one_rescat_with_http_info(self, id, subid, **kwargs): # noqa: E501 + """Read a category. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_one_rescat_with_http_info(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the category. (required) + :return: Statuslike + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_team_one_rescat" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_team_one_rescat`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `read_team_one_rescat`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/resources_categories/{subid}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Statuslike', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_team_resources_categories(self, id, **kwargs): # noqa: E501 + """Read resources categories of a team. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_resources_categories(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :return: list[Statuslike] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_team_resources_categories_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.read_team_resources_categories_with_http_info(id, **kwargs) # noqa: E501 + return data + + def read_team_resources_categories_with_http_info(self, id, **kwargs): # noqa: E501 + """Read resources categories of a team. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_resources_categories_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :return: list[Statuslike] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_team_resources_categories" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_team_resources_categories`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/resources_categories', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Statuslike]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/resources_status_api.py b/vendor/elabapi-python/elabapi_python/api/resources_status_api.py new file mode 100644 index 0000000..a5bd6ed --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/resources_status_api.py @@ -0,0 +1,538 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class ResourcesStatusApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_resstatus(self, id, subid, **kwargs): # noqa: E501 + """Delete a status. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_resstatus(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the status (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_resstatus_with_http_info(id, subid, **kwargs) # noqa: E501 + else: + (data) = self.delete_resstatus_with_http_info(id, subid, **kwargs) # noqa: E501 + return data + + def delete_resstatus_with_http_info(self, id, subid, **kwargs): # noqa: E501 + """Delete a status. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_resstatus_with_http_info(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the status (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_resstatus" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_resstatus`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `delete_resstatus`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/items_status/{subid}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def patch_resstatus(self, id, subid, **kwargs): # noqa: E501 + """Modify a status. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_resstatus(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the status (required) + :param Statuslike body: Parameters for modifying a status. + :return: Statuslike + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_resstatus_with_http_info(id, subid, **kwargs) # noqa: E501 + else: + (data) = self.patch_resstatus_with_http_info(id, subid, **kwargs) # noqa: E501 + return data + + def patch_resstatus_with_http_info(self, id, subid, **kwargs): # noqa: E501 + """Modify a status. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_resstatus_with_http_info(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the status (required) + :param Statuslike body: Parameters for modifying a status. + :return: Statuslike + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'subid', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_resstatus" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_resstatus`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `patch_resstatus`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/items_status/{subid}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Statuslike', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_team_one_resstat(self, id, **kwargs): # noqa: E501 + """Create a new status for resources. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_team_one_resstat(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param IdItemsStatusBody body: Parameters for creating a resources status. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_team_one_resstat_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.post_team_one_resstat_with_http_info(id, **kwargs) # noqa: E501 + return data + + def post_team_one_resstat_with_http_info(self, id, **kwargs): # noqa: E501 + """Create a new status for resources. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_team_one_resstat_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param IdItemsStatusBody body: Parameters for creating a resources status. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_team_one_resstat" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_team_one_resstat`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/items_status', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_team_items_status(self, id, **kwargs): # noqa: E501 + """Read resources status of a team. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_items_status(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :return: list[Statuslike] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_team_items_status_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.read_team_items_status_with_http_info(id, **kwargs) # noqa: E501 + return data + + def read_team_items_status_with_http_info(self, id, **kwargs): # noqa: E501 + """Read resources status of a team. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_items_status_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :return: list[Statuslike] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_team_items_status" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_team_items_status`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/items_status', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Statuslike]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_team_one_resstatus(self, id, subid, **kwargs): # noqa: E501 + """Read a status. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_one_resstatus(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the status (required) + :return: Statuslike + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_team_one_resstatus_with_http_info(id, subid, **kwargs) # noqa: E501 + else: + (data) = self.read_team_one_resstatus_with_http_info(id, subid, **kwargs) # noqa: E501 + return data + + def read_team_one_resstatus_with_http_info(self, id, subid, **kwargs): # noqa: E501 + """Read a status. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_one_resstatus_with_http_info(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the status (required) + :return: Statuslike + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_team_one_resstatus" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_team_one_resstatus`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `read_team_one_resstatus`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/items_status/{subid}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Statuslike', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/revisions_api.py b/vendor/elabapi-python/elabapi_python/api/revisions_api.py new file mode 100644 index 0000000..67c4500 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/revisions_api.py @@ -0,0 +1,360 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class RevisionsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def patch_entity_revision(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Restore a revision. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_entity_revision(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the revision (required) + :param RevisionsSubidBody body: Parameters for restoring an entity revision. + :return: Revision + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_entity_revision_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.patch_entity_revision_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def patch_entity_revision_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Restore a revision. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_entity_revision_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the revision (required) + :param RevisionsSubidBody body: Parameters for restoring an entity revision. + :return: Revision + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_entity_revision" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `patch_entity_revision`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_entity_revision`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `patch_entity_revision`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/revisions/{subid}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Revision', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_entity_revision(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Read a revision of that entity. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_entity_revision(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the revision (required) + :return: Revision + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_entity_revision_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.read_entity_revision_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def read_entity_revision_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Read a revision of that entity. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_entity_revision_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the revision (required) + :return: Revision + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_entity_revision" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `read_entity_revision`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_entity_revision`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `read_entity_revision`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/revisions/{subid}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Revision', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_entity_revisions(self, entity_type, id, **kwargs): # noqa: E501 + """Read all revisions of that entity. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_entity_revisions(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :return: list[InlineResponse2008] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_entity_revisions_with_http_info(entity_type, id, **kwargs) # noqa: E501 + else: + (data) = self.read_entity_revisions_with_http_info(entity_type, id, **kwargs) # noqa: E501 + return data + + def read_entity_revisions_with_http_info(self, entity_type, id, **kwargs): # noqa: E501 + """Read all revisions of that entity. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_entity_revisions_with_http_info(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :return: list[InlineResponse2008] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_entity_revisions" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `read_entity_revisions`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_entity_revisions`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/revisions', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[InlineResponse2008]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/steps_api.py b/vendor/elabapi-python/elabapi_python/api/steps_api.py new file mode 100644 index 0000000..3df6579 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/steps_api.py @@ -0,0 +1,471 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class StepsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_step(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Delete a step. # noqa: E501 + + The step gets deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_step(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the step (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_step_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.delete_step_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def delete_step_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Delete a step. # noqa: E501 + + The step gets deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_step_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the step (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_step" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `delete_step`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_step`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `delete_step`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/steps/{subid}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def patch_step(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Actions on a step. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_step(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the step (required) + :param StepsSubidBody body: Parameters for modifying a step + :return: Step + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_step_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.patch_step_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def patch_step_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Actions on a step. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_step_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the step (required) + :param StepsSubidBody body: Parameters for modifying a step + :return: Step + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_step" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `patch_step`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_step`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `patch_step`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/steps/{subid}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Step', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_step(self, entity_type, id, **kwargs): # noqa: E501 + """Create a step. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_step(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param IdStepsBody body: Parameters for creating a step. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_step_with_http_info(entity_type, id, **kwargs) # noqa: E501 + else: + (data) = self.post_step_with_http_info(entity_type, id, **kwargs) # noqa: E501 + return data + + def post_step_with_http_info(self, entity_type, id, **kwargs): # noqa: E501 + """Create a step. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_step_with_http_info(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param IdStepsBody body: Parameters for creating a step. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_step" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `post_step`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_step`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/steps', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_steps(self, entity_type, id, **kwargs): # noqa: E501 + """Read all steps of that entity. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_steps(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :return: list[Step] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_steps_with_http_info(entity_type, id, **kwargs) # noqa: E501 + else: + (data) = self.read_steps_with_http_info(entity_type, id, **kwargs) # noqa: E501 + return data + + def read_steps_with_http_info(self, entity_type, id, **kwargs): # noqa: E501 + """Read all steps of that entity. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_steps_with_http_info(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :return: list[Step] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_steps" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `read_steps`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_steps`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/steps', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Step]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/storage_units_api.py b/vendor/elabapi-python/elabapi_python/api/storage_units_api.py new file mode 100644 index 0000000..faf5e5e --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/storage_units_api.py @@ -0,0 +1,516 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class StorageUnitsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_storage_unit(self, id, **kwargs): # noqa: E501 + """Delete a storage unit. # noqa: E501 + + Delete a storage unit. Requires permission to manage inventory locations. Cannot delete a storage unit that has children or containers. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_storage_unit(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the storage unit. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_storage_unit_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.delete_storage_unit_with_http_info(id, **kwargs) # noqa: E501 + return data + + def delete_storage_unit_with_http_info(self, id, **kwargs): # noqa: E501 + """Delete a storage unit. # noqa: E501 + + Delete a storage unit. Requires permission to manage inventory locations. Cannot delete a storage unit that has children or containers. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_storage_unit_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the storage unit. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_storage_unit" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_storage_unit`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/storage_units/{id}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def patch_storage_unit(self, id, **kwargs): # noqa: E501 + """Modify a storage unit. # noqa: E501 + + Update the name and/or the parent of a storage unit. Setting `parent_id` reparents the unit (and everything under it) in place. Pass `parent_id: null` to move the unit to the root. Requires permission to manage inventory locations. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_storage_unit(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the storage unit. (required) + :param StorageUnitsIdBody body: Parameters for modifying a storage unit. + :return: StorageUnit + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_storage_unit_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.patch_storage_unit_with_http_info(id, **kwargs) # noqa: E501 + return data + + def patch_storage_unit_with_http_info(self, id, **kwargs): # noqa: E501 + """Modify a storage unit. # noqa: E501 + + Update the name and/or the parent of a storage unit. Setting `parent_id` reparents the unit (and everything under it) in place. Pass `parent_id: null` to move the unit to the root. Requires permission to manage inventory locations. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_storage_unit_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the storage unit. (required) + :param StorageUnitsIdBody body: Parameters for modifying a storage unit. + :return: StorageUnit + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_storage_unit" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_storage_unit`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/storage_units/{id}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='StorageUnit', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_storage_unit(self, body, **kwargs): # noqa: E501 + """Create a new storage unit. # noqa: E501 + + Create a new storage unit. Requires permission to manage inventory locations. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_storage_unit(body, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param StorageUnitsBody body: Parameters for creating a storage unit. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_storage_unit_with_http_info(body, **kwargs) # noqa: E501 + else: + (data) = self.post_storage_unit_with_http_info(body, **kwargs) # noqa: E501 + return data + + def post_storage_unit_with_http_info(self, body, **kwargs): # noqa: E501 + """Create a new storage unit. # noqa: E501 + + Create a new storage unit. Requires permission to manage inventory locations. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_storage_unit_with_http_info(body, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param StorageUnitsBody body: Parameters for creating a storage unit. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_storage_unit" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'body' is set + if ('body' not in params or + params['body'] is None): + raise ValueError("Missing the required parameter `body` when calling `post_storage_unit`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/storage_units', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_storage_unit(self, id, **kwargs): # noqa: E501 + """Read a storage unit. # noqa: E501 + + Get details of a specific storage unit including its full hierarchical path. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_storage_unit(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the storage unit. (required) + :return: StorageUnit + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_storage_unit_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.read_storage_unit_with_http_info(id, **kwargs) # noqa: E501 + return data + + def read_storage_unit_with_http_info(self, id, **kwargs): # noqa: E501 + """Read a storage unit. # noqa: E501 + + Get details of a specific storage unit including its full hierarchical path. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_storage_unit_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the storage unit. (required) + :return: StorageUnit + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_storage_unit" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_storage_unit`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/storage_units/{id}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='StorageUnit', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_storage_units(self, **kwargs): # noqa: E501 + """Read all containers, or the storage unit hierarchy when `?hierarchy=true`. # noqa: E501 + + Without parameters, returns the full list of containers (assignments of experiments or resources to storage locations) that you have access to. With `?hierarchy=true`, returns a flat list of all storage units (freezers, boxes, positions, etc.) with their hierarchy metadata (`id`, `name`, `parent_id`, `full_path`, `level_depth`, `children_count`). This allows clients to discover, traverse, or display the storage unit tree. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_storage_units(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param bool hierarchy: When true, returns a flat list of all storage units in the hierarchy (id, name, parent_id, full_path, level_depth, children_count) instead of the default container assignment list. + :return: InlineResponse200 + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_storage_units_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.read_storage_units_with_http_info(**kwargs) # noqa: E501 + return data + + def read_storage_units_with_http_info(self, **kwargs): # noqa: E501 + """Read all containers, or the storage unit hierarchy when `?hierarchy=true`. # noqa: E501 + + Without parameters, returns the full list of containers (assignments of experiments or resources to storage locations) that you have access to. With `?hierarchy=true`, returns a flat list of all storage units (freezers, boxes, positions, etc.) with their hierarchy metadata (`id`, `name`, `parent_id`, `full_path`, `level_depth`, `children_count`). This allows clients to discover, traverse, or display the storage unit tree. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_storage_units_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param bool hierarchy: When true, returns a flat list of all storage units in the hierarchy (id, name, parent_id, full_path, level_depth, children_count) instead of the default container assignment list. + :return: InlineResponse200 + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['hierarchy'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_storage_units" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'hierarchy' in params: + query_params.append(('hierarchy', params['hierarchy'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/storage_units', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='InlineResponse200', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/tags_api.py b/vendor/elabapi-python/elabapi_python/api/tags_api.py new file mode 100644 index 0000000..72a074d --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/tags_api.py @@ -0,0 +1,572 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class TagsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_tag(self, entity_type, id, **kwargs): # noqa: E501 + """Delete all tags. # noqa: E501 + + All the tags from that entity get removed. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_tag(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_tag_with_http_info(entity_type, id, **kwargs) # noqa: E501 + else: + (data) = self.delete_tag_with_http_info(entity_type, id, **kwargs) # noqa: E501 + return data + + def delete_tag_with_http_info(self, entity_type, id, **kwargs): # noqa: E501 + """Delete all tags. # noqa: E501 + + All the tags from that entity get removed. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_tag_with_http_info(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_tag" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `delete_tag`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_tag`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/tags', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def patch_tag(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Actions on a tag (like removing it from the entity). # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_tag(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the tag (required) + :param TagsSubidBody1 body: Parameters for modifying a tag + :return: Tag + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_tag_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.patch_tag_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def patch_tag_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Actions on a tag (like removing it from the entity). # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_tag_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the tag (required) + :param TagsSubidBody1 body: Parameters for modifying a tag + :return: Tag + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_tag" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `patch_tag`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_tag`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `patch_tag`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/tags/{subid}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Tag', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_tag(self, entity_type, id, **kwargs): # noqa: E501 + """Create a tag. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_tag(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param IdTagsBody1 body: Parameters for creating a tag. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_tag_with_http_info(entity_type, id, **kwargs) # noqa: E501 + else: + (data) = self.post_tag_with_http_info(entity_type, id, **kwargs) # noqa: E501 + return data + + def post_tag_with_http_info(self, entity_type, id, **kwargs): # noqa: E501 + """Create a tag. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_tag_with_http_info(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param IdTagsBody1 body: Parameters for creating a tag. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_tag" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `post_tag`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_tag`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/tags', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_tag(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Read a tag. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_tag(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the tag (required) + :return: Tag + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_tag_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.read_tag_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def read_tag_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Read a tag. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_tag_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the tag (required) + :return: Tag + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_tag" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `read_tag`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_tag`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `read_tag`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/tags/{subid}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Tag', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_tags(self, entity_type, id, **kwargs): # noqa: E501 + """Read all tags of that entity. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_tags(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :return: list[Tag] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_tags_with_http_info(entity_type, id, **kwargs) # noqa: E501 + else: + (data) = self.read_tags_with_http_info(entity_type, id, **kwargs) # noqa: E501 + return data + + def read_tags_with_http_info(self, entity_type, id, **kwargs): # noqa: E501 + """Read all tags of that entity. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_tags_with_http_info(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :return: list[Tag] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_tags" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `read_tags`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_tags`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/tags', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Tag]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/team_tags_api.py b/vendor/elabapi-python/elabapi_python/api/team_tags_api.py new file mode 100644 index 0000000..c519fb3 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/team_tags_api.py @@ -0,0 +1,538 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class TeamTagsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_team_tag(self, id, subid, **kwargs): # noqa: E501 + """Delete a tag. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_team_tag(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the tag. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_team_tag_with_http_info(id, subid, **kwargs) # noqa: E501 + else: + (data) = self.delete_team_tag_with_http_info(id, subid, **kwargs) # noqa: E501 + return data + + def delete_team_tag_with_http_info(self, id, subid, **kwargs): # noqa: E501 + """Delete a tag. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_team_tag_with_http_info(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the tag. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_team_tag" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_team_tag`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `delete_team_tag`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/tags/{subid}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def patch_team_tag(self, id, subid, **kwargs): # noqa: E501 + """Actions on a tag. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_team_tag(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the tag. (required) + :param TagsSubidBody body: Parameters for modifying a tag. + :return: Tag + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_team_tag_with_http_info(id, subid, **kwargs) # noqa: E501 + else: + (data) = self.patch_team_tag_with_http_info(id, subid, **kwargs) # noqa: E501 + return data + + def patch_team_tag_with_http_info(self, id, subid, **kwargs): # noqa: E501 + """Actions on a tag. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_team_tag_with_http_info(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the tag. (required) + :param TagsSubidBody body: Parameters for modifying a tag. + :return: Tag + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'subid', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_team_tag" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_team_tag`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `patch_team_tag`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/tags/{subid}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Tag', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_team_tag(self, id, **kwargs): # noqa: E501 + """Create a tag in the team. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_team_tag(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param IdTagsBody body: Parameters for adding a tag in the team. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_team_tag_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.post_team_tag_with_http_info(id, **kwargs) # noqa: E501 + return data + + def post_team_tag_with_http_info(self, id, **kwargs): # noqa: E501 + """Create a tag in the team. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_team_tag_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param IdTagsBody body: Parameters for adding a tag in the team. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_team_tag" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_team_tag`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/tags', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_team_tag(self, id, subid, **kwargs): # noqa: E501 + """Read a tag. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_tag(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the tag. (required) + :return: Tag + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_team_tag_with_http_info(id, subid, **kwargs) # noqa: E501 + else: + (data) = self.read_team_tag_with_http_info(id, subid, **kwargs) # noqa: E501 + return data + + def read_team_tag_with_http_info(self, id, subid, **kwargs): # noqa: E501 + """Read a tag. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_tag_with_http_info(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the tag. (required) + :return: Tag + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_team_tag" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_team_tag`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `read_team_tag`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/tags/{subid}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Tag', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_team_tags(self, id, **kwargs): # noqa: E501 + """Read all tags for the team. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_tags(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :return: list[Tag] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_team_tags_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.read_team_tags_with_http_info(id, **kwargs) # noqa: E501 + return data + + def read_team_tags_with_http_info(self, id, **kwargs): # noqa: E501 + """Read all tags for the team. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_tags_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :return: list[Tag] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_team_tags" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_team_tags`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/tags', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Tag]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/teamgroups_api.py b/vendor/elabapi-python/elabapi_python/api/teamgroups_api.py new file mode 100644 index 0000000..bf50a1d --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/teamgroups_api.py @@ -0,0 +1,538 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class TeamgroupsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_teamgroup(self, id, subid, **kwargs): # noqa: E501 + """Delete a teamgroup. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_teamgroup(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the teamgroup. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_teamgroup_with_http_info(id, subid, **kwargs) # noqa: E501 + else: + (data) = self.delete_teamgroup_with_http_info(id, subid, **kwargs) # noqa: E501 + return data + + def delete_teamgroup_with_http_info(self, id, subid, **kwargs): # noqa: E501 + """Delete a teamgroup. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_teamgroup_with_http_info(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the teamgroup. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_teamgroup" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_teamgroup`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `delete_teamgroup`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/teamgroups/{subid}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def patch_teamgroup(self, id, subid, **kwargs): # noqa: E501 + """Modify a teamgroup. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_teamgroup(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the teamgroup. (required) + :param TeamgroupsSubidBody body: Parameters for modifying a teamgroup. + :return: Teamgroup + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_teamgroup_with_http_info(id, subid, **kwargs) # noqa: E501 + else: + (data) = self.patch_teamgroup_with_http_info(id, subid, **kwargs) # noqa: E501 + return data + + def patch_teamgroup_with_http_info(self, id, subid, **kwargs): # noqa: E501 + """Modify a teamgroup. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_teamgroup_with_http_info(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the teamgroup. (required) + :param TeamgroupsSubidBody body: Parameters for modifying a teamgroup. + :return: Teamgroup + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'subid', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_teamgroup" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_teamgroup`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `patch_teamgroup`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/teamgroups/{subid}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Teamgroup', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_teamgroups(self, id, **kwargs): # noqa: E501 + """Create a new teamgroup. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_teamgroups(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param IdTeamgroupsBody body: Parameters for creating a teamgroup. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_teamgroups_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.post_teamgroups_with_http_info(id, **kwargs) # noqa: E501 + return data + + def post_teamgroups_with_http_info(self, id, **kwargs): # noqa: E501 + """Create a new teamgroup. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_teamgroups_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param IdTeamgroupsBody body: Parameters for creating a teamgroup. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_teamgroups" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_teamgroups`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/teamgroups', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_team_teamgroups(self, id, **kwargs): # noqa: E501 + """Read teamgroups of a team. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_teamgroups(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :return: dict(str, Teamgroup) + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_team_teamgroups_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.read_team_teamgroups_with_http_info(id, **kwargs) # noqa: E501 + return data + + def read_team_teamgroups_with_http_info(self, id, **kwargs): # noqa: E501 + """Read teamgroups of a team. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_teamgroups_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :return: dict(str, Teamgroup) + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_team_teamgroups" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_team_teamgroups`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/teamgroups', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='dict(str, Teamgroup)', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_teamgroup(self, id, subid, **kwargs): # noqa: E501 + """Read a teamgroup. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_teamgroup(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the teamgroup. (required) + :return: InlineResponse2005 + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_teamgroup_with_http_info(id, subid, **kwargs) # noqa: E501 + else: + (data) = self.read_teamgroup_with_http_info(id, subid, **kwargs) # noqa: E501 + return data + + def read_teamgroup_with_http_info(self, id, subid, **kwargs): # noqa: E501 + """Read a teamgroup. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_teamgroup_with_http_info(id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the team. (required) + :param int subid: ID of the teamgroup. (required) + :return: InlineResponse2005 + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_teamgroup" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_teamgroup`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `read_teamgroup`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}/teamgroups/{subid}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='InlineResponse2005', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/teams_api.py b/vendor/elabapi-python/elabapi_python/api/teams_api.py new file mode 100644 index 0000000..61f708a --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/teams_api.py @@ -0,0 +1,405 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class TeamsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def patch_team(self, id, **kwargs): # noqa: E501 + """Actions on a team. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_team(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param Id id: ID of the team or `current`. (required) + :param TeamsIdBody body: Parameters for modifying a team. + :return: Team + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_team_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.patch_team_with_http_info(id, **kwargs) # noqa: E501 + return data + + def patch_team_with_http_info(self, id, **kwargs): # noqa: E501 + """Actions on a team. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_team_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param Id id: ID of the team or `current`. (required) + :param TeamsIdBody body: Parameters for modifying a team. + :return: Team + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_team" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_team`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Team', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_teams(self, **kwargs): # noqa: E501 + """Create a new team. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_teams(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param TeamsBody body: Parameters for creating a new team. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_teams_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.post_teams_with_http_info(**kwargs) # noqa: E501 + return data + + def post_teams_with_http_info(self, **kwargs): # noqa: E501 + """Create a new team. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_teams_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param TeamsBody body: Parameters for creating a new team. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_teams" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_team(self, id, **kwargs): # noqa: E501 + """Read a team. Requires Admin permissions. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param Id id: ID of the team or `current`. (required) + :return: Team + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_team_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.read_team_with_http_info(id, **kwargs) # noqa: E501 + return data + + def read_team_with_http_info(self, id, **kwargs): # noqa: E501 + """Read a team. Requires Admin permissions. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_team_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param Id id: ID of the team or `current`. (required) + :return: Team + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_team" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_team`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams/{id}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Team', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_teams(self, **kwargs): # noqa: E501 + """Read all teams. Requires Sysadmin permissions. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_teams(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[Team] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_teams_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.read_teams_with_http_info(**kwargs) # noqa: E501 + return data + + def read_teams_with_http_info(self, **kwargs): # noqa: E501 + """Read all teams. Requires Sysadmin permissions. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_teams_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[Team] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_teams" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/teams', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Team]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/todolist_api.py b/vendor/elabapi-python/elabapi_python/api/todolist_api.py new file mode 100644 index 0000000..b2b3cec --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/todolist_api.py @@ -0,0 +1,498 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class TodolistApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_todoitem(self, id, **kwargs): # noqa: E501 + """Delete a todoitem. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_todoitem(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the todoitem. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_todoitem_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.delete_todoitem_with_http_info(id, **kwargs) # noqa: E501 + return data + + def delete_todoitem_with_http_info(self, id, **kwargs): # noqa: E501 + """Delete a todoitem. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_todoitem_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the todoitem. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_todoitem" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_todoitem`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/todolist/{id}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def patch_todoitem(self, id, **kwargs): # noqa: E501 + """Actions on a todoitem. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_todoitem(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the todoitem. (required) + :param TodolistIdBody body: Parameters for modifying a todoitem. + :return: Todoitem + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_todoitem_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.patch_todoitem_with_http_info(id, **kwargs) # noqa: E501 + return data + + def patch_todoitem_with_http_info(self, id, **kwargs): # noqa: E501 + """Actions on a todoitem. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_todoitem_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the todoitem. (required) + :param TodolistIdBody body: Parameters for modifying a todoitem. + :return: Todoitem + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_todoitem" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_todoitem`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/todolist/{id}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Todoitem', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_todolist(self, **kwargs): # noqa: E501 + """Create a todo item # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_todolist(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param TodolistBody body: Parameters for creating a todoitem. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_todolist_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.post_todolist_with_http_info(**kwargs) # noqa: E501 + return data + + def post_todolist_with_http_info(self, **kwargs): # noqa: E501 + """Create a todo item # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_todolist_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param TodolistBody body: Parameters for creating a todoitem. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_todolist" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/todolist', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_todoitem(self, id, **kwargs): # noqa: E501 + """Read a todo entry. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_todoitem(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the todoitem. (required) + :return: Todoitem + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_todoitem_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.read_todoitem_with_http_info(id, **kwargs) # noqa: E501 + return data + + def read_todoitem_with_http_info(self, id, **kwargs): # noqa: E501 + """Read a todo entry. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_todoitem_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int id: ID of the todoitem. (required) + :return: Todoitem + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_todoitem" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_todoitem`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/todolist/{id}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Todoitem', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_todolist(self, **kwargs): # noqa: E501 + """Read all todoitems. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_todolist(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[Todoitem] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_todolist_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.read_todolist_with_http_info(**kwargs) # noqa: E501 + return data + + def read_todolist_with_http_info(self, **kwargs): # noqa: E501 + """Read all todoitems. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_todolist_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[Todoitem] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_todolist" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/todolist', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Todoitem]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/unfinished_steps_api.py b/vendor/elabapi-python/elabapi_python/api/unfinished_steps_api.py new file mode 100644 index 0000000..46a06b1 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/unfinished_steps_api.py @@ -0,0 +1,122 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class UnfinishedStepsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def read_unfinished_steps(self, **kwargs): # noqa: E501 + """Read all unfinished steps. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_unfinished_steps(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str scope: Set to \"team\" to extend the list to other members. + :return: list[UnfinishedSteps] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_unfinished_steps_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.read_unfinished_steps_with_http_info(**kwargs) # noqa: E501 + return data + + def read_unfinished_steps_with_http_info(self, **kwargs): # noqa: E501 + """Read all unfinished steps. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_unfinished_steps_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str scope: Set to \"team\" to extend the list to other members. + :return: list[UnfinishedSteps] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['scope'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_unfinished_steps" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'scope' in params: + query_params.append(('scope', params['scope'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/unfinished_steps', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[UnfinishedSteps]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/uploads_api.py b/vendor/elabapi-python/elabapi_python/api/uploads_api.py new file mode 100644 index 0000000..8a9be37 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/uploads_api.py @@ -0,0 +1,717 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class UploadsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def delete_upload(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Delete an upload. # noqa: E501 + + The upload gets deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_upload(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the upload (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.delete_upload_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.delete_upload_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def delete_upload_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Delete an upload. # noqa: E501 + + The upload gets deleted. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_upload_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the upload (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method delete_upload" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `delete_upload`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `delete_upload`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `delete_upload`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/uploads/{subid}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def patch_upload(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Modify attributes such as \"real_name\", \"comment\" or \"state\" of an upload. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_upload(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the upload (required) + :param UploadsSubidBody1 body: Parameters for modifying an upload attributes. + :return: Upload + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_upload_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.patch_upload_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def patch_upload_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Modify attributes such as \"real_name\", \"comment\" or \"state\" of an upload. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_upload_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the upload (required) + :param UploadsSubidBody1 body: Parameters for modifying an upload attributes. + :return: Upload + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_upload" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `patch_upload`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_upload`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `patch_upload`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/uploads/{subid}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Upload', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_upload(self, entity_type, id, **kwargs): # noqa: E501 + """Create an upload. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_upload(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param str file: + :param str comment: + :param str state: Filter results based on their state: 1 (Normal), 2 (Archived), 3 (Deleted). Supports comma separated values. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_upload_with_http_info(entity_type, id, **kwargs) # noqa: E501 + else: + (data) = self.post_upload_with_http_info(entity_type, id, **kwargs) # noqa: E501 + return data + + def post_upload_with_http_info(self, entity_type, id, **kwargs): # noqa: E501 + """Create an upload. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_upload_with_http_info(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param str file: + :param str comment: + :param str state: Filter results based on their state: 1 (Normal), 2 (Archived), 3 (Deleted). Supports comma separated values. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'file', 'comment', 'state'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_upload" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `post_upload`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_upload`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + if 'state' in params: + query_params.append(('state', params['state'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + if 'file' in params: + local_var_files['file'] = params['file'] # noqa: E501 + if 'comment' in params: + form_params.append(('comment', params['comment'])) # noqa: E501 + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['multipart/form-data']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/uploads', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_upload_replace(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Replace an existing uploaded file. The existing file will be archived and the new one will be added. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_upload_replace(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the upload (required) + :param str file: + :param str comment: + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_upload_replace_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.post_upload_replace_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def post_upload_replace_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Replace an existing uploaded file. The existing file will be archived and the new one will be added. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_upload_replace_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the upload (required) + :param str file: + :param str comment: + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid', 'file', 'comment'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_upload_replace" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `post_upload_replace`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `post_upload_replace`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `post_upload_replace`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + if 'file' in params: + local_var_files['file'] = params['file'] # noqa: E501 + if 'comment' in params: + form_params.append(('comment', params['comment'])) # noqa: E501 + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['multipart/form-data']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/uploads/{subid}', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_upload(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Read an upload. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_upload(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the upload (required) + :param str format: To download the file itself, use `binary` format parameter. In python library, when downloading a file content, make sure to add ` _preload_content=False` into the call to `read_upload()`. + :return: Upload + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_upload_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + else: + (data) = self.read_upload_with_http_info(entity_type, id, subid, **kwargs) # noqa: E501 + return data + + def read_upload_with_http_info(self, entity_type, id, subid, **kwargs): # noqa: E501 + """Read an upload. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_upload_with_http_info(entity_type, id, subid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param int subid: ID of the upload (required) + :param str format: To download the file itself, use `binary` format parameter. In python library, when downloading a file content, make sure to add ` _preload_content=False` into the call to `read_upload()`. + :return: Upload + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'subid', 'format'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_upload" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `read_upload`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_upload`") # noqa: E501 + # verify the required parameter 'subid' is set + if ('subid' not in params or + params['subid'] is None): + raise ValueError("Missing the required parameter `subid` when calling `read_upload`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + if 'subid' in params: + path_params['subid'] = params['subid'] # noqa: E501 + + query_params = [] + if 'format' in params: + query_params.append(('format', params['format'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json', '*/*']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/uploads/{subid}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Upload', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_uploads(self, entity_type, id, **kwargs): # noqa: E501 + """Read attached files of that entity. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_uploads(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param str state: Filter results based on their state: 1 (Normal), 2 (Archived), 3 (Deleted). Supports comma separated values. + :return: list[Upload] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_uploads_with_http_info(entity_type, id, **kwargs) # noqa: E501 + else: + (data) = self.read_uploads_with_http_info(entity_type, id, **kwargs) # noqa: E501 + return data + + def read_uploads_with_http_info(self, entity_type, id, **kwargs): # noqa: E501 + """Read attached files of that entity. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_uploads_with_http_info(entity_type, id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entity_type: Entity type (required) + :param int id: ID of the entity (required) + :param str state: Filter results based on their state: 1 (Normal), 2 (Archived), 3 (Deleted). Supports comma separated values. + :return: list[Upload] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['entity_type', 'id', 'state'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_uploads" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'entity_type' is set + if ('entity_type' not in params or + params['entity_type'] is None): + raise ValueError("Missing the required parameter `entity_type` when calling `read_uploads`") # noqa: E501 + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_uploads`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'entity_type' in params: + path_params['entity_type'] = params['entity_type'] # noqa: E501 + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + if 'state' in params: + query_params.append(('state', params['state'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/{entity_type}/{id}/uploads', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[Upload]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/user_uploads_api.py b/vendor/elabapi-python/elabapi_python/api/user_uploads_api.py new file mode 100644 index 0000000..82d1cc6 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/user_uploads_api.py @@ -0,0 +1,126 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class UserUploadsApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def read_user_uploads(self, id, **kwargs): # noqa: E501 + """Read attached files from a user # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_user_uploads(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param Id2 id: ID of the user or `me`. (required) + :return: list[InlineResponse2006] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_user_uploads_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.read_user_uploads_with_http_info(id, **kwargs) # noqa: E501 + return data + + def read_user_uploads_with_http_info(self, id, **kwargs): # noqa: E501 + """Read attached files from a user # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_user_uploads_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param Id2 id: ID of the user or `me`. (required) + :return: list[InlineResponse2006] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_user_uploads" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_user_uploads`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/users/{id}/uploads', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[InlineResponse2006]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api/users_api.py b/vendor/elabapi-python/elabapi_python/api/users_api.py new file mode 100644 index 0000000..62ea4c0 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api/users_api.py @@ -0,0 +1,429 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from elabapi_python.api_client import ApiClient + + +class UsersApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def patch_user(self, id, **kwargs): # noqa: E501 + """Modify a user. # noqa: E501 + + Note: it is possible to use \"me\" instead of the userid to access the user of the API key. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_user(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param Id1 id: ID of the user or `me`. (required) + :param UsersIdBody body: Parameters for modifying a user. + :return: Users + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.patch_user_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.patch_user_with_http_info(id, **kwargs) # noqa: E501 + return data + + def patch_user_with_http_info(self, id, **kwargs): # noqa: E501 + """Modify a user. # noqa: E501 + + Note: it is possible to use \"me\" instead of the userid to access the user of the API key. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.patch_user_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param Id1 id: ID of the user or `me`. (required) + :param UsersIdBody body: Parameters for modifying a user. + :return: Users + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id', 'body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method patch_user" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `patch_user`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/users/{id}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Users', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def post_user(self, **kwargs): # noqa: E501 + """Create a new user. # noqa: E501 + + An Admin can create a user in its own team only. A sysadmin can specify the team. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_user(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param UsersBody body: Parameters for creating a user. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.post_user_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.post_user_with_http_info(**kwargs) # noqa: E501 + return data + + def post_user_with_http_info(self, **kwargs): # noqa: E501 + """Create a new user. # noqa: E501 + + An Admin can create a user in its own team only. A sysadmin can specify the team. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_user_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param UsersBody body: Parameters for creating a user. + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['body'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_user" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in params: + body_params = params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/users', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_user(self, id, **kwargs): # noqa: E501 + """Read information of a user. # noqa: E501 + + Note: it is possible to use \"me\" instead of the userid to access the user of the API key. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_user(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param Id1 id: ID of the user or `me`. (required) + :return: Users + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_user_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.read_user_with_http_info(id, **kwargs) # noqa: E501 + return data + + def read_user_with_http_info(self, id, **kwargs): # noqa: E501 + """Read information of a user. # noqa: E501 + + Note: it is possible to use \"me\" instead of the userid to access the user of the API key. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_user_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param Id1 id: ID of the user or `me`. (required) + :return: Users + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_user" % key + ) + params[key] = val + del params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in params or + params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `read_user`") # noqa: E501 + + collection_formats = {} + + path_params = {} + if 'id' in params: + path_params['id'] = params['id'] # noqa: E501 + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/users/{id}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='Users', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def read_users(self, **kwargs): # noqa: E501 + """Read users from instance. # noqa: E501 + + Get a list of users with an active account on the instance. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_users(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int team: Add a filter on the team + :param int current_team: If set to 1, use the requester's current team as filter. + :param bool only_admins: Return only team admins. + :param bool only_archived: Return only archived users. + :return: list[object] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.read_users_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.read_users_with_http_info(**kwargs) # noqa: E501 + return data + + def read_users_with_http_info(self, **kwargs): # noqa: E501 + """Read users from instance. # noqa: E501 + + Get a list of users with an active account on the instance. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_users_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int team: Add a filter on the team + :param int current_team: If set to 1, use the requester's current team as filter. + :param bool only_admins: Return only team admins. + :param bool only_archived: Return only archived users. + :return: list[object] + If the method is called asynchronously, + returns the request thread. + """ + + all_params = ['team', 'current_team', 'only_admins', 'only_archived'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method read_users" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'team' in params: + query_params.append(('team', params['team'])) # noqa: E501 + if 'current_team' in params: + query_params.append(('currentTeam', params['current_team'])) # noqa: E501 + if 'only_admins' in params: + query_params.append(('onlyAdmins', params['only_admins'])) # noqa: E501 + if 'only_archived' in params: + query_params.append(('onlyArchived', params['only_archived'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['token'] # noqa: E501 + + return self.api_client.call_api( + '/users', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[object]', # noqa: E501 + auth_settings=auth_settings, + async_req=params.get('async_req'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/vendor/elabapi-python/elabapi_python/api_client.py b/vendor/elabapi-python/elabapi_python/api_client.py new file mode 100644 index 0000000..681e233 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/api_client.py @@ -0,0 +1,632 @@ +# coding: utf-8 +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" +from __future__ import absolute_import + +import datetime +import json +import mimetypes +from multiprocessing.pool import ThreadPool +import os +import re +import tempfile + +# python 2 and python 3 compatibility library +import six +from six.moves.urllib.parse import quote + +from elabapi_python.configuration import Configuration +import elabapi_python.models +from elabapi_python import rest + + +class ApiClient(object): + """Generic API client for Swagger client library builds. + + Swagger generic API client. This client handles the client- + server communication, and is invariant across implementations. Specifics of + the methods and models for each application are generated from the Swagger + templates. + + NOTE: This class is auto generated by the swagger code generator program. + Ref: https://github.com/swagger-api/swagger-codegen + Do not edit the class manually. + + :param configuration: .Configuration object for this client + :param header_name: a header to pass when making calls to the API. + :param header_value: a header value to pass when making calls to + the API. + :param cookie: a cookie to include in the header when making calls + to the API + """ + + PRIMITIVE_TYPES = (float, bool, bytes, six.text_type) + six.integer_types + NATIVE_TYPES_MAPPING = { + 'int': int, + 'long': int if six.PY3 else long, # noqa: F821 + 'float': float, + 'str': str, + 'bool': bool, + 'date': datetime.date, + 'datetime': datetime.datetime, + 'object': object, + } + + def __init__(self, configuration=None, header_name=None, header_value=None, + cookie=None): + if configuration is None: + configuration = Configuration() + self.configuration = configuration + + self.pool = ThreadPool() + self.rest_client = rest.RESTClientObject(configuration) + self.default_headers = {} + if header_name is not None: + self.default_headers[header_name] = header_value + self.cookie = cookie + # Set default User-Agent. + self.user_agent = 'Swagger-Codegen/5.6.1/python' + + def __del__(self): + self.pool.close() + self.pool.join() + + @property + def user_agent(self): + """User agent for this API client""" + return self.default_headers['User-Agent'] + + @user_agent.setter + def user_agent(self, value): + self.default_headers['User-Agent'] = value + + def set_default_header(self, header_name, header_value): + self.default_headers[header_name] = header_value + + def __call_api( + self, resource_path, method, path_params=None, + query_params=None, header_params=None, body=None, post_params=None, + files=None, response_type=None, auth_settings=None, + _return_http_data_only=None, collection_formats=None, + _preload_content=True, _request_timeout=None): + + config = self.configuration + + # header parameters + header_params = header_params or {} + header_params.update(self.default_headers) + if self.cookie: + header_params['Cookie'] = self.cookie + if header_params: + header_params = self.sanitize_for_serialization(header_params) + header_params = dict(self.parameters_to_tuples(header_params, + collection_formats)) + + # path parameters + if path_params: + path_params = self.sanitize_for_serialization(path_params) + path_params = self.parameters_to_tuples(path_params, + collection_formats) + for k, v in path_params: + # specified safe chars, encode everything + resource_path = resource_path.replace( + '{%s}' % k, + quote(str(v), safe=config.safe_chars_for_path_param) + ) + + # query parameters + if query_params: + query_params = self.sanitize_for_serialization(query_params) + query_params = self.parameters_to_tuples(query_params, + collection_formats) + + # post parameters + if post_params or files: + post_params = self.prepare_post_parameters(post_params, files) + post_params = self.sanitize_for_serialization(post_params) + post_params = self.parameters_to_tuples(post_params, + collection_formats) + + # auth setting + self.update_params_for_auth(header_params, query_params, auth_settings) + + # body + if body: + body = self.sanitize_for_serialization(body) + + # request url + url = self.configuration.host + resource_path + + # perform request and return response + response_data = self.request( + method, url, query_params=query_params, headers=header_params, + post_params=post_params, body=body, + _preload_content=_preload_content, + _request_timeout=_request_timeout) + + self.last_response = response_data + + return_data = response_data + if _preload_content: + # deserialize response data + if response_type: + return_data = self.deserialize(response_data, response_type) + else: + return_data = None + + if _return_http_data_only: + return (return_data) + else: + return (return_data, response_data.status, + response_data.getheaders()) + + def sanitize_for_serialization(self, obj): + """Builds a JSON POST object. + + If obj is None, return None. + If obj is str, int, long, float, bool, return directly. + If obj is datetime.datetime, datetime.date + convert to string in iso8601 format. + If obj is list, sanitize each element in the list. + If obj is dict, return the dict. + If obj is swagger model, return the properties dict. + + :param obj: The data to serialize. + :return: The serialized form of data. + """ + if obj is None: + return None + elif isinstance(obj, self.PRIMITIVE_TYPES): + return obj + elif isinstance(obj, list): + return [self.sanitize_for_serialization(sub_obj) + for sub_obj in obj] + elif isinstance(obj, tuple): + return tuple(self.sanitize_for_serialization(sub_obj) + for sub_obj in obj) + elif isinstance(obj, (datetime.datetime, datetime.date)): + return obj.isoformat() + + if isinstance(obj, dict): + obj_dict = obj + else: + # Convert model obj to dict except + # attributes `swagger_types`, `attribute_map` + # and attributes which value is not None. + # Convert attribute name to json key in + # model definition for request. + obj_dict = {obj.attribute_map[attr]: getattr(obj, attr) + for attr, _ in six.iteritems(obj.swagger_types) + if getattr(obj, attr) is not None} + + return {key: self.sanitize_for_serialization(val) + for key, val in six.iteritems(obj_dict)} + + def deserialize(self, response, response_type): + """Deserializes response into an object. + + :param response: RESTResponse object to be deserialized. + :param response_type: class literal for + deserialized object, or string of class name. + + :return: deserialized object. + """ + # handle file downloading + # save response body into a tmp file and return the instance + if response_type == "file": + return self.__deserialize_file(response) + + # fetch data from response object + try: + data = json.loads(response.data) + except ValueError: + data = response.data + + return self.__deserialize(data, response_type) + + def __deserialize(self, data, klass): + """Deserializes dict, list, str into an object. + + :param data: dict, list or str. + :param klass: class literal, or string of class name. + + :return: object. + """ + if data is None: + return None + + if type(klass) == str: + if klass.startswith('list['): + sub_kls = re.match(r'list\[(.*)\]', klass).group(1) + return [self.__deserialize(sub_data, sub_kls) + for sub_data in data] + + if klass.startswith('dict('): + sub_kls = re.match(r'dict\(([^,]*), (.*)\)', klass).group(2) + return {k: self.__deserialize(v, sub_kls) + for k, v in six.iteritems(data)} + + # convert str to class + if klass in self.NATIVE_TYPES_MAPPING: + klass = self.NATIVE_TYPES_MAPPING[klass] + else: + klass = getattr(elabapi_python.models, klass) + + if klass in self.PRIMITIVE_TYPES: + return self.__deserialize_primitive(data, klass) + elif klass == object: + return self.__deserialize_object(data) + elif klass == datetime.date: + return self.__deserialize_date(data) + elif klass == datetime.datetime: + return self.__deserialize_datatime(data) + else: + return self.__deserialize_model(data, klass) + + def call_api(self, resource_path, method, + path_params=None, query_params=None, header_params=None, + body=None, post_params=None, files=None, + response_type=None, auth_settings=None, async_req=None, + _return_http_data_only=None, collection_formats=None, + _preload_content=True, _request_timeout=None): + """Makes the HTTP request (synchronous) and returns deserialized data. + + To make an async request, set the async_req parameter. + + :param resource_path: Path to method endpoint. + :param method: Method to call. + :param path_params: Path parameters in the url. + :param query_params: Query parameters in the url. + :param header_params: Header parameters to be + placed in the request header. + :param body: Request body. + :param post_params dict: Request post form parameters, + for `application/x-www-form-urlencoded`, `multipart/form-data`. + :param auth_settings list: Auth Settings names for the request. + :param response: Response data type. + :param files dict: key -> filename, value -> filepath, + for `multipart/form-data`. + :param async_req bool: execute request asynchronously + :param _return_http_data_only: response data without head status code + and headers + :param collection_formats: dict of collection formats for path, query, + header, and post parameters. + :param _preload_content: if False, the urllib3.HTTPResponse object will + be returned without reading/decoding response + data. Default is True. + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :return: + If async_req parameter is True, + the request will be called asynchronously. + The method will return the request thread. + If parameter async_req is False or missing, + then the method will return the response directly. + """ + if not async_req: + return self.__call_api(resource_path, method, + path_params, query_params, header_params, + body, post_params, files, + response_type, auth_settings, + _return_http_data_only, collection_formats, + _preload_content, _request_timeout) + else: + thread = self.pool.apply_async(self.__call_api, (resource_path, + method, path_params, query_params, + header_params, body, + post_params, files, + response_type, auth_settings, + _return_http_data_only, + collection_formats, + _preload_content, _request_timeout)) + return thread + + def request(self, method, url, query_params=None, headers=None, + post_params=None, body=None, _preload_content=True, + _request_timeout=None): + """Makes the HTTP request using RESTClient.""" + if method == "GET": + return self.rest_client.GET(url, + query_params=query_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + headers=headers) + elif method == "HEAD": + return self.rest_client.HEAD(url, + query_params=query_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + headers=headers) + elif method == "OPTIONS": + return self.rest_client.OPTIONS(url, + query_params=query_params, + headers=headers, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + elif method == "POST": + return self.rest_client.POST(url, + query_params=query_params, + headers=headers, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + elif method == "PUT": + return self.rest_client.PUT(url, + query_params=query_params, + headers=headers, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + elif method == "PATCH": + return self.rest_client.PATCH(url, + query_params=query_params, + headers=headers, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + elif method == "DELETE": + return self.rest_client.DELETE(url, + query_params=query_params, + headers=headers, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + else: + raise ValueError( + "http method must be `GET`, `HEAD`, `OPTIONS`," + " `POST`, `PATCH`, `PUT` or `DELETE`." + ) + + def parameters_to_tuples(self, params, collection_formats): + """Get parameters as list of tuples, formatting collections. + + :param params: Parameters as dict or list of two-tuples + :param dict collection_formats: Parameter collection formats + :return: Parameters as list of tuples, collections formatted + """ + new_params = [] + if collection_formats is None: + collection_formats = {} + for k, v in six.iteritems(params) if isinstance(params, dict) else params: # noqa: E501 + if k in collection_formats: + collection_format = collection_formats[k] + if collection_format == 'multi': + new_params.extend((k, value) for value in v) + else: + if collection_format == 'ssv': + delimiter = ' ' + elif collection_format == 'tsv': + delimiter = '\t' + elif collection_format == 'pipes': + delimiter = '|' + else: # csv is the default + delimiter = ',' + new_params.append( + (k, delimiter.join(str(value) for value in v))) + else: + new_params.append((k, v)) + return new_params + + def prepare_post_parameters(self, post_params=None, files=None): + """Builds form parameters. + + :param post_params: Normal form parameters. + :param files: File parameters. + :return: Form parameters with files. + """ + params = [] + + if post_params: + params = post_params + + if files: + for k, v in six.iteritems(files): + if not v: + continue + file_names = v if type(v) is list else [v] + for n in file_names: + with open(n, 'rb') as f: + filename = os.path.basename(f.name) + filedata = f.read() + mimetype = (mimetypes.guess_type(filename)[0] or + 'application/octet-stream') + params.append( + tuple([k, tuple([filename, filedata, mimetype])])) + + return params + + def select_header_accept(self, accepts): + """Returns `Accept` based on an array of accepts provided. + + :param accepts: List of headers. + :return: Accept (e.g. application/json). + """ + if not accepts: + return + + accepts = [x.lower() for x in accepts] + + if 'application/json' in accepts: + return 'application/json' + else: + return ', '.join(accepts) + + def select_header_content_type(self, content_types): + """Returns `Content-Type` based on an array of content_types provided. + + :param content_types: List of content-types. + :return: Content-Type (e.g. application/json). + """ + if not content_types: + return 'application/json' + + content_types = [x.lower() for x in content_types] + + if 'application/json' in content_types or '*/*' in content_types: + return 'application/json' + else: + return content_types[0] + + def update_params_for_auth(self, headers, querys, auth_settings): + """Updates header and query params based on authentication setting. + + :param headers: Header parameters dict to be updated. + :param querys: Query parameters tuple list to be updated. + :param auth_settings: Authentication setting identifiers list. + """ + if not auth_settings: + return + + for auth in auth_settings: + auth_setting = self.configuration.auth_settings().get(auth) + if auth_setting: + if not auth_setting['value']: + continue + elif auth_setting['in'] == 'header': + headers[auth_setting['key']] = auth_setting['value'] + elif auth_setting['in'] == 'query': + querys.append((auth_setting['key'], auth_setting['value'])) + else: + raise ValueError( + 'Authentication token must be in `query` or `header`' + ) + + def __deserialize_file(self, response): + """Deserializes body to file + + Saves response body into a file in a temporary folder, + using the filename from the `Content-Disposition` header if provided. + + :param response: RESTResponse. + :return: file path. + """ + fd, path = tempfile.mkstemp(dir=self.configuration.temp_folder_path) + os.close(fd) + os.remove(path) + + content_disposition = response.getheader("Content-Disposition") + if content_disposition: + filename = re.search(r'filename=[\'"]?([^\'"\s]+)[\'"]?', + content_disposition).group(1) + path = os.path.join(os.path.dirname(path), filename) + response_data = response.data + with open(path, "wb") as f: + if isinstance(response_data, str): + # change str to bytes so we can write it + response_data = response_data.encode('utf-8') + f.write(response_data) + else: + f.write(response_data) + return path + + def __deserialize_primitive(self, data, klass): + """Deserializes string to primitive type. + + :param data: str. + :param klass: class literal. + + :return: int, long, float, str, bool. + """ + try: + return klass(data) + except UnicodeEncodeError: + return six.text_type(data) + except TypeError: + return data + + def __deserialize_object(self, value): + """Return a original value. + + :return: object. + """ + return value + + def __deserialize_date(self, string): + """Deserializes string to date. + + :param string: str. + :return: date. + """ + try: + from dateutil.parser import parse + return parse(string).date() + except ImportError: + return string + except ValueError: + raise rest.ApiException( + status=0, + reason="Failed to parse `{0}` as date object".format(string) + ) + + def __deserialize_datatime(self, string): + """Deserializes string to datetime. + + The string should be in iso8601 datetime format. + + :param string: str. + :return: datetime. + """ + try: + from dateutil.parser import parse + return parse(string) + except ImportError: + return string + except ValueError: + raise rest.ApiException( + status=0, + reason=( + "Failed to parse `{0}` as datetime object" + .format(string) + ) + ) + + def __hasattr(self, object, name): + return name in object.__class__.__dict__ + + def __deserialize_model(self, data, klass): + """Deserializes list or dict to model. + + :param data: dict, list. + :param klass: class literal. + :return: model object. + """ + + if not klass.swagger_types and not self.__hasattr(klass, 'get_real_child_model'): + return data + + kwargs = {} + if klass.swagger_types is not None: + for attr, attr_type in six.iteritems(klass.swagger_types): + if (data is not None and + klass.attribute_map[attr] in data and + isinstance(data, (list, dict))): + value = data[klass.attribute_map[attr]] + kwargs[attr] = self.__deserialize(value, attr_type) + + instance = klass(**kwargs) + + if (isinstance(instance, dict) and + klass.swagger_types is not None and + isinstance(data, dict)): + for key, value in data.items(): + if key not in klass.swagger_types: + instance[key] = value + if self.__hasattr(instance, 'get_real_child_model'): + klass_name = instance.get_real_child_model(data) + if klass_name: + instance = self.__deserialize(data, klass_name) + return instance diff --git a/vendor/elabapi-python/elabapi_python/configuration.py b/vendor/elabapi-python/elabapi_python/configuration.py new file mode 100644 index 0000000..8f5c543 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/configuration.py @@ -0,0 +1,254 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import copy +import logging +import multiprocessing +import sys +import urllib3 + +import six +from six.moves import http_client as httplib + + +class TypeWithDefault(type): + def __init__(cls, name, bases, dct): + super(TypeWithDefault, cls).__init__(name, bases, dct) + cls._default = None + + def __call__(cls): + if cls._default is None: + cls._default = type.__call__(cls) + return copy.copy(cls._default) + + def set_default(cls, default): + cls._default = copy.copy(default) + + +class Configuration(six.with_metaclass(TypeWithDefault, object)): + """NOTE: This class is auto generated by the swagger code generator program. + + Ref: https://github.com/swagger-api/swagger-codegen + Do not edit the class manually. + """ + + def __init__(self): + """Constructor""" + # Default Base url + self.host = "https://elab.local:3148/api/v2" + # Temp file folder for downloading files + self.temp_folder_path = None + + # Authentication Settings + # dict to store API key(s) + self.api_key = {} + # dict to store API prefix (e.g. Bearer) + self.api_key_prefix = {} + # function to refresh API key if expired + self.refresh_api_key_hook = None + # Username for HTTP basic authentication + self.username = "" + # Password for HTTP basic authentication + self.password = "" + # Logging Settings + self.logger = {} + self.logger["package_logger"] = logging.getLogger("elabapi_python") + self.logger["urllib3_logger"] = logging.getLogger("urllib3") + # Log format + self.logger_format = '%(asctime)s %(levelname)s %(message)s' + # Log stream handler + self.logger_stream_handler = None + # Log file handler + self.logger_file_handler = None + # Debug file location + self.logger_file = None + # Debug switch + self.debug = False + + # SSL/TLS verification + # Set this to false to skip verifying SSL certificate when calling API + # from https server. + self.verify_ssl = True + # Set this to customize the certificate file to verify the peer. + self.ssl_ca_cert = None + # client certificate file + self.cert_file = None + # client key file + self.key_file = None + # Set this to True/False to enable/disable SSL hostname verification. + self.assert_hostname = None + + # urllib3 connection pool's maximum number of connections saved + # per pool. urllib3 uses 1 connection as default value, but this is + # not the best value when you are making a lot of possibly parallel + # requests to the same host, which is often the case here. + # cpu_count * 5 is used as default value to increase performance. + self.connection_pool_maxsize = multiprocessing.cpu_count() * 5 + + # Proxy URL + self.proxy = None + # Safe chars for path_param + self.safe_chars_for_path_param = '' + + @property + def logger_file(self): + """The logger file. + + If the logger_file is None, then add stream handler and remove file + handler. Otherwise, add file handler and remove stream handler. + + :param value: The logger_file path. + :type: str + """ + return self.__logger_file + + @logger_file.setter + def logger_file(self, value): + """The logger file. + + If the logger_file is None, then add stream handler and remove file + handler. Otherwise, add file handler and remove stream handler. + + :param value: The logger_file path. + :type: str + """ + self.__logger_file = value + if self.__logger_file: + # If set logging file, + # then add file handler and remove stream handler. + self.logger_file_handler = logging.FileHandler(self.__logger_file) + self.logger_file_handler.setFormatter(self.logger_formatter) + for _, logger in six.iteritems(self.logger): + logger.addHandler(self.logger_file_handler) + if self.logger_stream_handler: + logger.removeHandler(self.logger_stream_handler) + else: + # If not set logging file, + # then add stream handler and remove file handler. + self.logger_stream_handler = logging.StreamHandler() + self.logger_stream_handler.setFormatter(self.logger_formatter) + for _, logger in six.iteritems(self.logger): + logger.addHandler(self.logger_stream_handler) + if self.logger_file_handler: + logger.removeHandler(self.logger_file_handler) + + @property + def debug(self): + """Debug status + + :param value: The debug status, True or False. + :type: bool + """ + return self.__debug + + @debug.setter + def debug(self, value): + """Debug status + + :param value: The debug status, True or False. + :type: bool + """ + self.__debug = value + if self.__debug: + # if debug status is True, turn on debug logging + for _, logger in six.iteritems(self.logger): + logger.setLevel(logging.DEBUG) + # turn on httplib debug + httplib.HTTPConnection.debuglevel = 1 + else: + # if debug status is False, turn off debug logging, + # setting log level to default `logging.WARNING` + for _, logger in six.iteritems(self.logger): + logger.setLevel(logging.WARNING) + # turn off httplib debug + httplib.HTTPConnection.debuglevel = 0 + + @property + def logger_format(self): + """The logger format. + + The logger_formatter will be updated when sets logger_format. + + :param value: The format string. + :type: str + """ + return self.__logger_format + + @logger_format.setter + def logger_format(self, value): + """The logger format. + + The logger_formatter will be updated when sets logger_format. + + :param value: The format string. + :type: str + """ + self.__logger_format = value + self.logger_formatter = logging.Formatter(self.__logger_format) + + def get_api_key_with_prefix(self, identifier): + """Gets API key (with prefix if set). + + :param identifier: The identifier of apiKey. + :return: The token for api key authentication. + """ + if self.refresh_api_key_hook: + self.refresh_api_key_hook(self) + + key = self.api_key.get(identifier) + if key: + prefix = self.api_key_prefix.get(identifier) + if prefix: + return "%s %s" % (prefix, key) + else: + return key + + def get_basic_auth_token(self): + """Gets HTTP basic authentication header (string). + + :return: The token for basic HTTP authentication. + """ + token = "" + if self.username or self.password: + token = urllib3.util.make_headers( + basic_auth=self.username + ':' + self.password + ).get('authorization') + return token + + def auth_settings(self): + """Gets Auth Settings dict for api client. + + :return: The Auth Settings information dict. + """ + return { + 'token': + { + 'type': 'api_key', + 'in': 'header', + 'key': 'Authorization', + 'value': self.get_api_key_with_prefix('Authorization') + }, + } + + def to_debug_report(self): + """Gets the essential information for debugging. + + :return: The report for debugging. + """ + return "Python SDK Debug Report:\n"\ + "OS: {env}\n"\ + "Python Version: {pyversion}\n"\ + "Version of the API: 2.0.0\n"\ + "SDK Package Version: 5.6.1".\ + format(env=sys.platform, pyversion=sys.version) diff --git a/vendor/elabapi-python/elabapi_python/models/__init__.py b/vendor/elabapi-python/elabapi_python/models/__init__.py new file mode 100644 index 0000000..349d183 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/__init__.py @@ -0,0 +1,142 @@ +# coding: utf-8 + +# flake8: noqa +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +# import models into model package +from elabapi_python.models.all_ofentity_editable_metadatamerge import AllOfentityEditableMetadatamerge +from elabapi_python.models.any_ofuploads_subid_body1 import AnyOfuploadsSubidBody1 +from elabapi_python.models.apikey import Apikey +from elabapi_python.models.apikeys_body import ApikeysBody +from elabapi_python.models.branding_id_body import BrandingIdBody +from elabapi_python.models.changelog import Changelog +from elabapi_python.models.comment import Comment +from elabapi_python.models.compound import Compound +from elabapi_python.models.compound_create_request import CompoundCreateRequest +from elabapi_python.models.compound_duplicate_request import CompoundDuplicateRequest +from elabapi_python.models.compounds_body import CompoundsBody +from elabapi_python.models.compounds_links_subid_body import CompoundsLinksSubidBody +from elabapi_python.models.config import Config +from elabapi_python.models.container import Container +from elabapi_python.models.containers_subid_body import ContainersSubidBody +from elabapi_python.models.containers_subid_body1 import ContainersSubidBody1 +from elabapi_python.models.dspace_body import DspaceBody +from elabapi_python.models.dspace_body1 import DspaceBody1 +from elabapi_python.models.dspace_entity import DspaceEntity +from elabapi_python.models.dspace_metadata import DspaceMetadata +from elabapi_python.models.dspace_metadata1 import DspaceMetadata1 +from elabapi_python.models.entity import Entity +from elabapi_python.models.entity_and_item_editable import EntityAndItemEditable +from elabapi_python.models.entity_duplicate import EntityDuplicate +from elabapi_python.models.entity_editable import EntityEditable +from elabapi_python.models.entity_template import EntityTemplate +from elabapi_python.models.entity_template_editable import EntityTemplateEditable +from elabapi_python.models.error import Error +from elabapi_python.models.event import Event +from elabapi_python.models.event_id_body import EventIdBody +from elabapi_python.models.eventid_delta import EventidDelta +from elabapi_python.models.events_id_body import EventsIdBody +from elabapi_python.models.exclusive_edit_mode import ExclusiveEditMode +from elabapi_python.models.experiment import Experiment +from elabapi_python.models.experiments_links_subid_body import ExperimentsLinksSubidBody +from elabapi_python.models.experiments_templates_id_body import ExperimentsTemplatesIdBody +from elabapi_python.models.export import Export +from elabapi_python.models.exports_body import ExportsBody +from elabapi_python.models.extra_fields_keys import ExtraFieldsKeys +from elabapi_python.models.favtags_body import FavtagsBody +from elabapi_python.models.id import Id +from elabapi_python.models.id1 import Id1 +from elabapi_python.models.id2 import Id2 +from elabapi_python.models.id3 import Id3 +from elabapi_python.models.id4 import Id4 +from elabapi_python.models.id_certs_body import IdCertsBody +from elabapi_python.models.id_comments_body import IdCommentsBody +from elabapi_python.models.id_endpoints_body import IdEndpointsBody +from elabapi_python.models.id_experiments_categories_body import IdExperimentsCategoriesBody +from elabapi_python.models.id_experiments_status_body import IdExperimentsStatusBody +from elabapi_python.models.id_items_status_body import IdItemsStatusBody +from elabapi_python.models.id_resources_categories_body import IdResourcesCategoriesBody +from elabapi_python.models.id_steps_body import IdStepsBody +from elabapi_python.models.id_tags_body import IdTagsBody +from elabapi_python.models.id_tags_body1 import IdTagsBody1 +from elabapi_python.models.id_teamgroups_body import IdTeamgroupsBody +from elabapi_python.models.id_uploads_body import IdUploadsBody +from elabapi_python.models.idp import Idp +from elabapi_python.models.idp_cert import IdpCert +from elabapi_python.models.idp_endpoint import IdpEndpoint +from elabapi_python.models.idp_source import IdpSource +from elabapi_python.models.idps_body import IdpsBody +from elabapi_python.models.idps_id_body import IdpsIdBody +from elabapi_python.models.idps_sources_body import IdpsSourcesBody +from elabapi_python.models.idps_sources_id_body import IdpsSourcesIdBody +from elabapi_python.models.import_body import ImportBody +from elabapi_python.models.inline_response200 import InlineResponse200 +from elabapi_python.models.inline_response2001 import InlineResponse2001 +from elabapi_python.models.inline_response20010 import InlineResponse20010 +from elabapi_python.models.inline_response2001_experiments import InlineResponse2001Experiments +from elabapi_python.models.inline_response2001_items import InlineResponse2001Items +from elabapi_python.models.inline_response2001_users import InlineResponse2001Users +from elabapi_python.models.inline_response2002 import InlineResponse2002 +from elabapi_python.models.inline_response2003 import InlineResponse2003 +from elabapi_python.models.inline_response2004 import InlineResponse2004 +from elabapi_python.models.inline_response2004_query_parameters import InlineResponse2004QueryParameters +from elabapi_python.models.inline_response2005 import InlineResponse2005 +from elabapi_python.models.inline_response2006 import InlineResponse2006 +from elabapi_python.models.inline_response2007 import InlineResponse2007 +from elabapi_python.models.inline_response2008 import InlineResponse2008 +from elabapi_python.models.inline_response2009 import InlineResponse2009 +from elabapi_python.models.inline_response2009_embedded import InlineResponse2009Embedded +from elabapi_python.models.inline_response2009_embedded_entries import InlineResponse2009EmbeddedEntries +from elabapi_python.models.instance_body import InstanceBody +from elabapi_python.models.item import Item +from elabapi_python.models.item_editable import ItemEditable +from elabapi_python.models.items_links_subid_body import ItemsLinksSubidBody +from elabapi_python.models.items_types_id_body import ItemsTypesIdBody +from elabapi_python.models.link import Link +from elabapi_python.models.metadata import Metadata +from elabapi_python.models.metadata_elabftw import MetadataElabftw +from elabapi_python.models.metadata_elabftw_extra_fields_groups import MetadataElabftwExtraFieldsGroups +from elabapi_python.models.metadata_extra_fields import MetadataExtraFields +from elabapi_python.models.notification import Notification +from elabapi_python.models.notifications_subid_body import NotificationsSubidBody +from elabapi_python.models.patch_action import PatchAction +from elabapi_python.models.revision import Revision +from elabapi_python.models.revisions_subid_body import RevisionsSubidBody +from elabapi_python.models.statuslike import Statuslike +from elabapi_python.models.step import Step +from elabapi_python.models.steps_subid_body import StepsSubidBody +from elabapi_python.models.storage_unit import StorageUnit +from elabapi_python.models.storage_units_body import StorageUnitsBody +from elabapi_python.models.storage_units_id_body import StorageUnitsIdBody +from elabapi_python.models.tag import Tag +from elabapi_python.models.tags_subid_body import TagsSubidBody +from elabapi_python.models.tags_subid_body1 import TagsSubidBody1 +from elabapi_python.models.team import Team +from elabapi_python.models.teamgroup import Teamgroup +from elabapi_python.models.teamgroup_users import TeamgroupUsers +from elabapi_python.models.teamgroups_subid_body import TeamgroupsSubidBody +from elabapi_python.models.teams_body import TeamsBody +from elabapi_python.models.teams_id_body import TeamsIdBody +from elabapi_python.models.todoitem import Todoitem +from elabapi_python.models.todolist_body import TodolistBody +from elabapi_python.models.todolist_id_body import TodolistIdBody +from elabapi_python.models.unfinished_step import UnfinishedStep +from elabapi_python.models.unfinished_steps import UnfinishedSteps +from elabapi_python.models.upload import Upload +from elabapi_python.models.uploads_subid_body import UploadsSubidBody +from elabapi_python.models.uploads_subid_body1 import UploadsSubidBody1 +from elabapi_python.models.users import Users +from elabapi_python.models.users_body import UsersBody +from elabapi_python.models.users_full import UsersFull +from elabapi_python.models.users_full_teams import UsersFullTeams +from elabapi_python.models.users_id_body import UsersIdBody diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/__init__.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000..863f215 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/__init__.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/all_ofentity_editable_metadatamerge.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/all_ofentity_editable_metadatamerge.cpython-313.pyc new file mode 100644 index 0000000..c3b4cac Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/all_ofentity_editable_metadatamerge.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/any_ofuploads_subid_body1.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/any_ofuploads_subid_body1.cpython-313.pyc new file mode 100644 index 0000000..448ffa4 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/any_ofuploads_subid_body1.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/apikey.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/apikey.cpython-313.pyc new file mode 100644 index 0000000..0d16d45 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/apikey.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/apikeys_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/apikeys_body.cpython-313.pyc new file mode 100644 index 0000000..3d79988 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/apikeys_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/branding_id_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/branding_id_body.cpython-313.pyc new file mode 100644 index 0000000..9b5c577 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/branding_id_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/changelog.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/changelog.cpython-313.pyc new file mode 100644 index 0000000..a17568e Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/changelog.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/comment.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/comment.cpython-313.pyc new file mode 100644 index 0000000..5ee77b5 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/comment.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/compound.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/compound.cpython-313.pyc new file mode 100644 index 0000000..75aeb57 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/compound.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/compound_create_request.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/compound_create_request.cpython-313.pyc new file mode 100644 index 0000000..2fa1688 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/compound_create_request.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/compound_duplicate_request.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/compound_duplicate_request.cpython-313.pyc new file mode 100644 index 0000000..6c0a102 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/compound_duplicate_request.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/compounds_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/compounds_body.cpython-313.pyc new file mode 100644 index 0000000..88b7f2a Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/compounds_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/compounds_links_subid_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/compounds_links_subid_body.cpython-313.pyc new file mode 100644 index 0000000..2502357 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/compounds_links_subid_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/config.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/config.cpython-313.pyc new file mode 100644 index 0000000..7efc137 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/config.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/container.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/container.cpython-313.pyc new file mode 100644 index 0000000..c80d492 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/container.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/containers_subid_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/containers_subid_body.cpython-313.pyc new file mode 100644 index 0000000..59aed2e Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/containers_subid_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/containers_subid_body1.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/containers_subid_body1.cpython-313.pyc new file mode 100644 index 0000000..9b94339 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/containers_subid_body1.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/dspace_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/dspace_body.cpython-313.pyc new file mode 100644 index 0000000..3b57fae Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/dspace_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/dspace_body1.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/dspace_body1.cpython-313.pyc new file mode 100644 index 0000000..0379549 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/dspace_body1.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/dspace_entity.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/dspace_entity.cpython-313.pyc new file mode 100644 index 0000000..c5bd8c3 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/dspace_entity.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/dspace_metadata.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/dspace_metadata.cpython-313.pyc new file mode 100644 index 0000000..9f211bf Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/dspace_metadata.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/dspace_metadata1.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/dspace_metadata1.cpython-313.pyc new file mode 100644 index 0000000..dff7ad8 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/dspace_metadata1.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/entity.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/entity.cpython-313.pyc new file mode 100644 index 0000000..94b524c Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/entity.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/entity_and_item_editable.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/entity_and_item_editable.cpython-313.pyc new file mode 100644 index 0000000..a81a0e4 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/entity_and_item_editable.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/entity_duplicate.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/entity_duplicate.cpython-313.pyc new file mode 100644 index 0000000..67244ad Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/entity_duplicate.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/entity_editable.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/entity_editable.cpython-313.pyc new file mode 100644 index 0000000..7779b41 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/entity_editable.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/entity_template.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/entity_template.cpython-313.pyc new file mode 100644 index 0000000..f3b55d7 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/entity_template.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/entity_template_editable.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/entity_template_editable.cpython-313.pyc new file mode 100644 index 0000000..80ecc12 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/entity_template_editable.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/error.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/error.cpython-313.pyc new file mode 100644 index 0000000..28bc141 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/error.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/event.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/event.cpython-313.pyc new file mode 100644 index 0000000..d6dfee9 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/event.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/event_id_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/event_id_body.cpython-313.pyc new file mode 100644 index 0000000..9996d41 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/event_id_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/eventid_delta.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/eventid_delta.cpython-313.pyc new file mode 100644 index 0000000..4deda2e Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/eventid_delta.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/events_id_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/events_id_body.cpython-313.pyc new file mode 100644 index 0000000..3b6be90 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/events_id_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/exclusive_edit_mode.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/exclusive_edit_mode.cpython-313.pyc new file mode 100644 index 0000000..4239bfb Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/exclusive_edit_mode.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/experiment.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/experiment.cpython-313.pyc new file mode 100644 index 0000000..4e57861 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/experiment.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/experiments_links_subid_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/experiments_links_subid_body.cpython-313.pyc new file mode 100644 index 0000000..539e761 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/experiments_links_subid_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/experiments_templates_id_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/experiments_templates_id_body.cpython-313.pyc new file mode 100644 index 0000000..6c38d53 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/experiments_templates_id_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/export.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/export.cpython-313.pyc new file mode 100644 index 0000000..197ef6d Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/export.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/exports_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/exports_body.cpython-313.pyc new file mode 100644 index 0000000..0022f80 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/exports_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/extra_fields_keys.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/extra_fields_keys.cpython-313.pyc new file mode 100644 index 0000000..ad389d9 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/extra_fields_keys.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/favtags_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/favtags_body.cpython-313.pyc new file mode 100644 index 0000000..75fd9c7 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/favtags_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/id.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/id.cpython-313.pyc new file mode 100644 index 0000000..2e4ddc3 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/id.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/id1.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/id1.cpython-313.pyc new file mode 100644 index 0000000..e48f17f Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/id1.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/id2.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/id2.cpython-313.pyc new file mode 100644 index 0000000..1033517 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/id2.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/id3.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/id3.cpython-313.pyc new file mode 100644 index 0000000..51e2655 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/id3.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/id4.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/id4.cpython-313.pyc new file mode 100644 index 0000000..56f9b57 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/id4.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/id_certs_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_certs_body.cpython-313.pyc new file mode 100644 index 0000000..029e68b Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_certs_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/id_comments_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_comments_body.cpython-313.pyc new file mode 100644 index 0000000..bdde8a8 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_comments_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/id_endpoints_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_endpoints_body.cpython-313.pyc new file mode 100644 index 0000000..6224e06 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_endpoints_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/id_experiments_categories_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_experiments_categories_body.cpython-313.pyc new file mode 100644 index 0000000..b4bc8f1 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_experiments_categories_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/id_experiments_status_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_experiments_status_body.cpython-313.pyc new file mode 100644 index 0000000..8ad0fa7 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_experiments_status_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/id_items_status_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_items_status_body.cpython-313.pyc new file mode 100644 index 0000000..50f25d5 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_items_status_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/id_resources_categories_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_resources_categories_body.cpython-313.pyc new file mode 100644 index 0000000..cf83056 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_resources_categories_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/id_steps_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_steps_body.cpython-313.pyc new file mode 100644 index 0000000..58aea20 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_steps_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/id_tags_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_tags_body.cpython-313.pyc new file mode 100644 index 0000000..aa907c3 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_tags_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/id_tags_body1.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_tags_body1.cpython-313.pyc new file mode 100644 index 0000000..2572854 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_tags_body1.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/id_teamgroups_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_teamgroups_body.cpython-313.pyc new file mode 100644 index 0000000..4190948 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_teamgroups_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/id_uploads_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_uploads_body.cpython-313.pyc new file mode 100644 index 0000000..f6b6490 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/id_uploads_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/idp.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/idp.cpython-313.pyc new file mode 100644 index 0000000..c81c9b3 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/idp.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/idp_cert.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/idp_cert.cpython-313.pyc new file mode 100644 index 0000000..5d013b4 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/idp_cert.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/idp_endpoint.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/idp_endpoint.cpython-313.pyc new file mode 100644 index 0000000..b19b066 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/idp_endpoint.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/idp_source.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/idp_source.cpython-313.pyc new file mode 100644 index 0000000..807f1d6 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/idp_source.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/idps_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/idps_body.cpython-313.pyc new file mode 100644 index 0000000..c615cf5 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/idps_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/idps_id_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/idps_id_body.cpython-313.pyc new file mode 100644 index 0000000..1bdb3ec Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/idps_id_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/idps_sources_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/idps_sources_body.cpython-313.pyc new file mode 100644 index 0000000..8b323bb Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/idps_sources_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/idps_sources_id_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/idps_sources_id_body.cpython-313.pyc new file mode 100644 index 0000000..027a985 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/idps_sources_id_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/import_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/import_body.cpython-313.pyc new file mode 100644 index 0000000..cf700f5 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/import_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response200.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response200.cpython-313.pyc new file mode 100644 index 0000000..e26c24d Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response200.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2001.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2001.cpython-313.pyc new file mode 100644 index 0000000..63848b4 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2001.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response20010.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response20010.cpython-313.pyc new file mode 100644 index 0000000..ae575f9 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response20010.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2001_experiments.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2001_experiments.cpython-313.pyc new file mode 100644 index 0000000..988cc30 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2001_experiments.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2001_items.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2001_items.cpython-313.pyc new file mode 100644 index 0000000..6f22467 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2001_items.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2001_users.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2001_users.cpython-313.pyc new file mode 100644 index 0000000..8b23c57 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2001_users.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2002.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2002.cpython-313.pyc new file mode 100644 index 0000000..39d11dd Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2002.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2003.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2003.cpython-313.pyc new file mode 100644 index 0000000..a51363b Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2003.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2004.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2004.cpython-313.pyc new file mode 100644 index 0000000..9122c8b Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2004.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2004_query_parameters.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2004_query_parameters.cpython-313.pyc new file mode 100644 index 0000000..94e81f8 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2004_query_parameters.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2005.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2005.cpython-313.pyc new file mode 100644 index 0000000..5089966 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2005.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2006.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2006.cpython-313.pyc new file mode 100644 index 0000000..7712d48 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2006.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2007.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2007.cpython-313.pyc new file mode 100644 index 0000000..2d54976 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2007.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2008.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2008.cpython-313.pyc new file mode 100644 index 0000000..b3db3d3 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2008.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2009.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2009.cpython-313.pyc new file mode 100644 index 0000000..82773da Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2009.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2009_embedded.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2009_embedded.cpython-313.pyc new file mode 100644 index 0000000..437444a Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2009_embedded.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2009_embedded_entries.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2009_embedded_entries.cpython-313.pyc new file mode 100644 index 0000000..2dc113e Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/inline_response2009_embedded_entries.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/instance_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/instance_body.cpython-313.pyc new file mode 100644 index 0000000..111fc79 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/instance_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/item.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/item.cpython-313.pyc new file mode 100644 index 0000000..16fdc3f Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/item.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/item_editable.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/item_editable.cpython-313.pyc new file mode 100644 index 0000000..38a707f Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/item_editable.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/items_links_subid_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/items_links_subid_body.cpython-313.pyc new file mode 100644 index 0000000..2379a1e Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/items_links_subid_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/items_types_id_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/items_types_id_body.cpython-313.pyc new file mode 100644 index 0000000..8a123f1 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/items_types_id_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/link.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/link.cpython-313.pyc new file mode 100644 index 0000000..1f37a2a Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/link.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/metadata.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/metadata.cpython-313.pyc new file mode 100644 index 0000000..a8f242c Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/metadata.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/metadata_elabftw.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/metadata_elabftw.cpython-313.pyc new file mode 100644 index 0000000..8af4f6b Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/metadata_elabftw.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/metadata_elabftw_extra_fields_groups.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/metadata_elabftw_extra_fields_groups.cpython-313.pyc new file mode 100644 index 0000000..f61d394 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/metadata_elabftw_extra_fields_groups.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/metadata_extra_fields.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/metadata_extra_fields.cpython-313.pyc new file mode 100644 index 0000000..649492b Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/metadata_extra_fields.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/notification.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/notification.cpython-313.pyc new file mode 100644 index 0000000..619c679 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/notification.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/notifications_subid_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/notifications_subid_body.cpython-313.pyc new file mode 100644 index 0000000..66983b5 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/notifications_subid_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/patch_action.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/patch_action.cpython-313.pyc new file mode 100644 index 0000000..4dc3bff Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/patch_action.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/revision.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/revision.cpython-313.pyc new file mode 100644 index 0000000..c9cf4b2 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/revision.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/revisions_subid_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/revisions_subid_body.cpython-313.pyc new file mode 100644 index 0000000..70c5d44 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/revisions_subid_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/statuslike.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/statuslike.cpython-313.pyc new file mode 100644 index 0000000..91d2710 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/statuslike.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/step.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/step.cpython-313.pyc new file mode 100644 index 0000000..d572194 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/step.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/steps_subid_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/steps_subid_body.cpython-313.pyc new file mode 100644 index 0000000..e01b23b Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/steps_subid_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/storage_unit.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/storage_unit.cpython-313.pyc new file mode 100644 index 0000000..efd0f99 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/storage_unit.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/storage_units_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/storage_units_body.cpython-313.pyc new file mode 100644 index 0000000..7ba063b Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/storage_units_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/storage_units_id_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/storage_units_id_body.cpython-313.pyc new file mode 100644 index 0000000..5ca2950 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/storage_units_id_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/tag.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/tag.cpython-313.pyc new file mode 100644 index 0000000..07ee1e0 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/tag.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/tags_subid_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/tags_subid_body.cpython-313.pyc new file mode 100644 index 0000000..d216f30 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/tags_subid_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/tags_subid_body1.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/tags_subid_body1.cpython-313.pyc new file mode 100644 index 0000000..db14cc5 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/tags_subid_body1.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/team.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/team.cpython-313.pyc new file mode 100644 index 0000000..f890129 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/team.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/teamgroup.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/teamgroup.cpython-313.pyc new file mode 100644 index 0000000..cd72b38 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/teamgroup.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/teamgroup_users.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/teamgroup_users.cpython-313.pyc new file mode 100644 index 0000000..04f13d3 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/teamgroup_users.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/teamgroups_subid_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/teamgroups_subid_body.cpython-313.pyc new file mode 100644 index 0000000..7ad465c Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/teamgroups_subid_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/teams_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/teams_body.cpython-313.pyc new file mode 100644 index 0000000..629db78 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/teams_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/teams_id_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/teams_id_body.cpython-313.pyc new file mode 100644 index 0000000..6a77e98 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/teams_id_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/todoitem.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/todoitem.cpython-313.pyc new file mode 100644 index 0000000..566eeeb Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/todoitem.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/todolist_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/todolist_body.cpython-313.pyc new file mode 100644 index 0000000..96e9172 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/todolist_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/todolist_id_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/todolist_id_body.cpython-313.pyc new file mode 100644 index 0000000..02fdcbf Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/todolist_id_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/unfinished_step.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/unfinished_step.cpython-313.pyc new file mode 100644 index 0000000..a7900d8 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/unfinished_step.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/unfinished_steps.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/unfinished_steps.cpython-313.pyc new file mode 100644 index 0000000..43f9f09 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/unfinished_steps.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/upload.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/upload.cpython-313.pyc new file mode 100644 index 0000000..0223e27 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/upload.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/uploads_subid_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/uploads_subid_body.cpython-313.pyc new file mode 100644 index 0000000..03bfe19 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/uploads_subid_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/uploads_subid_body1.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/uploads_subid_body1.cpython-313.pyc new file mode 100644 index 0000000..4d4adeb Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/uploads_subid_body1.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/users.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/users.cpython-313.pyc new file mode 100644 index 0000000..4835aab Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/users.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/users_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/users_body.cpython-313.pyc new file mode 100644 index 0000000..35a4afb Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/users_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/users_full.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/users_full.cpython-313.pyc new file mode 100644 index 0000000..bc009b8 Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/users_full.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/users_full_teams.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/users_full_teams.cpython-313.pyc new file mode 100644 index 0000000..7da6efb Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/users_full_teams.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/__pycache__/users_id_body.cpython-313.pyc b/vendor/elabapi-python/elabapi_python/models/__pycache__/users_id_body.cpython-313.pyc new file mode 100644 index 0000000..c5401dc Binary files /dev/null and b/vendor/elabapi-python/elabapi_python/models/__pycache__/users_id_body.cpython-313.pyc differ diff --git a/vendor/elabapi-python/elabapi_python/models/all_ofentity_editable_metadatamerge.py b/vendor/elabapi-python/elabapi_python/models/all_ofentity_editable_metadatamerge.py new file mode 100644 index 0000000..bc4ff04 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/all_ofentity_editable_metadatamerge.py @@ -0,0 +1,90 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six +from elabapi_python.models.metadata import Metadata # noqa: F401,E501 + +class AllOfentityEditableMetadatamerge(Metadata): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + } + if hasattr(Metadata, "swagger_types"): + swagger_types.update(Metadata.swagger_types) + + attribute_map = { + } + if hasattr(Metadata, "attribute_map"): + attribute_map.update(Metadata.attribute_map) + + def __init__(self, *args, **kwargs): # noqa: E501 + """AllOfentityEditableMetadatamerge - a model defined in Swagger""" # noqa: E501 + self.discriminator = None + Metadata.__init__(self, *args, **kwargs) + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(AllOfentityEditableMetadatamerge, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, AllOfentityEditableMetadatamerge): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/any_ofuploads_subid_body1.py b/vendor/elabapi-python/elabapi_python/models/any_ofuploads_subid_body1.py new file mode 100644 index 0000000..43bb991 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/any_ofuploads_subid_body1.py @@ -0,0 +1,84 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class AnyOfuploadsSubidBody1(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + } + + attribute_map = { + } + + def __init__(self): # noqa: E501 + """AnyOfuploadsSubidBody1 - a model defined in Swagger""" # noqa: E501 + self.discriminator = None + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(AnyOfuploadsSubidBody1, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, AnyOfuploadsSubidBody1): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/apikey.py b/vendor/elabapi-python/elabapi_python/models/apikey.py new file mode 100644 index 0000000..a22d31a --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/apikey.py @@ -0,0 +1,292 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Apikey(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'name': 'str', + 'created_at': 'str', + 'last_used_at': 'str', + 'hash': 'str', + 'can_write': 'int', + 'team': 'int', + 'team_name': 'str' + } + + attribute_map = { + 'id': 'id', + 'name': 'name', + 'created_at': 'created_at', + 'last_used_at': 'last_used_at', + 'hash': 'hash', + 'can_write': 'can_write', + 'team': 'team', + 'team_name': 'team_name' + } + + def __init__(self, id=None, name=None, created_at=None, last_used_at=None, hash=None, can_write=None, team=None, team_name=None): # noqa: E501 + """Apikey - a model defined in Swagger""" # noqa: E501 + self._id = None + self._name = None + self._created_at = None + self._last_used_at = None + self._hash = None + self._can_write = None + self._team = None + self._team_name = None + self.discriminator = None + if id is not None: + self.id = id + if name is not None: + self.name = name + if created_at is not None: + self.created_at = created_at + if last_used_at is not None: + self.last_used_at = last_used_at + if hash is not None: + self.hash = hash + if can_write is not None: + self.can_write = can_write + if team is not None: + self.team = team + if team_name is not None: + self.team_name = team_name + + @property + def id(self): + """Gets the id of this Apikey. # noqa: E501 + + + :return: The id of this Apikey. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this Apikey. + + + :param id: The id of this Apikey. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def name(self): + """Gets the name of this Apikey. # noqa: E501 + + + :return: The name of this Apikey. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this Apikey. + + + :param name: The name of this Apikey. # noqa: E501 + :type: str + """ + + self._name = name + + @property + def created_at(self): + """Gets the created_at of this Apikey. # noqa: E501 + + + :return: The created_at of this Apikey. # noqa: E501 + :rtype: str + """ + return self._created_at + + @created_at.setter + def created_at(self, created_at): + """Sets the created_at of this Apikey. + + + :param created_at: The created_at of this Apikey. # noqa: E501 + :type: str + """ + + self._created_at = created_at + + @property + def last_used_at(self): + """Gets the last_used_at of this Apikey. # noqa: E501 + + + :return: The last_used_at of this Apikey. # noqa: E501 + :rtype: str + """ + return self._last_used_at + + @last_used_at.setter + def last_used_at(self, last_used_at): + """Sets the last_used_at of this Apikey. + + + :param last_used_at: The last_used_at of this Apikey. # noqa: E501 + :type: str + """ + + self._last_used_at = last_used_at + + @property + def hash(self): + """Gets the hash of this Apikey. # noqa: E501 + + + :return: The hash of this Apikey. # noqa: E501 + :rtype: str + """ + return self._hash + + @hash.setter + def hash(self, hash): + """Sets the hash of this Apikey. + + + :param hash: The hash of this Apikey. # noqa: E501 + :type: str + """ + + self._hash = hash + + @property + def can_write(self): + """Gets the can_write of this Apikey. # noqa: E501 + + + :return: The can_write of this Apikey. # noqa: E501 + :rtype: int + """ + return self._can_write + + @can_write.setter + def can_write(self, can_write): + """Sets the can_write of this Apikey. + + + :param can_write: The can_write of this Apikey. # noqa: E501 + :type: int + """ + + self._can_write = can_write + + @property + def team(self): + """Gets the team of this Apikey. # noqa: E501 + + + :return: The team of this Apikey. # noqa: E501 + :rtype: int + """ + return self._team + + @team.setter + def team(self, team): + """Sets the team of this Apikey. + + + :param team: The team of this Apikey. # noqa: E501 + :type: int + """ + + self._team = team + + @property + def team_name(self): + """Gets the team_name of this Apikey. # noqa: E501 + + + :return: The team_name of this Apikey. # noqa: E501 + :rtype: str + """ + return self._team_name + + @team_name.setter + def team_name(self, team_name): + """Sets the team_name of this Apikey. + + + :param team_name: The team_name of this Apikey. # noqa: E501 + :type: str + """ + + self._team_name = team_name + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Apikey, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Apikey): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/apikeys_body.py b/vendor/elabapi-python/elabapi_python/models/apikeys_body.py new file mode 100644 index 0000000..2f73bdf --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/apikeys_body.py @@ -0,0 +1,140 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class ApikeysBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'name': 'str', + 'canwrite': 'int' + } + + attribute_map = { + 'name': 'name', + 'canwrite': 'canwrite' + } + + def __init__(self, name='An API key', canwrite=0): # noqa: E501 + """ApikeysBody - a model defined in Swagger""" # noqa: E501 + self._name = None + self._canwrite = None + self.discriminator = None + if name is not None: + self.name = name + if canwrite is not None: + self.canwrite = canwrite + + @property + def name(self): + """Gets the name of this ApikeysBody. # noqa: E501 + + A name for the API key. # noqa: E501 + + :return: The name of this ApikeysBody. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this ApikeysBody. + + A name for the API key. # noqa: E501 + + :param name: The name of this ApikeysBody. # noqa: E501 + :type: str + """ + + self._name = name + + @property + def canwrite(self): + """Gets the canwrite of this ApikeysBody. # noqa: E501 + + Set to 1 to allow the key to do write actions. # noqa: E501 + + :return: The canwrite of this ApikeysBody. # noqa: E501 + :rtype: int + """ + return self._canwrite + + @canwrite.setter + def canwrite(self, canwrite): + """Sets the canwrite of this ApikeysBody. + + Set to 1 to allow the key to do write actions. # noqa: E501 + + :param canwrite: The canwrite of this ApikeysBody. # noqa: E501 + :type: int + """ + + self._canwrite = canwrite + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(ApikeysBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, ApikeysBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/branding_id_body.py b/vendor/elabapi-python/elabapi_python/models/branding_id_body.py new file mode 100644 index 0000000..7f29a4d --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/branding_id_body.py @@ -0,0 +1,147 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class BrandingIdBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'action': 'str', + 'file': 'str' + } + + attribute_map = { + 'action': 'action', + 'file': 'file' + } + + def __init__(self, action='update', file=None): # noqa: E501 + """BrandingIdBody - a model defined in Swagger""" # noqa: E501 + self._action = None + self._file = None + self.discriminator = None + if action is not None: + self.action = action + self.file = file + + @property + def action(self): + """Gets the action of this BrandingIdBody. # noqa: E501 + + Update a branding asset. Requires Sysadmin permissions. # noqa: E501 + + :return: The action of this BrandingIdBody. # noqa: E501 + :rtype: str + """ + return self._action + + @action.setter + def action(self, action): + """Sets the action of this BrandingIdBody. + + Update a branding asset. Requires Sysadmin permissions. # noqa: E501 + + :param action: The action of this BrandingIdBody. # noqa: E501 + :type: str + """ + allowed_values = ["update"] # noqa: E501 + if action not in allowed_values: + raise ValueError( + "Invalid value for `action` ({0}), must be one of {1}" # noqa: E501 + .format(action, allowed_values) + ) + + self._action = action + + @property + def file(self): + """Gets the file of this BrandingIdBody. # noqa: E501 + + Branding file. Accepted types are SVG, PNG, JPEG, WebP and ICO. Maximum size is 1 MiB. # noqa: E501 + + :return: The file of this BrandingIdBody. # noqa: E501 + :rtype: str + """ + return self._file + + @file.setter + def file(self, file): + """Sets the file of this BrandingIdBody. + + Branding file. Accepted types are SVG, PNG, JPEG, WebP and ICO. Maximum size is 1 MiB. # noqa: E501 + + :param file: The file of this BrandingIdBody. # noqa: E501 + :type: str + """ + if file is None: + raise ValueError("Invalid value for `file`, must not be `None`") # noqa: E501 + + self._file = file + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(BrandingIdBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, BrandingIdBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/changelog.py b/vendor/elabapi-python/elabapi_python/models/changelog.py new file mode 100644 index 0000000..df17aed --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/changelog.py @@ -0,0 +1,224 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Changelog(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'created_at': 'str', + 'target': 'str', + 'content': 'str', + 'fullname': 'str', + 'userid': 'int' + } + + attribute_map = { + 'created_at': 'created_at', + 'target': 'target', + 'content': 'content', + 'fullname': 'fullname', + 'userid': 'userid' + } + + def __init__(self, created_at=None, target=None, content=None, fullname=None, userid=None): # noqa: E501 + """Changelog - a model defined in Swagger""" # noqa: E501 + self._created_at = None + self._target = None + self._content = None + self._fullname = None + self._userid = None + self.discriminator = None + if created_at is not None: + self.created_at = created_at + if target is not None: + self.target = target + if content is not None: + self.content = content + if fullname is not None: + self.fullname = fullname + if userid is not None: + self.userid = userid + + @property + def created_at(self): + """Gets the created_at of this Changelog. # noqa: E501 + + Timestamp when the change was recorded. # noqa: E501 + + :return: The created_at of this Changelog. # noqa: E501 + :rtype: str + """ + return self._created_at + + @created_at.setter + def created_at(self, created_at): + """Sets the created_at of this Changelog. + + Timestamp when the change was recorded. # noqa: E501 + + :param created_at: The created_at of this Changelog. # noqa: E501 + :type: str + """ + + self._created_at = created_at + + @property + def target(self): + """Gets the target of this Changelog. # noqa: E501 + + Field/attribute that was changed. # noqa: E501 + + :return: The target of this Changelog. # noqa: E501 + :rtype: str + """ + return self._target + + @target.setter + def target(self, target): + """Sets the target of this Changelog. + + Field/attribute that was changed. # noqa: E501 + + :param target: The target of this Changelog. # noqa: E501 + :type: str + """ + + self._target = target + + @property + def content(self): + """Gets the content of this Changelog. # noqa: E501 + + New value stored for the target field (may be a scalar or JSON-encoded string depending on target). # noqa: E501 + + :return: The content of this Changelog. # noqa: E501 + :rtype: str + """ + return self._content + + @content.setter + def content(self, content): + """Sets the content of this Changelog. + + New value stored for the target field (may be a scalar or JSON-encoded string depending on target). # noqa: E501 + + :param content: The content of this Changelog. # noqa: E501 + :type: str + """ + + self._content = content + + @property + def fullname(self): + """Gets the fullname of this Changelog. # noqa: E501 + + Full name of the user who made the change. # noqa: E501 + + :return: The fullname of this Changelog. # noqa: E501 + :rtype: str + """ + return self._fullname + + @fullname.setter + def fullname(self, fullname): + """Sets the fullname of this Changelog. + + Full name of the user who made the change. # noqa: E501 + + :param fullname: The fullname of this Changelog. # noqa: E501 + :type: str + """ + + self._fullname = fullname + + @property + def userid(self): + """Gets the userid of this Changelog. # noqa: E501 + + Userid of the user who made the change. # noqa: E501 + + :return: The userid of this Changelog. # noqa: E501 + :rtype: int + """ + return self._userid + + @userid.setter + def userid(self, userid): + """Sets the userid of this Changelog. + + Userid of the user who made the change. # noqa: E501 + + :param userid: The userid of this Changelog. # noqa: E501 + :type: int + """ + + self._userid = userid + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Changelog, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Changelog): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/comment.py b/vendor/elabapi-python/elabapi_python/models/comment.py new file mode 100644 index 0000000..6444bd7 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/comment.py @@ -0,0 +1,344 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Comment(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'created_at': 'str', + 'item_id': 'int', + 'comment': 'str', + 'userid': 'int', + 'modified_at': 'str', + 'fullname': 'str', + 'firstname': 'str', + 'lastname': 'str', + 'orcid': 'str' + } + + attribute_map = { + 'id': 'id', + 'created_at': 'created_at', + 'item_id': 'item_id', + 'comment': 'comment', + 'userid': 'userid', + 'modified_at': 'modified_at', + 'fullname': 'fullname', + 'firstname': 'firstname', + 'lastname': 'lastname', + 'orcid': 'orcid' + } + + def __init__(self, id=None, created_at=None, item_id=None, comment=None, userid=None, modified_at=None, fullname=None, firstname=None, lastname=None, orcid=None): # noqa: E501 + """Comment - a model defined in Swagger""" # noqa: E501 + self._id = None + self._created_at = None + self._item_id = None + self._comment = None + self._userid = None + self._modified_at = None + self._fullname = None + self._firstname = None + self._lastname = None + self._orcid = None + self.discriminator = None + if id is not None: + self.id = id + if created_at is not None: + self.created_at = created_at + if item_id is not None: + self.item_id = item_id + if comment is not None: + self.comment = comment + if userid is not None: + self.userid = userid + if modified_at is not None: + self.modified_at = modified_at + if fullname is not None: + self.fullname = fullname + if firstname is not None: + self.firstname = firstname + if lastname is not None: + self.lastname = lastname + if orcid is not None: + self.orcid = orcid + + @property + def id(self): + """Gets the id of this Comment. # noqa: E501 + + + :return: The id of this Comment. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this Comment. + + + :param id: The id of this Comment. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def created_at(self): + """Gets the created_at of this Comment. # noqa: E501 + + + :return: The created_at of this Comment. # noqa: E501 + :rtype: str + """ + return self._created_at + + @created_at.setter + def created_at(self, created_at): + """Sets the created_at of this Comment. + + + :param created_at: The created_at of this Comment. # noqa: E501 + :type: str + """ + + self._created_at = created_at + + @property + def item_id(self): + """Gets the item_id of this Comment. # noqa: E501 + + + :return: The item_id of this Comment. # noqa: E501 + :rtype: int + """ + return self._item_id + + @item_id.setter + def item_id(self, item_id): + """Sets the item_id of this Comment. + + + :param item_id: The item_id of this Comment. # noqa: E501 + :type: int + """ + + self._item_id = item_id + + @property + def comment(self): + """Gets the comment of this Comment. # noqa: E501 + + + :return: The comment of this Comment. # noqa: E501 + :rtype: str + """ + return self._comment + + @comment.setter + def comment(self, comment): + """Sets the comment of this Comment. + + + :param comment: The comment of this Comment. # noqa: E501 + :type: str + """ + + self._comment = comment + + @property + def userid(self): + """Gets the userid of this Comment. # noqa: E501 + + + :return: The userid of this Comment. # noqa: E501 + :rtype: int + """ + return self._userid + + @userid.setter + def userid(self, userid): + """Sets the userid of this Comment. + + + :param userid: The userid of this Comment. # noqa: E501 + :type: int + """ + + self._userid = userid + + @property + def modified_at(self): + """Gets the modified_at of this Comment. # noqa: E501 + + + :return: The modified_at of this Comment. # noqa: E501 + :rtype: str + """ + return self._modified_at + + @modified_at.setter + def modified_at(self, modified_at): + """Sets the modified_at of this Comment. + + + :param modified_at: The modified_at of this Comment. # noqa: E501 + :type: str + """ + + self._modified_at = modified_at + + @property + def fullname(self): + """Gets the fullname of this Comment. # noqa: E501 + + + :return: The fullname of this Comment. # noqa: E501 + :rtype: str + """ + return self._fullname + + @fullname.setter + def fullname(self, fullname): + """Sets the fullname of this Comment. + + + :param fullname: The fullname of this Comment. # noqa: E501 + :type: str + """ + + self._fullname = fullname + + @property + def firstname(self): + """Gets the firstname of this Comment. # noqa: E501 + + + :return: The firstname of this Comment. # noqa: E501 + :rtype: str + """ + return self._firstname + + @firstname.setter + def firstname(self, firstname): + """Sets the firstname of this Comment. + + + :param firstname: The firstname of this Comment. # noqa: E501 + :type: str + """ + + self._firstname = firstname + + @property + def lastname(self): + """Gets the lastname of this Comment. # noqa: E501 + + + :return: The lastname of this Comment. # noqa: E501 + :rtype: str + """ + return self._lastname + + @lastname.setter + def lastname(self, lastname): + """Sets the lastname of this Comment. + + + :param lastname: The lastname of this Comment. # noqa: E501 + :type: str + """ + + self._lastname = lastname + + @property + def orcid(self): + """Gets the orcid of this Comment. # noqa: E501 + + + :return: The orcid of this Comment. # noqa: E501 + :rtype: str + """ + return self._orcid + + @orcid.setter + def orcid(self, orcid): + """Sets the orcid of this Comment. + + + :param orcid: The orcid of this Comment. # noqa: E501 + :type: str + """ + + self._orcid = orcid + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Comment, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Comment): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/compound.py b/vendor/elabapi-python/elabapi_python/models/compound.py new file mode 100644 index 0000000..75020e3 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/compound.py @@ -0,0 +1,1848 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Compound(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'created_at': 'datetime', + 'created_by': 'int', + 'modified_at': 'datetime', + 'modified_by': 'int', + 'userid': 'int', + 'team': 'int', + 'state': 'int', + 'name': 'str', + 'molecular_formula': 'str', + 'cas_number': 'str', + 'ec_number': 'str', + 'chebi_id': 'str', + 'chembl_id': 'str', + 'dea_number': 'str', + 'drugbank_id': 'str', + 'dsstox_id': 'str', + 'hmdb_id': 'str', + 'inchi': 'str', + 'inchi_key': 'str', + 'iupac_name': 'str', + 'kegg_id': 'str', + 'metabolomics_wb_id': 'str', + 'molecular_weight': 'str', + 'nci_code': 'str', + 'nikkaji_number': 'str', + 'pharmgkb_id': 'str', + 'pharos_ligand_id': 'str', + 'pubchem_cid': 'int', + 'rxcui': 'str', + 'smiles': 'str', + 'unii': 'str', + 'wikidata': 'str', + 'wikipedia': 'str', + 'is_corrosive': 'int', + 'is_explosive': 'int', + 'is_flammable': 'int', + 'is_gas_under_pressure': 'int', + 'is_hazardous2env': 'int', + 'is_hazardous2health': 'int', + 'is_serious_health_hazard': 'int', + 'is_oxidising': 'int', + 'is_toxic': 'int', + 'is_radioactive': 'int', + 'is_antibiotic': 'int', + 'is_antibiotic_precursor': 'int', + 'is_drug': 'int', + 'is_drug_precursor': 'int', + 'is_explosive_precursor': 'int', + 'is_cmr': 'int', + 'is_nano': 'int', + 'is_controlled': 'int', + 'is_ed2health': 'int', + 'is_ed2env': 'int', + 'is_pbt': 'int', + 'is_pmt': 'int', + 'is_vpvb': 'int', + 'is_vpvm': 'int', + 'fp2_base64': 'str', + 'userid_human': 'str', + 'team_name': 'str', + 'has_fingerprint': 'int' + } + + attribute_map = { + 'id': 'id', + 'created_at': 'created_at', + 'created_by': 'created_by', + 'modified_at': 'modified_at', + 'modified_by': 'modified_by', + 'userid': 'userid', + 'team': 'team', + 'state': 'state', + 'name': 'name', + 'molecular_formula': 'molecular_formula', + 'cas_number': 'cas_number', + 'ec_number': 'ec_number', + 'chebi_id': 'chebi_id', + 'chembl_id': 'chembl_id', + 'dea_number': 'dea_number', + 'drugbank_id': 'drugbank_id', + 'dsstox_id': 'dsstox_id', + 'hmdb_id': 'hmdb_id', + 'inchi': 'inchi', + 'inchi_key': 'inchi_key', + 'iupac_name': 'iupac_name', + 'kegg_id': 'kegg_id', + 'metabolomics_wb_id': 'metabolomics_wb_id', + 'molecular_weight': 'molecular_weight', + 'nci_code': 'nci_code', + 'nikkaji_number': 'nikkaji_number', + 'pharmgkb_id': 'pharmgkb_id', + 'pharos_ligand_id': 'pharos_ligand_id', + 'pubchem_cid': 'pubchem_cid', + 'rxcui': 'rxcui', + 'smiles': 'smiles', + 'unii': 'unii', + 'wikidata': 'wikidata', + 'wikipedia': 'wikipedia', + 'is_corrosive': 'is_corrosive', + 'is_explosive': 'is_explosive', + 'is_flammable': 'is_flammable', + 'is_gas_under_pressure': 'is_gas_under_pressure', + 'is_hazardous2env': 'is_hazardous2env', + 'is_hazardous2health': 'is_hazardous2health', + 'is_serious_health_hazard': 'is_serious_health_hazard', + 'is_oxidising': 'is_oxidising', + 'is_toxic': 'is_toxic', + 'is_radioactive': 'is_radioactive', + 'is_antibiotic': 'is_antibiotic', + 'is_antibiotic_precursor': 'is_antibiotic_precursor', + 'is_drug': 'is_drug', + 'is_drug_precursor': 'is_drug_precursor', + 'is_explosive_precursor': 'is_explosive_precursor', + 'is_cmr': 'is_cmr', + 'is_nano': 'is_nano', + 'is_controlled': 'is_controlled', + 'is_ed2health': 'is_ed2health', + 'is_ed2env': 'is_ed2env', + 'is_pbt': 'is_pbt', + 'is_pmt': 'is_pmt', + 'is_vpvb': 'is_vpvb', + 'is_vpvm': 'is_vpvm', + 'fp2_base64': 'fp2_base64', + 'userid_human': 'userid_human', + 'team_name': 'team_name', + 'has_fingerprint': 'has_fingerprint' + } + + def __init__(self, id=None, created_at=None, created_by=None, modified_at=None, modified_by=None, userid=None, team=None, state=None, name=None, molecular_formula=None, cas_number=None, ec_number=None, chebi_id=None, chembl_id=None, dea_number=None, drugbank_id=None, dsstox_id=None, hmdb_id=None, inchi=None, inchi_key=None, iupac_name=None, kegg_id=None, metabolomics_wb_id=None, molecular_weight=None, nci_code=None, nikkaji_number=None, pharmgkb_id=None, pharos_ligand_id=None, pubchem_cid=None, rxcui=None, smiles=None, unii=None, wikidata=None, wikipedia=None, is_corrosive=None, is_explosive=None, is_flammable=None, is_gas_under_pressure=None, is_hazardous2env=None, is_hazardous2health=None, is_serious_health_hazard=None, is_oxidising=None, is_toxic=None, is_radioactive=None, is_antibiotic=None, is_antibiotic_precursor=None, is_drug=None, is_drug_precursor=None, is_explosive_precursor=None, is_cmr=None, is_nano=None, is_controlled=None, is_ed2health=None, is_ed2env=None, is_pbt=None, is_pmt=None, is_vpvb=None, is_vpvm=None, fp2_base64=None, userid_human=None, team_name=None, has_fingerprint=None): # noqa: E501 + """Compound - a model defined in Swagger""" # noqa: E501 + self._id = None + self._created_at = None + self._created_by = None + self._modified_at = None + self._modified_by = None + self._userid = None + self._team = None + self._state = None + self._name = None + self._molecular_formula = None + self._cas_number = None + self._ec_number = None + self._chebi_id = None + self._chembl_id = None + self._dea_number = None + self._drugbank_id = None + self._dsstox_id = None + self._hmdb_id = None + self._inchi = None + self._inchi_key = None + self._iupac_name = None + self._kegg_id = None + self._metabolomics_wb_id = None + self._molecular_weight = None + self._nci_code = None + self._nikkaji_number = None + self._pharmgkb_id = None + self._pharos_ligand_id = None + self._pubchem_cid = None + self._rxcui = None + self._smiles = None + self._unii = None + self._wikidata = None + self._wikipedia = None + self._is_corrosive = None + self._is_explosive = None + self._is_flammable = None + self._is_gas_under_pressure = None + self._is_hazardous2env = None + self._is_hazardous2health = None + self._is_serious_health_hazard = None + self._is_oxidising = None + self._is_toxic = None + self._is_radioactive = None + self._is_antibiotic = None + self._is_antibiotic_precursor = None + self._is_drug = None + self._is_drug_precursor = None + self._is_explosive_precursor = None + self._is_cmr = None + self._is_nano = None + self._is_controlled = None + self._is_ed2health = None + self._is_ed2env = None + self._is_pbt = None + self._is_pmt = None + self._is_vpvb = None + self._is_vpvm = None + self._fp2_base64 = None + self._userid_human = None + self._team_name = None + self._has_fingerprint = None + self.discriminator = None + if id is not None: + self.id = id + if created_at is not None: + self.created_at = created_at + if created_by is not None: + self.created_by = created_by + if modified_at is not None: + self.modified_at = modified_at + if modified_by is not None: + self.modified_by = modified_by + if userid is not None: + self.userid = userid + if team is not None: + self.team = team + if state is not None: + self.state = state + if name is not None: + self.name = name + if molecular_formula is not None: + self.molecular_formula = molecular_formula + if cas_number is not None: + self.cas_number = cas_number + if ec_number is not None: + self.ec_number = ec_number + if chebi_id is not None: + self.chebi_id = chebi_id + if chembl_id is not None: + self.chembl_id = chembl_id + if dea_number is not None: + self.dea_number = dea_number + if drugbank_id is not None: + self.drugbank_id = drugbank_id + if dsstox_id is not None: + self.dsstox_id = dsstox_id + if hmdb_id is not None: + self.hmdb_id = hmdb_id + if inchi is not None: + self.inchi = inchi + if inchi_key is not None: + self.inchi_key = inchi_key + if iupac_name is not None: + self.iupac_name = iupac_name + if kegg_id is not None: + self.kegg_id = kegg_id + if metabolomics_wb_id is not None: + self.metabolomics_wb_id = metabolomics_wb_id + if molecular_weight is not None: + self.molecular_weight = molecular_weight + if nci_code is not None: + self.nci_code = nci_code + if nikkaji_number is not None: + self.nikkaji_number = nikkaji_number + if pharmgkb_id is not None: + self.pharmgkb_id = pharmgkb_id + if pharos_ligand_id is not None: + self.pharos_ligand_id = pharos_ligand_id + if pubchem_cid is not None: + self.pubchem_cid = pubchem_cid + if rxcui is not None: + self.rxcui = rxcui + if smiles is not None: + self.smiles = smiles + if unii is not None: + self.unii = unii + if wikidata is not None: + self.wikidata = wikidata + if wikipedia is not None: + self.wikipedia = wikipedia + if is_corrosive is not None: + self.is_corrosive = is_corrosive + if is_explosive is not None: + self.is_explosive = is_explosive + if is_flammable is not None: + self.is_flammable = is_flammable + if is_gas_under_pressure is not None: + self.is_gas_under_pressure = is_gas_under_pressure + if is_hazardous2env is not None: + self.is_hazardous2env = is_hazardous2env + if is_hazardous2health is not None: + self.is_hazardous2health = is_hazardous2health + if is_serious_health_hazard is not None: + self.is_serious_health_hazard = is_serious_health_hazard + if is_oxidising is not None: + self.is_oxidising = is_oxidising + if is_toxic is not None: + self.is_toxic = is_toxic + if is_radioactive is not None: + self.is_radioactive = is_radioactive + if is_antibiotic is not None: + self.is_antibiotic = is_antibiotic + if is_antibiotic_precursor is not None: + self.is_antibiotic_precursor = is_antibiotic_precursor + if is_drug is not None: + self.is_drug = is_drug + if is_drug_precursor is not None: + self.is_drug_precursor = is_drug_precursor + if is_explosive_precursor is not None: + self.is_explosive_precursor = is_explosive_precursor + if is_cmr is not None: + self.is_cmr = is_cmr + if is_nano is not None: + self.is_nano = is_nano + if is_controlled is not None: + self.is_controlled = is_controlled + if is_ed2health is not None: + self.is_ed2health = is_ed2health + if is_ed2env is not None: + self.is_ed2env = is_ed2env + if is_pbt is not None: + self.is_pbt = is_pbt + if is_pmt is not None: + self.is_pmt = is_pmt + if is_vpvb is not None: + self.is_vpvb = is_vpvb + if is_vpvm is not None: + self.is_vpvm = is_vpvm + if fp2_base64 is not None: + self.fp2_base64 = fp2_base64 + if userid_human is not None: + self.userid_human = userid_human + if team_name is not None: + self.team_name = team_name + if has_fingerprint is not None: + self.has_fingerprint = has_fingerprint + + @property + def id(self): + """Gets the id of this Compound. # noqa: E501 + + + :return: The id of this Compound. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this Compound. + + + :param id: The id of this Compound. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def created_at(self): + """Gets the created_at of this Compound. # noqa: E501 + + + :return: The created_at of this Compound. # noqa: E501 + :rtype: datetime + """ + return self._created_at + + @created_at.setter + def created_at(self, created_at): + """Sets the created_at of this Compound. + + + :param created_at: The created_at of this Compound. # noqa: E501 + :type: datetime + """ + + self._created_at = created_at + + @property + def created_by(self): + """Gets the created_by of this Compound. # noqa: E501 + + + :return: The created_by of this Compound. # noqa: E501 + :rtype: int + """ + return self._created_by + + @created_by.setter + def created_by(self, created_by): + """Sets the created_by of this Compound. + + + :param created_by: The created_by of this Compound. # noqa: E501 + :type: int + """ + + self._created_by = created_by + + @property + def modified_at(self): + """Gets the modified_at of this Compound. # noqa: E501 + + + :return: The modified_at of this Compound. # noqa: E501 + :rtype: datetime + """ + return self._modified_at + + @modified_at.setter + def modified_at(self, modified_at): + """Sets the modified_at of this Compound. + + + :param modified_at: The modified_at of this Compound. # noqa: E501 + :type: datetime + """ + + self._modified_at = modified_at + + @property + def modified_by(self): + """Gets the modified_by of this Compound. # noqa: E501 + + + :return: The modified_by of this Compound. # noqa: E501 + :rtype: int + """ + return self._modified_by + + @modified_by.setter + def modified_by(self, modified_by): + """Sets the modified_by of this Compound. + + + :param modified_by: The modified_by of this Compound. # noqa: E501 + :type: int + """ + + self._modified_by = modified_by + + @property + def userid(self): + """Gets the userid of this Compound. # noqa: E501 + + + :return: The userid of this Compound. # noqa: E501 + :rtype: int + """ + return self._userid + + @userid.setter + def userid(self, userid): + """Sets the userid of this Compound. + + + :param userid: The userid of this Compound. # noqa: E501 + :type: int + """ + + self._userid = userid + + @property + def team(self): + """Gets the team of this Compound. # noqa: E501 + + + :return: The team of this Compound. # noqa: E501 + :rtype: int + """ + return self._team + + @team.setter + def team(self, team): + """Sets the team of this Compound. + + + :param team: The team of this Compound. # noqa: E501 + :type: int + """ + + self._team = team + + @property + def state(self): + """Gets the state of this Compound. # noqa: E501 + + + :return: The state of this Compound. # noqa: E501 + :rtype: int + """ + return self._state + + @state.setter + def state(self, state): + """Sets the state of this Compound. + + + :param state: The state of this Compound. # noqa: E501 + :type: int + """ + + self._state = state + + @property + def name(self): + """Gets the name of this Compound. # noqa: E501 + + + :return: The name of this Compound. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this Compound. + + + :param name: The name of this Compound. # noqa: E501 + :type: str + """ + + self._name = name + + @property + def molecular_formula(self): + """Gets the molecular_formula of this Compound. # noqa: E501 + + + :return: The molecular_formula of this Compound. # noqa: E501 + :rtype: str + """ + return self._molecular_formula + + @molecular_formula.setter + def molecular_formula(self, molecular_formula): + """Sets the molecular_formula of this Compound. + + + :param molecular_formula: The molecular_formula of this Compound. # noqa: E501 + :type: str + """ + + self._molecular_formula = molecular_formula + + @property + def cas_number(self): + """Gets the cas_number of this Compound. # noqa: E501 + + + :return: The cas_number of this Compound. # noqa: E501 + :rtype: str + """ + return self._cas_number + + @cas_number.setter + def cas_number(self, cas_number): + """Sets the cas_number of this Compound. + + + :param cas_number: The cas_number of this Compound. # noqa: E501 + :type: str + """ + + self._cas_number = cas_number + + @property + def ec_number(self): + """Gets the ec_number of this Compound. # noqa: E501 + + + :return: The ec_number of this Compound. # noqa: E501 + :rtype: str + """ + return self._ec_number + + @ec_number.setter + def ec_number(self, ec_number): + """Sets the ec_number of this Compound. + + + :param ec_number: The ec_number of this Compound. # noqa: E501 + :type: str + """ + + self._ec_number = ec_number + + @property + def chebi_id(self): + """Gets the chebi_id of this Compound. # noqa: E501 + + + :return: The chebi_id of this Compound. # noqa: E501 + :rtype: str + """ + return self._chebi_id + + @chebi_id.setter + def chebi_id(self, chebi_id): + """Sets the chebi_id of this Compound. + + + :param chebi_id: The chebi_id of this Compound. # noqa: E501 + :type: str + """ + + self._chebi_id = chebi_id + + @property + def chembl_id(self): + """Gets the chembl_id of this Compound. # noqa: E501 + + + :return: The chembl_id of this Compound. # noqa: E501 + :rtype: str + """ + return self._chembl_id + + @chembl_id.setter + def chembl_id(self, chembl_id): + """Sets the chembl_id of this Compound. + + + :param chembl_id: The chembl_id of this Compound. # noqa: E501 + :type: str + """ + + self._chembl_id = chembl_id + + @property + def dea_number(self): + """Gets the dea_number of this Compound. # noqa: E501 + + + :return: The dea_number of this Compound. # noqa: E501 + :rtype: str + """ + return self._dea_number + + @dea_number.setter + def dea_number(self, dea_number): + """Sets the dea_number of this Compound. + + + :param dea_number: The dea_number of this Compound. # noqa: E501 + :type: str + """ + + self._dea_number = dea_number + + @property + def drugbank_id(self): + """Gets the drugbank_id of this Compound. # noqa: E501 + + + :return: The drugbank_id of this Compound. # noqa: E501 + :rtype: str + """ + return self._drugbank_id + + @drugbank_id.setter + def drugbank_id(self, drugbank_id): + """Sets the drugbank_id of this Compound. + + + :param drugbank_id: The drugbank_id of this Compound. # noqa: E501 + :type: str + """ + + self._drugbank_id = drugbank_id + + @property + def dsstox_id(self): + """Gets the dsstox_id of this Compound. # noqa: E501 + + + :return: The dsstox_id of this Compound. # noqa: E501 + :rtype: str + """ + return self._dsstox_id + + @dsstox_id.setter + def dsstox_id(self, dsstox_id): + """Sets the dsstox_id of this Compound. + + + :param dsstox_id: The dsstox_id of this Compound. # noqa: E501 + :type: str + """ + + self._dsstox_id = dsstox_id + + @property + def hmdb_id(self): + """Gets the hmdb_id of this Compound. # noqa: E501 + + + :return: The hmdb_id of this Compound. # noqa: E501 + :rtype: str + """ + return self._hmdb_id + + @hmdb_id.setter + def hmdb_id(self, hmdb_id): + """Sets the hmdb_id of this Compound. + + + :param hmdb_id: The hmdb_id of this Compound. # noqa: E501 + :type: str + """ + + self._hmdb_id = hmdb_id + + @property + def inchi(self): + """Gets the inchi of this Compound. # noqa: E501 + + + :return: The inchi of this Compound. # noqa: E501 + :rtype: str + """ + return self._inchi + + @inchi.setter + def inchi(self, inchi): + """Sets the inchi of this Compound. + + + :param inchi: The inchi of this Compound. # noqa: E501 + :type: str + """ + + self._inchi = inchi + + @property + def inchi_key(self): + """Gets the inchi_key of this Compound. # noqa: E501 + + + :return: The inchi_key of this Compound. # noqa: E501 + :rtype: str + """ + return self._inchi_key + + @inchi_key.setter + def inchi_key(self, inchi_key): + """Sets the inchi_key of this Compound. + + + :param inchi_key: The inchi_key of this Compound. # noqa: E501 + :type: str + """ + + self._inchi_key = inchi_key + + @property + def iupac_name(self): + """Gets the iupac_name of this Compound. # noqa: E501 + + + :return: The iupac_name of this Compound. # noqa: E501 + :rtype: str + """ + return self._iupac_name + + @iupac_name.setter + def iupac_name(self, iupac_name): + """Sets the iupac_name of this Compound. + + + :param iupac_name: The iupac_name of this Compound. # noqa: E501 + :type: str + """ + + self._iupac_name = iupac_name + + @property + def kegg_id(self): + """Gets the kegg_id of this Compound. # noqa: E501 + + + :return: The kegg_id of this Compound. # noqa: E501 + :rtype: str + """ + return self._kegg_id + + @kegg_id.setter + def kegg_id(self, kegg_id): + """Sets the kegg_id of this Compound. + + + :param kegg_id: The kegg_id of this Compound. # noqa: E501 + :type: str + """ + + self._kegg_id = kegg_id + + @property + def metabolomics_wb_id(self): + """Gets the metabolomics_wb_id of this Compound. # noqa: E501 + + + :return: The metabolomics_wb_id of this Compound. # noqa: E501 + :rtype: str + """ + return self._metabolomics_wb_id + + @metabolomics_wb_id.setter + def metabolomics_wb_id(self, metabolomics_wb_id): + """Sets the metabolomics_wb_id of this Compound. + + + :param metabolomics_wb_id: The metabolomics_wb_id of this Compound. # noqa: E501 + :type: str + """ + + self._metabolomics_wb_id = metabolomics_wb_id + + @property + def molecular_weight(self): + """Gets the molecular_weight of this Compound. # noqa: E501 + + + :return: The molecular_weight of this Compound. # noqa: E501 + :rtype: str + """ + return self._molecular_weight + + @molecular_weight.setter + def molecular_weight(self, molecular_weight): + """Sets the molecular_weight of this Compound. + + + :param molecular_weight: The molecular_weight of this Compound. # noqa: E501 + :type: str + """ + + self._molecular_weight = molecular_weight + + @property + def nci_code(self): + """Gets the nci_code of this Compound. # noqa: E501 + + + :return: The nci_code of this Compound. # noqa: E501 + :rtype: str + """ + return self._nci_code + + @nci_code.setter + def nci_code(self, nci_code): + """Sets the nci_code of this Compound. + + + :param nci_code: The nci_code of this Compound. # noqa: E501 + :type: str + """ + + self._nci_code = nci_code + + @property + def nikkaji_number(self): + """Gets the nikkaji_number of this Compound. # noqa: E501 + + + :return: The nikkaji_number of this Compound. # noqa: E501 + :rtype: str + """ + return self._nikkaji_number + + @nikkaji_number.setter + def nikkaji_number(self, nikkaji_number): + """Sets the nikkaji_number of this Compound. + + + :param nikkaji_number: The nikkaji_number of this Compound. # noqa: E501 + :type: str + """ + + self._nikkaji_number = nikkaji_number + + @property + def pharmgkb_id(self): + """Gets the pharmgkb_id of this Compound. # noqa: E501 + + + :return: The pharmgkb_id of this Compound. # noqa: E501 + :rtype: str + """ + return self._pharmgkb_id + + @pharmgkb_id.setter + def pharmgkb_id(self, pharmgkb_id): + """Sets the pharmgkb_id of this Compound. + + + :param pharmgkb_id: The pharmgkb_id of this Compound. # noqa: E501 + :type: str + """ + + self._pharmgkb_id = pharmgkb_id + + @property + def pharos_ligand_id(self): + """Gets the pharos_ligand_id of this Compound. # noqa: E501 + + + :return: The pharos_ligand_id of this Compound. # noqa: E501 + :rtype: str + """ + return self._pharos_ligand_id + + @pharos_ligand_id.setter + def pharos_ligand_id(self, pharos_ligand_id): + """Sets the pharos_ligand_id of this Compound. + + + :param pharos_ligand_id: The pharos_ligand_id of this Compound. # noqa: E501 + :type: str + """ + + self._pharos_ligand_id = pharos_ligand_id + + @property + def pubchem_cid(self): + """Gets the pubchem_cid of this Compound. # noqa: E501 + + + :return: The pubchem_cid of this Compound. # noqa: E501 + :rtype: int + """ + return self._pubchem_cid + + @pubchem_cid.setter + def pubchem_cid(self, pubchem_cid): + """Sets the pubchem_cid of this Compound. + + + :param pubchem_cid: The pubchem_cid of this Compound. # noqa: E501 + :type: int + """ + + self._pubchem_cid = pubchem_cid + + @property + def rxcui(self): + """Gets the rxcui of this Compound. # noqa: E501 + + + :return: The rxcui of this Compound. # noqa: E501 + :rtype: str + """ + return self._rxcui + + @rxcui.setter + def rxcui(self, rxcui): + """Sets the rxcui of this Compound. + + + :param rxcui: The rxcui of this Compound. # noqa: E501 + :type: str + """ + + self._rxcui = rxcui + + @property + def smiles(self): + """Gets the smiles of this Compound. # noqa: E501 + + + :return: The smiles of this Compound. # noqa: E501 + :rtype: str + """ + return self._smiles + + @smiles.setter + def smiles(self, smiles): + """Sets the smiles of this Compound. + + + :param smiles: The smiles of this Compound. # noqa: E501 + :type: str + """ + + self._smiles = smiles + + @property + def unii(self): + """Gets the unii of this Compound. # noqa: E501 + + + :return: The unii of this Compound. # noqa: E501 + :rtype: str + """ + return self._unii + + @unii.setter + def unii(self, unii): + """Sets the unii of this Compound. + + + :param unii: The unii of this Compound. # noqa: E501 + :type: str + """ + + self._unii = unii + + @property + def wikidata(self): + """Gets the wikidata of this Compound. # noqa: E501 + + + :return: The wikidata of this Compound. # noqa: E501 + :rtype: str + """ + return self._wikidata + + @wikidata.setter + def wikidata(self, wikidata): + """Sets the wikidata of this Compound. + + + :param wikidata: The wikidata of this Compound. # noqa: E501 + :type: str + """ + + self._wikidata = wikidata + + @property + def wikipedia(self): + """Gets the wikipedia of this Compound. # noqa: E501 + + + :return: The wikipedia of this Compound. # noqa: E501 + :rtype: str + """ + return self._wikipedia + + @wikipedia.setter + def wikipedia(self, wikipedia): + """Sets the wikipedia of this Compound. + + + :param wikipedia: The wikipedia of this Compound. # noqa: E501 + :type: str + """ + + self._wikipedia = wikipedia + + @property + def is_corrosive(self): + """Gets the is_corrosive of this Compound. # noqa: E501 + + + :return: The is_corrosive of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_corrosive + + @is_corrosive.setter + def is_corrosive(self, is_corrosive): + """Sets the is_corrosive of this Compound. + + + :param is_corrosive: The is_corrosive of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_corrosive not in allowed_values: + raise ValueError( + "Invalid value for `is_corrosive` ({0}), must be one of {1}" # noqa: E501 + .format(is_corrosive, allowed_values) + ) + + self._is_corrosive = is_corrosive + + @property + def is_explosive(self): + """Gets the is_explosive of this Compound. # noqa: E501 + + + :return: The is_explosive of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_explosive + + @is_explosive.setter + def is_explosive(self, is_explosive): + """Sets the is_explosive of this Compound. + + + :param is_explosive: The is_explosive of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_explosive not in allowed_values: + raise ValueError( + "Invalid value for `is_explosive` ({0}), must be one of {1}" # noqa: E501 + .format(is_explosive, allowed_values) + ) + + self._is_explosive = is_explosive + + @property + def is_flammable(self): + """Gets the is_flammable of this Compound. # noqa: E501 + + + :return: The is_flammable of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_flammable + + @is_flammable.setter + def is_flammable(self, is_flammable): + """Sets the is_flammable of this Compound. + + + :param is_flammable: The is_flammable of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_flammable not in allowed_values: + raise ValueError( + "Invalid value for `is_flammable` ({0}), must be one of {1}" # noqa: E501 + .format(is_flammable, allowed_values) + ) + + self._is_flammable = is_flammable + + @property + def is_gas_under_pressure(self): + """Gets the is_gas_under_pressure of this Compound. # noqa: E501 + + + :return: The is_gas_under_pressure of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_gas_under_pressure + + @is_gas_under_pressure.setter + def is_gas_under_pressure(self, is_gas_under_pressure): + """Sets the is_gas_under_pressure of this Compound. + + + :param is_gas_under_pressure: The is_gas_under_pressure of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_gas_under_pressure not in allowed_values: + raise ValueError( + "Invalid value for `is_gas_under_pressure` ({0}), must be one of {1}" # noqa: E501 + .format(is_gas_under_pressure, allowed_values) + ) + + self._is_gas_under_pressure = is_gas_under_pressure + + @property + def is_hazardous2env(self): + """Gets the is_hazardous2env of this Compound. # noqa: E501 + + + :return: The is_hazardous2env of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_hazardous2env + + @is_hazardous2env.setter + def is_hazardous2env(self, is_hazardous2env): + """Sets the is_hazardous2env of this Compound. + + + :param is_hazardous2env: The is_hazardous2env of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_hazardous2env not in allowed_values: + raise ValueError( + "Invalid value for `is_hazardous2env` ({0}), must be one of {1}" # noqa: E501 + .format(is_hazardous2env, allowed_values) + ) + + self._is_hazardous2env = is_hazardous2env + + @property + def is_hazardous2health(self): + """Gets the is_hazardous2health of this Compound. # noqa: E501 + + + :return: The is_hazardous2health of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_hazardous2health + + @is_hazardous2health.setter + def is_hazardous2health(self, is_hazardous2health): + """Sets the is_hazardous2health of this Compound. + + + :param is_hazardous2health: The is_hazardous2health of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_hazardous2health not in allowed_values: + raise ValueError( + "Invalid value for `is_hazardous2health` ({0}), must be one of {1}" # noqa: E501 + .format(is_hazardous2health, allowed_values) + ) + + self._is_hazardous2health = is_hazardous2health + + @property + def is_serious_health_hazard(self): + """Gets the is_serious_health_hazard of this Compound. # noqa: E501 + + + :return: The is_serious_health_hazard of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_serious_health_hazard + + @is_serious_health_hazard.setter + def is_serious_health_hazard(self, is_serious_health_hazard): + """Sets the is_serious_health_hazard of this Compound. + + + :param is_serious_health_hazard: The is_serious_health_hazard of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_serious_health_hazard not in allowed_values: + raise ValueError( + "Invalid value for `is_serious_health_hazard` ({0}), must be one of {1}" # noqa: E501 + .format(is_serious_health_hazard, allowed_values) + ) + + self._is_serious_health_hazard = is_serious_health_hazard + + @property + def is_oxidising(self): + """Gets the is_oxidising of this Compound. # noqa: E501 + + + :return: The is_oxidising of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_oxidising + + @is_oxidising.setter + def is_oxidising(self, is_oxidising): + """Sets the is_oxidising of this Compound. + + + :param is_oxidising: The is_oxidising of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_oxidising not in allowed_values: + raise ValueError( + "Invalid value for `is_oxidising` ({0}), must be one of {1}" # noqa: E501 + .format(is_oxidising, allowed_values) + ) + + self._is_oxidising = is_oxidising + + @property + def is_toxic(self): + """Gets the is_toxic of this Compound. # noqa: E501 + + + :return: The is_toxic of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_toxic + + @is_toxic.setter + def is_toxic(self, is_toxic): + """Sets the is_toxic of this Compound. + + + :param is_toxic: The is_toxic of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_toxic not in allowed_values: + raise ValueError( + "Invalid value for `is_toxic` ({0}), must be one of {1}" # noqa: E501 + .format(is_toxic, allowed_values) + ) + + self._is_toxic = is_toxic + + @property + def is_radioactive(self): + """Gets the is_radioactive of this Compound. # noqa: E501 + + + :return: The is_radioactive of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_radioactive + + @is_radioactive.setter + def is_radioactive(self, is_radioactive): + """Sets the is_radioactive of this Compound. + + + :param is_radioactive: The is_radioactive of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_radioactive not in allowed_values: + raise ValueError( + "Invalid value for `is_radioactive` ({0}), must be one of {1}" # noqa: E501 + .format(is_radioactive, allowed_values) + ) + + self._is_radioactive = is_radioactive + + @property + def is_antibiotic(self): + """Gets the is_antibiotic of this Compound. # noqa: E501 + + + :return: The is_antibiotic of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_antibiotic + + @is_antibiotic.setter + def is_antibiotic(self, is_antibiotic): + """Sets the is_antibiotic of this Compound. + + + :param is_antibiotic: The is_antibiotic of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_antibiotic not in allowed_values: + raise ValueError( + "Invalid value for `is_antibiotic` ({0}), must be one of {1}" # noqa: E501 + .format(is_antibiotic, allowed_values) + ) + + self._is_antibiotic = is_antibiotic + + @property + def is_antibiotic_precursor(self): + """Gets the is_antibiotic_precursor of this Compound. # noqa: E501 + + + :return: The is_antibiotic_precursor of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_antibiotic_precursor + + @is_antibiotic_precursor.setter + def is_antibiotic_precursor(self, is_antibiotic_precursor): + """Sets the is_antibiotic_precursor of this Compound. + + + :param is_antibiotic_precursor: The is_antibiotic_precursor of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_antibiotic_precursor not in allowed_values: + raise ValueError( + "Invalid value for `is_antibiotic_precursor` ({0}), must be one of {1}" # noqa: E501 + .format(is_antibiotic_precursor, allowed_values) + ) + + self._is_antibiotic_precursor = is_antibiotic_precursor + + @property + def is_drug(self): + """Gets the is_drug of this Compound. # noqa: E501 + + + :return: The is_drug of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_drug + + @is_drug.setter + def is_drug(self, is_drug): + """Sets the is_drug of this Compound. + + + :param is_drug: The is_drug of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_drug not in allowed_values: + raise ValueError( + "Invalid value for `is_drug` ({0}), must be one of {1}" # noqa: E501 + .format(is_drug, allowed_values) + ) + + self._is_drug = is_drug + + @property + def is_drug_precursor(self): + """Gets the is_drug_precursor of this Compound. # noqa: E501 + + + :return: The is_drug_precursor of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_drug_precursor + + @is_drug_precursor.setter + def is_drug_precursor(self, is_drug_precursor): + """Sets the is_drug_precursor of this Compound. + + + :param is_drug_precursor: The is_drug_precursor of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_drug_precursor not in allowed_values: + raise ValueError( + "Invalid value for `is_drug_precursor` ({0}), must be one of {1}" # noqa: E501 + .format(is_drug_precursor, allowed_values) + ) + + self._is_drug_precursor = is_drug_precursor + + @property + def is_explosive_precursor(self): + """Gets the is_explosive_precursor of this Compound. # noqa: E501 + + + :return: The is_explosive_precursor of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_explosive_precursor + + @is_explosive_precursor.setter + def is_explosive_precursor(self, is_explosive_precursor): + """Sets the is_explosive_precursor of this Compound. + + + :param is_explosive_precursor: The is_explosive_precursor of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_explosive_precursor not in allowed_values: + raise ValueError( + "Invalid value for `is_explosive_precursor` ({0}), must be one of {1}" # noqa: E501 + .format(is_explosive_precursor, allowed_values) + ) + + self._is_explosive_precursor = is_explosive_precursor + + @property + def is_cmr(self): + """Gets the is_cmr of this Compound. # noqa: E501 + + + :return: The is_cmr of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_cmr + + @is_cmr.setter + def is_cmr(self, is_cmr): + """Sets the is_cmr of this Compound. + + + :param is_cmr: The is_cmr of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_cmr not in allowed_values: + raise ValueError( + "Invalid value for `is_cmr` ({0}), must be one of {1}" # noqa: E501 + .format(is_cmr, allowed_values) + ) + + self._is_cmr = is_cmr + + @property + def is_nano(self): + """Gets the is_nano of this Compound. # noqa: E501 + + + :return: The is_nano of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_nano + + @is_nano.setter + def is_nano(self, is_nano): + """Sets the is_nano of this Compound. + + + :param is_nano: The is_nano of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_nano not in allowed_values: + raise ValueError( + "Invalid value for `is_nano` ({0}), must be one of {1}" # noqa: E501 + .format(is_nano, allowed_values) + ) + + self._is_nano = is_nano + + @property + def is_controlled(self): + """Gets the is_controlled of this Compound. # noqa: E501 + + + :return: The is_controlled of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_controlled + + @is_controlled.setter + def is_controlled(self, is_controlled): + """Sets the is_controlled of this Compound. + + + :param is_controlled: The is_controlled of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_controlled not in allowed_values: + raise ValueError( + "Invalid value for `is_controlled` ({0}), must be one of {1}" # noqa: E501 + .format(is_controlled, allowed_values) + ) + + self._is_controlled = is_controlled + + @property + def is_ed2health(self): + """Gets the is_ed2health of this Compound. # noqa: E501 + + + :return: The is_ed2health of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_ed2health + + @is_ed2health.setter + def is_ed2health(self, is_ed2health): + """Sets the is_ed2health of this Compound. + + + :param is_ed2health: The is_ed2health of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_ed2health not in allowed_values: + raise ValueError( + "Invalid value for `is_ed2health` ({0}), must be one of {1}" # noqa: E501 + .format(is_ed2health, allowed_values) + ) + + self._is_ed2health = is_ed2health + + @property + def is_ed2env(self): + """Gets the is_ed2env of this Compound. # noqa: E501 + + + :return: The is_ed2env of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_ed2env + + @is_ed2env.setter + def is_ed2env(self, is_ed2env): + """Sets the is_ed2env of this Compound. + + + :param is_ed2env: The is_ed2env of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_ed2env not in allowed_values: + raise ValueError( + "Invalid value for `is_ed2env` ({0}), must be one of {1}" # noqa: E501 + .format(is_ed2env, allowed_values) + ) + + self._is_ed2env = is_ed2env + + @property + def is_pbt(self): + """Gets the is_pbt of this Compound. # noqa: E501 + + + :return: The is_pbt of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_pbt + + @is_pbt.setter + def is_pbt(self, is_pbt): + """Sets the is_pbt of this Compound. + + + :param is_pbt: The is_pbt of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_pbt not in allowed_values: + raise ValueError( + "Invalid value for `is_pbt` ({0}), must be one of {1}" # noqa: E501 + .format(is_pbt, allowed_values) + ) + + self._is_pbt = is_pbt + + @property + def is_pmt(self): + """Gets the is_pmt of this Compound. # noqa: E501 + + + :return: The is_pmt of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_pmt + + @is_pmt.setter + def is_pmt(self, is_pmt): + """Sets the is_pmt of this Compound. + + + :param is_pmt: The is_pmt of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_pmt not in allowed_values: + raise ValueError( + "Invalid value for `is_pmt` ({0}), must be one of {1}" # noqa: E501 + .format(is_pmt, allowed_values) + ) + + self._is_pmt = is_pmt + + @property + def is_vpvb(self): + """Gets the is_vpvb of this Compound. # noqa: E501 + + + :return: The is_vpvb of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_vpvb + + @is_vpvb.setter + def is_vpvb(self, is_vpvb): + """Sets the is_vpvb of this Compound. + + + :param is_vpvb: The is_vpvb of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_vpvb not in allowed_values: + raise ValueError( + "Invalid value for `is_vpvb` ({0}), must be one of {1}" # noqa: E501 + .format(is_vpvb, allowed_values) + ) + + self._is_vpvb = is_vpvb + + @property + def is_vpvm(self): + """Gets the is_vpvm of this Compound. # noqa: E501 + + + :return: The is_vpvm of this Compound. # noqa: E501 + :rtype: int + """ + return self._is_vpvm + + @is_vpvm.setter + def is_vpvm(self, is_vpvm): + """Sets the is_vpvm of this Compound. + + + :param is_vpvm: The is_vpvm of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_vpvm not in allowed_values: + raise ValueError( + "Invalid value for `is_vpvm` ({0}), must be one of {1}" # noqa: E501 + .format(is_vpvm, allowed_values) + ) + + self._is_vpvm = is_vpvm + + @property + def fp2_base64(self): + """Gets the fp2_base64 of this Compound. # noqa: E501 + + Base64-encoded fingerprint # noqa: E501 + + :return: The fp2_base64 of this Compound. # noqa: E501 + :rtype: str + """ + return self._fp2_base64 + + @fp2_base64.setter + def fp2_base64(self, fp2_base64): + """Sets the fp2_base64 of this Compound. + + Base64-encoded fingerprint # noqa: E501 + + :param fp2_base64: The fp2_base64 of this Compound. # noqa: E501 + :type: str + """ + + self._fp2_base64 = fp2_base64 + + @property + def userid_human(self): + """Gets the userid_human of this Compound. # noqa: E501 + + + :return: The userid_human of this Compound. # noqa: E501 + :rtype: str + """ + return self._userid_human + + @userid_human.setter + def userid_human(self, userid_human): + """Sets the userid_human of this Compound. + + + :param userid_human: The userid_human of this Compound. # noqa: E501 + :type: str + """ + + self._userid_human = userid_human + + @property + def team_name(self): + """Gets the team_name of this Compound. # noqa: E501 + + + :return: The team_name of this Compound. # noqa: E501 + :rtype: str + """ + return self._team_name + + @team_name.setter + def team_name(self, team_name): + """Sets the team_name of this Compound. + + + :param team_name: The team_name of this Compound. # noqa: E501 + :type: str + """ + + self._team_name = team_name + + @property + def has_fingerprint(self): + """Gets the has_fingerprint of this Compound. # noqa: E501 + + + :return: The has_fingerprint of this Compound. # noqa: E501 + :rtype: int + """ + return self._has_fingerprint + + @has_fingerprint.setter + def has_fingerprint(self, has_fingerprint): + """Sets the has_fingerprint of this Compound. + + + :param has_fingerprint: The has_fingerprint of this Compound. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if has_fingerprint not in allowed_values: + raise ValueError( + "Invalid value for `has_fingerprint` ({0}), must be one of {1}" # noqa: E501 + .format(has_fingerprint, allowed_values) + ) + + self._has_fingerprint = has_fingerprint + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Compound, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Compound): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/compound_create_request.py b/vendor/elabapi-python/elabapi_python/models/compound_create_request.py new file mode 100644 index 0000000..ff0a730 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/compound_create_request.py @@ -0,0 +1,614 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class CompoundCreateRequest(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'action': 'str', + 'name': 'str', + 'inchi': 'str', + 'inchi_key': 'str', + 'smiles': 'str', + 'molecular_formula': 'str', + 'cas_number': 'str', + 'iupac_name': 'str', + 'pubchem_cid': 'int', + 'is_corrosive': 'int', + 'is_serious_health_hazard': 'int', + 'is_explosive': 'int', + 'is_flammable': 'int', + 'is_gas_under_pressure': 'int', + 'is_hazardous2env': 'int', + 'is_hazardous2health': 'int', + 'is_oxidising': 'int', + 'is_toxic': 'int' + } + + attribute_map = { + 'action': 'action', + 'name': 'name', + 'inchi': 'inchi', + 'inchi_key': 'inchi_key', + 'smiles': 'smiles', + 'molecular_formula': 'molecular_formula', + 'cas_number': 'cas_number', + 'iupac_name': 'iupac_name', + 'pubchem_cid': 'pubchem_cid', + 'is_corrosive': 'is_corrosive', + 'is_serious_health_hazard': 'is_serious_health_hazard', + 'is_explosive': 'is_explosive', + 'is_flammable': 'is_flammable', + 'is_gas_under_pressure': 'is_gas_under_pressure', + 'is_hazardous2env': 'is_hazardous2env', + 'is_hazardous2health': 'is_hazardous2health', + 'is_oxidising': 'is_oxidising', + 'is_toxic': 'is_toxic' + } + + def __init__(self, action='create', name=None, inchi=None, inchi_key=None, smiles=None, molecular_formula=None, cas_number=None, iupac_name=None, pubchem_cid=None, is_corrosive=None, is_serious_health_hazard=None, is_explosive=None, is_flammable=None, is_gas_under_pressure=None, is_hazardous2env=None, is_hazardous2health=None, is_oxidising=None, is_toxic=None): # noqa: E501 + """CompoundCreateRequest - a model defined in Swagger""" # noqa: E501 + self._action = None + self._name = None + self._inchi = None + self._inchi_key = None + self._smiles = None + self._molecular_formula = None + self._cas_number = None + self._iupac_name = None + self._pubchem_cid = None + self._is_corrosive = None + self._is_serious_health_hazard = None + self._is_explosive = None + self._is_flammable = None + self._is_gas_under_pressure = None + self._is_hazardous2env = None + self._is_hazardous2health = None + self._is_oxidising = None + self._is_toxic = None + self.discriminator = None + if action is not None: + self.action = action + if name is not None: + self.name = name + if inchi is not None: + self.inchi = inchi + if inchi_key is not None: + self.inchi_key = inchi_key + if smiles is not None: + self.smiles = smiles + if molecular_formula is not None: + self.molecular_formula = molecular_formula + if cas_number is not None: + self.cas_number = cas_number + if iupac_name is not None: + self.iupac_name = iupac_name + if pubchem_cid is not None: + self.pubchem_cid = pubchem_cid + if is_corrosive is not None: + self.is_corrosive = is_corrosive + if is_serious_health_hazard is not None: + self.is_serious_health_hazard = is_serious_health_hazard + if is_explosive is not None: + self.is_explosive = is_explosive + if is_flammable is not None: + self.is_flammable = is_flammable + if is_gas_under_pressure is not None: + self.is_gas_under_pressure = is_gas_under_pressure + if is_hazardous2env is not None: + self.is_hazardous2env = is_hazardous2env + if is_hazardous2health is not None: + self.is_hazardous2health = is_hazardous2health + if is_oxidising is not None: + self.is_oxidising = is_oxidising + if is_toxic is not None: + self.is_toxic = is_toxic + + @property + def action(self): + """Gets the action of this CompoundCreateRequest. # noqa: E501 + + Note: the default value for `action` attribute is `create`, and as such it can be omitted. # noqa: E501 + + :return: The action of this CompoundCreateRequest. # noqa: E501 + :rtype: str + """ + return self._action + + @action.setter + def action(self, action): + """Sets the action of this CompoundCreateRequest. + + Note: the default value for `action` attribute is `create`, and as such it can be omitted. # noqa: E501 + + :param action: The action of this CompoundCreateRequest. # noqa: E501 + :type: str + """ + allowed_values = ["create"] # noqa: E501 + if action not in allowed_values: + raise ValueError( + "Invalid value for `action` ({0}), must be one of {1}" # noqa: E501 + .format(action, allowed_values) + ) + + self._action = action + + @property + def name(self): + """Gets the name of this CompoundCreateRequest. # noqa: E501 + + + :return: The name of this CompoundCreateRequest. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this CompoundCreateRequest. + + + :param name: The name of this CompoundCreateRequest. # noqa: E501 + :type: str + """ + + self._name = name + + @property + def inchi(self): + """Gets the inchi of this CompoundCreateRequest. # noqa: E501 + + + :return: The inchi of this CompoundCreateRequest. # noqa: E501 + :rtype: str + """ + return self._inchi + + @inchi.setter + def inchi(self, inchi): + """Sets the inchi of this CompoundCreateRequest. + + + :param inchi: The inchi of this CompoundCreateRequest. # noqa: E501 + :type: str + """ + + self._inchi = inchi + + @property + def inchi_key(self): + """Gets the inchi_key of this CompoundCreateRequest. # noqa: E501 + + + :return: The inchi_key of this CompoundCreateRequest. # noqa: E501 + :rtype: str + """ + return self._inchi_key + + @inchi_key.setter + def inchi_key(self, inchi_key): + """Sets the inchi_key of this CompoundCreateRequest. + + + :param inchi_key: The inchi_key of this CompoundCreateRequest. # noqa: E501 + :type: str + """ + + self._inchi_key = inchi_key + + @property + def smiles(self): + """Gets the smiles of this CompoundCreateRequest. # noqa: E501 + + + :return: The smiles of this CompoundCreateRequest. # noqa: E501 + :rtype: str + """ + return self._smiles + + @smiles.setter + def smiles(self, smiles): + """Sets the smiles of this CompoundCreateRequest. + + + :param smiles: The smiles of this CompoundCreateRequest. # noqa: E501 + :type: str + """ + + self._smiles = smiles + + @property + def molecular_formula(self): + """Gets the molecular_formula of this CompoundCreateRequest. # noqa: E501 + + + :return: The molecular_formula of this CompoundCreateRequest. # noqa: E501 + :rtype: str + """ + return self._molecular_formula + + @molecular_formula.setter + def molecular_formula(self, molecular_formula): + """Sets the molecular_formula of this CompoundCreateRequest. + + + :param molecular_formula: The molecular_formula of this CompoundCreateRequest. # noqa: E501 + :type: str + """ + + self._molecular_formula = molecular_formula + + @property + def cas_number(self): + """Gets the cas_number of this CompoundCreateRequest. # noqa: E501 + + + :return: The cas_number of this CompoundCreateRequest. # noqa: E501 + :rtype: str + """ + return self._cas_number + + @cas_number.setter + def cas_number(self, cas_number): + """Sets the cas_number of this CompoundCreateRequest. + + + :param cas_number: The cas_number of this CompoundCreateRequest. # noqa: E501 + :type: str + """ + + self._cas_number = cas_number + + @property + def iupac_name(self): + """Gets the iupac_name of this CompoundCreateRequest. # noqa: E501 + + + :return: The iupac_name of this CompoundCreateRequest. # noqa: E501 + :rtype: str + """ + return self._iupac_name + + @iupac_name.setter + def iupac_name(self, iupac_name): + """Sets the iupac_name of this CompoundCreateRequest. + + + :param iupac_name: The iupac_name of this CompoundCreateRequest. # noqa: E501 + :type: str + """ + + self._iupac_name = iupac_name + + @property + def pubchem_cid(self): + """Gets the pubchem_cid of this CompoundCreateRequest. # noqa: E501 + + + :return: The pubchem_cid of this CompoundCreateRequest. # noqa: E501 + :rtype: int + """ + return self._pubchem_cid + + @pubchem_cid.setter + def pubchem_cid(self, pubchem_cid): + """Sets the pubchem_cid of this CompoundCreateRequest. + + + :param pubchem_cid: The pubchem_cid of this CompoundCreateRequest. # noqa: E501 + :type: int + """ + + self._pubchem_cid = pubchem_cid + + @property + def is_corrosive(self): + """Gets the is_corrosive of this CompoundCreateRequest. # noqa: E501 + + + :return: The is_corrosive of this CompoundCreateRequest. # noqa: E501 + :rtype: int + """ + return self._is_corrosive + + @is_corrosive.setter + def is_corrosive(self, is_corrosive): + """Sets the is_corrosive of this CompoundCreateRequest. + + + :param is_corrosive: The is_corrosive of this CompoundCreateRequest. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_corrosive not in allowed_values: + raise ValueError( + "Invalid value for `is_corrosive` ({0}), must be one of {1}" # noqa: E501 + .format(is_corrosive, allowed_values) + ) + + self._is_corrosive = is_corrosive + + @property + def is_serious_health_hazard(self): + """Gets the is_serious_health_hazard of this CompoundCreateRequest. # noqa: E501 + + + :return: The is_serious_health_hazard of this CompoundCreateRequest. # noqa: E501 + :rtype: int + """ + return self._is_serious_health_hazard + + @is_serious_health_hazard.setter + def is_serious_health_hazard(self, is_serious_health_hazard): + """Sets the is_serious_health_hazard of this CompoundCreateRequest. + + + :param is_serious_health_hazard: The is_serious_health_hazard of this CompoundCreateRequest. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_serious_health_hazard not in allowed_values: + raise ValueError( + "Invalid value for `is_serious_health_hazard` ({0}), must be one of {1}" # noqa: E501 + .format(is_serious_health_hazard, allowed_values) + ) + + self._is_serious_health_hazard = is_serious_health_hazard + + @property + def is_explosive(self): + """Gets the is_explosive of this CompoundCreateRequest. # noqa: E501 + + + :return: The is_explosive of this CompoundCreateRequest. # noqa: E501 + :rtype: int + """ + return self._is_explosive + + @is_explosive.setter + def is_explosive(self, is_explosive): + """Sets the is_explosive of this CompoundCreateRequest. + + + :param is_explosive: The is_explosive of this CompoundCreateRequest. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_explosive not in allowed_values: + raise ValueError( + "Invalid value for `is_explosive` ({0}), must be one of {1}" # noqa: E501 + .format(is_explosive, allowed_values) + ) + + self._is_explosive = is_explosive + + @property + def is_flammable(self): + """Gets the is_flammable of this CompoundCreateRequest. # noqa: E501 + + + :return: The is_flammable of this CompoundCreateRequest. # noqa: E501 + :rtype: int + """ + return self._is_flammable + + @is_flammable.setter + def is_flammable(self, is_flammable): + """Sets the is_flammable of this CompoundCreateRequest. + + + :param is_flammable: The is_flammable of this CompoundCreateRequest. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_flammable not in allowed_values: + raise ValueError( + "Invalid value for `is_flammable` ({0}), must be one of {1}" # noqa: E501 + .format(is_flammable, allowed_values) + ) + + self._is_flammable = is_flammable + + @property + def is_gas_under_pressure(self): + """Gets the is_gas_under_pressure of this CompoundCreateRequest. # noqa: E501 + + + :return: The is_gas_under_pressure of this CompoundCreateRequest. # noqa: E501 + :rtype: int + """ + return self._is_gas_under_pressure + + @is_gas_under_pressure.setter + def is_gas_under_pressure(self, is_gas_under_pressure): + """Sets the is_gas_under_pressure of this CompoundCreateRequest. + + + :param is_gas_under_pressure: The is_gas_under_pressure of this CompoundCreateRequest. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_gas_under_pressure not in allowed_values: + raise ValueError( + "Invalid value for `is_gas_under_pressure` ({0}), must be one of {1}" # noqa: E501 + .format(is_gas_under_pressure, allowed_values) + ) + + self._is_gas_under_pressure = is_gas_under_pressure + + @property + def is_hazardous2env(self): + """Gets the is_hazardous2env of this CompoundCreateRequest. # noqa: E501 + + + :return: The is_hazardous2env of this CompoundCreateRequest. # noqa: E501 + :rtype: int + """ + return self._is_hazardous2env + + @is_hazardous2env.setter + def is_hazardous2env(self, is_hazardous2env): + """Sets the is_hazardous2env of this CompoundCreateRequest. + + + :param is_hazardous2env: The is_hazardous2env of this CompoundCreateRequest. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_hazardous2env not in allowed_values: + raise ValueError( + "Invalid value for `is_hazardous2env` ({0}), must be one of {1}" # noqa: E501 + .format(is_hazardous2env, allowed_values) + ) + + self._is_hazardous2env = is_hazardous2env + + @property + def is_hazardous2health(self): + """Gets the is_hazardous2health of this CompoundCreateRequest. # noqa: E501 + + + :return: The is_hazardous2health of this CompoundCreateRequest. # noqa: E501 + :rtype: int + """ + return self._is_hazardous2health + + @is_hazardous2health.setter + def is_hazardous2health(self, is_hazardous2health): + """Sets the is_hazardous2health of this CompoundCreateRequest. + + + :param is_hazardous2health: The is_hazardous2health of this CompoundCreateRequest. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_hazardous2health not in allowed_values: + raise ValueError( + "Invalid value for `is_hazardous2health` ({0}), must be one of {1}" # noqa: E501 + .format(is_hazardous2health, allowed_values) + ) + + self._is_hazardous2health = is_hazardous2health + + @property + def is_oxidising(self): + """Gets the is_oxidising of this CompoundCreateRequest. # noqa: E501 + + + :return: The is_oxidising of this CompoundCreateRequest. # noqa: E501 + :rtype: int + """ + return self._is_oxidising + + @is_oxidising.setter + def is_oxidising(self, is_oxidising): + """Sets the is_oxidising of this CompoundCreateRequest. + + + :param is_oxidising: The is_oxidising of this CompoundCreateRequest. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_oxidising not in allowed_values: + raise ValueError( + "Invalid value for `is_oxidising` ({0}), must be one of {1}" # noqa: E501 + .format(is_oxidising, allowed_values) + ) + + self._is_oxidising = is_oxidising + + @property + def is_toxic(self): + """Gets the is_toxic of this CompoundCreateRequest. # noqa: E501 + + + :return: The is_toxic of this CompoundCreateRequest. # noqa: E501 + :rtype: int + """ + return self._is_toxic + + @is_toxic.setter + def is_toxic(self, is_toxic): + """Sets the is_toxic of this CompoundCreateRequest. + + + :param is_toxic: The is_toxic of this CompoundCreateRequest. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_toxic not in allowed_values: + raise ValueError( + "Invalid value for `is_toxic` ({0}), must be one of {1}" # noqa: E501 + .format(is_toxic, allowed_values) + ) + + self._is_toxic = is_toxic + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(CompoundCreateRequest, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, CompoundCreateRequest): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/compound_duplicate_request.py b/vendor/elabapi-python/elabapi_python/models/compound_duplicate_request.py new file mode 100644 index 0000000..24f6547 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/compound_duplicate_request.py @@ -0,0 +1,173 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class CompoundDuplicateRequest(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'action': 'str', + 'cid': 'int', + 'cas': 'str' + } + + attribute_map = { + 'action': 'action', + 'cid': 'cid', + 'cas': 'cas' + } + + def __init__(self, action=None, cid=None, cas=None): # noqa: E501 + """CompoundDuplicateRequest - a model defined in Swagger""" # noqa: E501 + self._action = None + self._cid = None + self._cas = None + self.discriminator = None + self.action = action + if cid is not None: + self.cid = cid + if cas is not None: + self.cas = cas + + @property + def action(self): + """Gets the action of this CompoundDuplicateRequest. # noqa: E501 + + + :return: The action of this CompoundDuplicateRequest. # noqa: E501 + :rtype: str + """ + return self._action + + @action.setter + def action(self, action): + """Sets the action of this CompoundDuplicateRequest. + + + :param action: The action of this CompoundDuplicateRequest. # noqa: E501 + :type: str + """ + if action is None: + raise ValueError("Invalid value for `action`, must not be `None`") # noqa: E501 + allowed_values = ["duplicate"] # noqa: E501 + if action not in allowed_values: + raise ValueError( + "Invalid value for `action` ({0}), must be one of {1}" # noqa: E501 + .format(action, allowed_values) + ) + + self._action = action + + @property + def cid(self): + """Gets the cid of this CompoundDuplicateRequest. # noqa: E501 + + PubChem Compound ID (CID). Use it to find a compound via this unique identifier. Not compatible with `cas` parameter. # noqa: E501 + + :return: The cid of this CompoundDuplicateRequest. # noqa: E501 + :rtype: int + """ + return self._cid + + @cid.setter + def cid(self, cid): + """Sets the cid of this CompoundDuplicateRequest. + + PubChem Compound ID (CID). Use it to find a compound via this unique identifier. Not compatible with `cas` parameter. # noqa: E501 + + :param cid: The cid of this CompoundDuplicateRequest. # noqa: E501 + :type: int + """ + + self._cid = cid + + @property + def cas(self): + """Gets the cas of this CompoundDuplicateRequest. # noqa: E501 + + CAS number. Use it to find a compound via this unique identifier. Not compatible with `cid` parameter. # noqa: E501 + + :return: The cas of this CompoundDuplicateRequest. # noqa: E501 + :rtype: str + """ + return self._cas + + @cas.setter + def cas(self, cas): + """Sets the cas of this CompoundDuplicateRequest. + + CAS number. Use it to find a compound via this unique identifier. Not compatible with `cid` parameter. # noqa: E501 + + :param cas: The cas of this CompoundDuplicateRequest. # noqa: E501 + :type: str + """ + + self._cas = cas + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(CompoundDuplicateRequest, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, CompoundDuplicateRequest): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/compounds_body.py b/vendor/elabapi-python/elabapi_python/models/compounds_body.py new file mode 100644 index 0000000..8f23084 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/compounds_body.py @@ -0,0 +1,84 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class CompoundsBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + } + + attribute_map = { + } + + def __init__(self): # noqa: E501 + """CompoundsBody - a model defined in Swagger""" # noqa: E501 + self.discriminator = None + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(CompoundsBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, CompoundsBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/compounds_links_subid_body.py b/vendor/elabapi-python/elabapi_python/models/compounds_links_subid_body.py new file mode 100644 index 0000000..db4a4fb --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/compounds_links_subid_body.py @@ -0,0 +1,118 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class CompoundsLinksSubidBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'action': 'str' + } + + attribute_map = { + 'action': 'action' + } + + def __init__(self, action=None): # noqa: E501 + """CompoundsLinksSubidBody - a model defined in Swagger""" # noqa: E501 + self._action = None + self.discriminator = None + if action is not None: + self.action = action + + @property + def action(self): + """Gets the action of this CompoundsLinksSubidBody. # noqa: E501 + + The `create` action will create the link. # noqa: E501 + + :return: The action of this CompoundsLinksSubidBody. # noqa: E501 + :rtype: str + """ + return self._action + + @action.setter + def action(self, action): + """Sets the action of this CompoundsLinksSubidBody. + + The `create` action will create the link. # noqa: E501 + + :param action: The action of this CompoundsLinksSubidBody. # noqa: E501 + :type: str + """ + allowed_values = ["create"] # noqa: E501 + if action not in allowed_values: + raise ValueError( + "Invalid value for `action` ({0}), must be one of {1}" # noqa: E501 + .format(action, allowed_values) + ) + + self._action = action + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(CompoundsLinksSubidBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, CompoundsLinksSubidBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/config.py b/vendor/elabapi-python/elabapi_python/models/config.py new file mode 100644 index 0000000..d6bec76 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/config.py @@ -0,0 +1,2890 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Config(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'admins_create_users': 'str', + 'admins_create_users_remote_dir': 'str', + 'admin_panel_custom_msg': 'str', + 'admin_validate': 'str', + 'allow_permission_full': 'str', + 'allow_permission_organization': 'str', + 'allow_permission_team': 'str', + 'allow_permission_user': 'str', + 'allow_permission_useronly': 'str', + 'announcement': 'str', + 'anon_users': 'str', + 'autologout_time': 'str', + 'blox_anon': 'str', + 'blox_enabled': 'str', + 'chat_url': 'str', + 'cookie_validity_time': 'int', + 'dspace_host': 'str', + 'dspace_user': 'str', + 'dspace_password': 'str', + 'email_domain': 'str', + 'extauth_email': 'str', + 'extauth_firstname': 'str', + 'extauth_lastname': 'str', + 'extauth_remote_user': 'str', + 'extauth_teams': 'str', + 'lang': 'str', + 'ldap_base_dn': 'str', + 'ldap_search_attr': 'str', + 'ldap_email': 'str', + 'ldap_firstname': 'str', + 'ldap_host': 'str', + 'ldap_lastname': 'str', + 'ldap_password': 'str', + 'ldap_port': 'str', + 'ldap_sync_teams': 'str', + 'ldap_team': 'str', + 'ldap_team_create': 'str', + 'ldap_toggle': 'str', + 'ldap_use_tls': 'str', + 'ldap_username': 'str', + 'local_login': 'str', + 'local_register': 'str', + 'login_announcement': 'str', + 'login_tries': 'str', + 'logout_url': 'str', + 'mail_from': 'str', + 'max_revisions': 'str', + 'min_days_revisions': 'str', + 'min_delta_revisions': 'str', + 'onboarding_email_active': 'str', + 'onboarding_email_admins_body': 'str', + 'onboarding_email_admins_subject': 'str', + 'onboarding_email_body': 'str', + 'onboarding_email_different_for_admins': 'str', + 'onboarding_email_subject': 'str', + 'privacy_policy': 'str', + 'proxy': 'str', + 'remote_dir_config': 'str', + 'remote_dir_service': 'str', + 's3_bucket_name': 'str', + 's3_endpoint': 'str', + 's3_path_prefix': 'str', + 's3_region': 'str', + 's3_verify_cert': 'str', + 'saml_allowrepeatattributename': 'str', + 'saml_authnrequestssigned': 'str', + 'saml_baseurl': 'str', + 'saml_debug': 'str', + 'saml_entityid': 'str', + 'saml_logoutrequestsigned': 'str', + 'saml_logoutresponsesigned': 'str', + 'saml_lowercaseurlencoding': 'str', + 'saml_nameidencrypted': 'str', + 'saml_nameidformat': 'str', + 'saml_privatekey': 'str', + 'saml_relaxdestinationvalidation': 'str', + 'saml_signmetadata': 'str', + 'saml_strict': 'str', + 'saml_sync_teams': 'str', + 'saml_team_create': 'str', + 'saml_team_default': 'str', + 'saml_toggle': 'str', + 'saml_user_default': 'str', + 'saml_wantassertionsencrypted': 'str', + 'saml_wantassertionssigned': 'str', + 'saml_wantmessagessigned': 'str', + 'saml_wantnameid': 'str', + 'saml_wantnameidencrypted': 'str', + 'saml_wantxmlvalidation': 'str', + 'saml_x509': 'str', + 'saml_x509_new': 'str', + 'schema': 'str', + 'smtp_address': 'str', + 'smtp_encryption': 'str', + 'smtp_password': 'str', + 'smtp_port': 'str', + 'smtp_username': 'str', + 'support_url': 'str', + 'ts_authority': 'str', + 'ts_cert': 'str', + 'ts_hash': 'str', + 'ts_limit': 'str', + 'ts_login': 'str', + 'ts_password': 'str', + 'ts_url': 'str', + 'uploads_storage': 'str', + 'users_validity_is_externally_managed': 'str' + } + + attribute_map = { + 'admins_create_users': 'admins_create_users', + 'admins_create_users_remote_dir': 'admins_create_users_remote_dir', + 'admin_panel_custom_msg': 'admin_panel_custom_msg', + 'admin_validate': 'admin_validate', + 'allow_permission_full': 'allow_permission_full', + 'allow_permission_organization': 'allow_permission_organization', + 'allow_permission_team': 'allow_permission_team', + 'allow_permission_user': 'allow_permission_user', + 'allow_permission_useronly': 'allow_permission_useronly', + 'announcement': 'announcement', + 'anon_users': 'anon_users', + 'autologout_time': 'autologout_time', + 'blox_anon': 'blox_anon', + 'blox_enabled': 'blox_enabled', + 'chat_url': 'chat_url', + 'cookie_validity_time': 'cookie_validity_time', + 'dspace_host': 'dspace_host', + 'dspace_user': 'dspace_user', + 'dspace_password': 'dspace_password', + 'email_domain': 'email_domain', + 'extauth_email': 'extauth_email', + 'extauth_firstname': 'extauth_firstname', + 'extauth_lastname': 'extauth_lastname', + 'extauth_remote_user': 'extauth_remote_user', + 'extauth_teams': 'extauth_teams', + 'lang': 'lang', + 'ldap_base_dn': 'ldap_base_dn', + 'ldap_search_attr': 'ldap_search_attr', + 'ldap_email': 'ldap_email', + 'ldap_firstname': 'ldap_firstname', + 'ldap_host': 'ldap_host', + 'ldap_lastname': 'ldap_lastname', + 'ldap_password': 'ldap_password', + 'ldap_port': 'ldap_port', + 'ldap_sync_teams': 'ldap_sync_teams', + 'ldap_team': 'ldap_team', + 'ldap_team_create': 'ldap_team_create', + 'ldap_toggle': 'ldap_toggle', + 'ldap_use_tls': 'ldap_use_tls', + 'ldap_username': 'ldap_username', + 'local_login': 'local_login', + 'local_register': 'local_register', + 'login_announcement': 'login_announcement', + 'login_tries': 'login_tries', + 'logout_url': 'logout_url', + 'mail_from': 'mail_from', + 'max_revisions': 'max_revisions', + 'min_days_revisions': 'min_days_revisions', + 'min_delta_revisions': 'min_delta_revisions', + 'onboarding_email_active': 'onboarding_email_active', + 'onboarding_email_admins_body': 'onboarding_email_admins_body', + 'onboarding_email_admins_subject': 'onboarding_email_admins_subject', + 'onboarding_email_body': 'onboarding_email_body', + 'onboarding_email_different_for_admins': 'onboarding_email_different_for_admins', + 'onboarding_email_subject': 'onboarding_email_subject', + 'privacy_policy': 'privacy_policy', + 'proxy': 'proxy', + 'remote_dir_config': 'remote_dir_config', + 'remote_dir_service': 'remote_dir_service', + 's3_bucket_name': 's3_bucket_name', + 's3_endpoint': 's3_endpoint', + 's3_path_prefix': 's3_path_prefix', + 's3_region': 's3_region', + 's3_verify_cert': 's3_verify_cert', + 'saml_allowrepeatattributename': 'saml_allowrepeatattributename', + 'saml_authnrequestssigned': 'saml_authnrequestssigned', + 'saml_baseurl': 'saml_baseurl', + 'saml_debug': 'saml_debug', + 'saml_entityid': 'saml_entityid', + 'saml_logoutrequestsigned': 'saml_logoutrequestsigned', + 'saml_logoutresponsesigned': 'saml_logoutresponsesigned', + 'saml_lowercaseurlencoding': 'saml_lowercaseurlencoding', + 'saml_nameidencrypted': 'saml_nameidencrypted', + 'saml_nameidformat': 'saml_nameidformat', + 'saml_privatekey': 'saml_privatekey', + 'saml_relaxdestinationvalidation': 'saml_relaxdestinationvalidation', + 'saml_signmetadata': 'saml_signmetadata', + 'saml_strict': 'saml_strict', + 'saml_sync_teams': 'saml_sync_teams', + 'saml_team_create': 'saml_team_create', + 'saml_team_default': 'saml_team_default', + 'saml_toggle': 'saml_toggle', + 'saml_user_default': 'saml_user_default', + 'saml_wantassertionsencrypted': 'saml_wantassertionsencrypted', + 'saml_wantassertionssigned': 'saml_wantassertionssigned', + 'saml_wantmessagessigned': 'saml_wantmessagessigned', + 'saml_wantnameid': 'saml_wantnameid', + 'saml_wantnameidencrypted': 'saml_wantnameidencrypted', + 'saml_wantxmlvalidation': 'saml_wantxmlvalidation', + 'saml_x509': 'saml_x509', + 'saml_x509_new': 'saml_x509_new', + 'schema': 'schema', + 'smtp_address': 'smtp_address', + 'smtp_encryption': 'smtp_encryption', + 'smtp_password': 'smtp_password', + 'smtp_port': 'smtp_port', + 'smtp_username': 'smtp_username', + 'support_url': 'support_url', + 'ts_authority': 'ts_authority', + 'ts_cert': 'ts_cert', + 'ts_hash': 'ts_hash', + 'ts_limit': 'ts_limit', + 'ts_login': 'ts_login', + 'ts_password': 'ts_password', + 'ts_url': 'ts_url', + 'uploads_storage': 'uploads_storage', + 'users_validity_is_externally_managed': 'users_validity_is_externally_managed' + } + + def __init__(self, admins_create_users='1', admins_create_users_remote_dir='0', admin_panel_custom_msg='', admin_validate='0', allow_permission_full='1', allow_permission_organization='1', allow_permission_team='1', allow_permission_user='1', allow_permission_useronly='1', announcement=None, anon_users='1', autologout_time='0', blox_anon='0', blox_enabled='1', chat_url='https://gitter.im/elabftw/elabftw', cookie_validity_time=43200, dspace_host='https://demo.dspace.org/', dspace_user='dspacedemo+admin@gmail.com', dspace_password='', email_domain=None, extauth_email='', extauth_firstname='', extauth_lastname='', extauth_remote_user='', extauth_teams='', lang='en_GB', ldap_base_dn='dc=example,dc=org', ldap_search_attr='mail', ldap_email='mail', ldap_firstname='givenname', ldap_host='ldap', ldap_lastname='cn', ldap_password='admin', ldap_port='389', ldap_sync_teams='0', ldap_team='on', ldap_team_create='0', ldap_toggle='0', ldap_use_tls='0', ldap_username='cn=admin,dc=example,dc=org', local_login='1', local_register='1', login_announcement=None, login_tries='10', logout_url='', mail_from='notconfigured@example.com', max_revisions='10', min_days_revisions='23', min_delta_revisions='100', onboarding_email_active='1', onboarding_email_admins_body='

Test email body for admins.

', onboarding_email_admins_subject='subject for admins', onboarding_email_body='

Test email body for users.

', onboarding_email_different_for_admins='1', onboarding_email_subject='test email subject', privacy_policy=None, proxy='', remote_dir_config='', remote_dir_service='eairef', s3_bucket_name='', s3_endpoint='', s3_path_prefix='', s3_region='fr-par-42', s3_verify_cert='1', saml_allowrepeatattributename='0', saml_authnrequestssigned='0', saml_baseurl=None, saml_debug='0', saml_entityid=None, saml_logoutrequestsigned='0', saml_logoutresponsesigned='0', saml_lowercaseurlencoding='0', saml_nameidencrypted='0', saml_nameidformat='urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress', saml_privatekey=None, saml_relaxdestinationvalidation='0', saml_signmetadata='0', saml_strict='1', saml_sync_teams='0', saml_team_create='1', saml_team_default='-1', saml_toggle='0', saml_user_default='1', saml_wantassertionsencrypted='0', saml_wantassertionssigned='0', saml_wantmessagessigned='0', saml_wantnameid='1', saml_wantnameidencrypted='0', saml_wantxmlvalidation='1', saml_x509=None, saml_x509_new=None, schema='196', smtp_address='mail.smtp2go.com', smtp_encryption='ssl', smtp_password='', smtp_port='587', smtp_username='', support_url='https://github.com/elabftw/elabftw/issues', ts_authority='dfn', ts_cert=None, ts_hash='sha256', ts_limit='0', ts_login=None, ts_password='', ts_url=None, uploads_storage='1', users_validity_is_externally_managed='0'): # noqa: E501 + """Config - a model defined in Swagger""" # noqa: E501 + self._admins_create_users = None + self._admins_create_users_remote_dir = None + self._admin_panel_custom_msg = None + self._admin_validate = None + self._allow_permission_full = None + self._allow_permission_organization = None + self._allow_permission_team = None + self._allow_permission_user = None + self._allow_permission_useronly = None + self._announcement = None + self._anon_users = None + self._autologout_time = None + self._blox_anon = None + self._blox_enabled = None + self._chat_url = None + self._cookie_validity_time = None + self._dspace_host = None + self._dspace_user = None + self._dspace_password = None + self._email_domain = None + self._extauth_email = None + self._extauth_firstname = None + self._extauth_lastname = None + self._extauth_remote_user = None + self._extauth_teams = None + self._lang = None + self._ldap_base_dn = None + self._ldap_search_attr = None + self._ldap_email = None + self._ldap_firstname = None + self._ldap_host = None + self._ldap_lastname = None + self._ldap_password = None + self._ldap_port = None + self._ldap_sync_teams = None + self._ldap_team = None + self._ldap_team_create = None + self._ldap_toggle = None + self._ldap_use_tls = None + self._ldap_username = None + self._local_login = None + self._local_register = None + self._login_announcement = None + self._login_tries = None + self._logout_url = None + self._mail_from = None + self._max_revisions = None + self._min_days_revisions = None + self._min_delta_revisions = None + self._onboarding_email_active = None + self._onboarding_email_admins_body = None + self._onboarding_email_admins_subject = None + self._onboarding_email_body = None + self._onboarding_email_different_for_admins = None + self._onboarding_email_subject = None + self._privacy_policy = None + self._proxy = None + self._remote_dir_config = None + self._remote_dir_service = None + self._s3_bucket_name = None + self._s3_endpoint = None + self._s3_path_prefix = None + self._s3_region = None + self._s3_verify_cert = None + self._saml_allowrepeatattributename = None + self._saml_authnrequestssigned = None + self._saml_baseurl = None + self._saml_debug = None + self._saml_entityid = None + self._saml_logoutrequestsigned = None + self._saml_logoutresponsesigned = None + self._saml_lowercaseurlencoding = None + self._saml_nameidencrypted = None + self._saml_nameidformat = None + self._saml_privatekey = None + self._saml_relaxdestinationvalidation = None + self._saml_signmetadata = None + self._saml_strict = None + self._saml_sync_teams = None + self._saml_team_create = None + self._saml_team_default = None + self._saml_toggle = None + self._saml_user_default = None + self._saml_wantassertionsencrypted = None + self._saml_wantassertionssigned = None + self._saml_wantmessagessigned = None + self._saml_wantnameid = None + self._saml_wantnameidencrypted = None + self._saml_wantxmlvalidation = None + self._saml_x509 = None + self._saml_x509_new = None + self._schema = None + self._smtp_address = None + self._smtp_encryption = None + self._smtp_password = None + self._smtp_port = None + self._smtp_username = None + self._support_url = None + self._ts_authority = None + self._ts_cert = None + self._ts_hash = None + self._ts_limit = None + self._ts_login = None + self._ts_password = None + self._ts_url = None + self._uploads_storage = None + self._users_validity_is_externally_managed = None + self.discriminator = None + if admins_create_users is not None: + self.admins_create_users = admins_create_users + if admins_create_users_remote_dir is not None: + self.admins_create_users_remote_dir = admins_create_users_remote_dir + if admin_panel_custom_msg is not None: + self.admin_panel_custom_msg = admin_panel_custom_msg + if admin_validate is not None: + self.admin_validate = admin_validate + if allow_permission_full is not None: + self.allow_permission_full = allow_permission_full + if allow_permission_organization is not None: + self.allow_permission_organization = allow_permission_organization + if allow_permission_team is not None: + self.allow_permission_team = allow_permission_team + if allow_permission_user is not None: + self.allow_permission_user = allow_permission_user + if allow_permission_useronly is not None: + self.allow_permission_useronly = allow_permission_useronly + if announcement is not None: + self.announcement = announcement + if anon_users is not None: + self.anon_users = anon_users + if autologout_time is not None: + self.autologout_time = autologout_time + if blox_anon is not None: + self.blox_anon = blox_anon + if blox_enabled is not None: + self.blox_enabled = blox_enabled + if chat_url is not None: + self.chat_url = chat_url + if cookie_validity_time is not None: + self.cookie_validity_time = cookie_validity_time + if dspace_host is not None: + self.dspace_host = dspace_host + if dspace_user is not None: + self.dspace_user = dspace_user + if dspace_password is not None: + self.dspace_password = dspace_password + if email_domain is not None: + self.email_domain = email_domain + if extauth_email is not None: + self.extauth_email = extauth_email + if extauth_firstname is not None: + self.extauth_firstname = extauth_firstname + if extauth_lastname is not None: + self.extauth_lastname = extauth_lastname + if extauth_remote_user is not None: + self.extauth_remote_user = extauth_remote_user + if extauth_teams is not None: + self.extauth_teams = extauth_teams + if lang is not None: + self.lang = lang + if ldap_base_dn is not None: + self.ldap_base_dn = ldap_base_dn + if ldap_search_attr is not None: + self.ldap_search_attr = ldap_search_attr + if ldap_email is not None: + self.ldap_email = ldap_email + if ldap_firstname is not None: + self.ldap_firstname = ldap_firstname + if ldap_host is not None: + self.ldap_host = ldap_host + if ldap_lastname is not None: + self.ldap_lastname = ldap_lastname + if ldap_password is not None: + self.ldap_password = ldap_password + if ldap_port is not None: + self.ldap_port = ldap_port + if ldap_sync_teams is not None: + self.ldap_sync_teams = ldap_sync_teams + if ldap_team is not None: + self.ldap_team = ldap_team + if ldap_team_create is not None: + self.ldap_team_create = ldap_team_create + if ldap_toggle is not None: + self.ldap_toggle = ldap_toggle + if ldap_use_tls is not None: + self.ldap_use_tls = ldap_use_tls + if ldap_username is not None: + self.ldap_username = ldap_username + if local_login is not None: + self.local_login = local_login + if local_register is not None: + self.local_register = local_register + if login_announcement is not None: + self.login_announcement = login_announcement + if login_tries is not None: + self.login_tries = login_tries + if logout_url is not None: + self.logout_url = logout_url + if mail_from is not None: + self.mail_from = mail_from + if max_revisions is not None: + self.max_revisions = max_revisions + if min_days_revisions is not None: + self.min_days_revisions = min_days_revisions + if min_delta_revisions is not None: + self.min_delta_revisions = min_delta_revisions + if onboarding_email_active is not None: + self.onboarding_email_active = onboarding_email_active + if onboarding_email_admins_body is not None: + self.onboarding_email_admins_body = onboarding_email_admins_body + if onboarding_email_admins_subject is not None: + self.onboarding_email_admins_subject = onboarding_email_admins_subject + if onboarding_email_body is not None: + self.onboarding_email_body = onboarding_email_body + if onboarding_email_different_for_admins is not None: + self.onboarding_email_different_for_admins = onboarding_email_different_for_admins + if onboarding_email_subject is not None: + self.onboarding_email_subject = onboarding_email_subject + if privacy_policy is not None: + self.privacy_policy = privacy_policy + if proxy is not None: + self.proxy = proxy + if remote_dir_config is not None: + self.remote_dir_config = remote_dir_config + if remote_dir_service is not None: + self.remote_dir_service = remote_dir_service + if s3_bucket_name is not None: + self.s3_bucket_name = s3_bucket_name + if s3_endpoint is not None: + self.s3_endpoint = s3_endpoint + if s3_path_prefix is not None: + self.s3_path_prefix = s3_path_prefix + if s3_region is not None: + self.s3_region = s3_region + if s3_verify_cert is not None: + self.s3_verify_cert = s3_verify_cert + if saml_allowrepeatattributename is not None: + self.saml_allowrepeatattributename = saml_allowrepeatattributename + if saml_authnrequestssigned is not None: + self.saml_authnrequestssigned = saml_authnrequestssigned + if saml_baseurl is not None: + self.saml_baseurl = saml_baseurl + if saml_debug is not None: + self.saml_debug = saml_debug + if saml_entityid is not None: + self.saml_entityid = saml_entityid + if saml_logoutrequestsigned is not None: + self.saml_logoutrequestsigned = saml_logoutrequestsigned + if saml_logoutresponsesigned is not None: + self.saml_logoutresponsesigned = saml_logoutresponsesigned + if saml_lowercaseurlencoding is not None: + self.saml_lowercaseurlencoding = saml_lowercaseurlencoding + if saml_nameidencrypted is not None: + self.saml_nameidencrypted = saml_nameidencrypted + if saml_nameidformat is not None: + self.saml_nameidformat = saml_nameidformat + if saml_privatekey is not None: + self.saml_privatekey = saml_privatekey + if saml_relaxdestinationvalidation is not None: + self.saml_relaxdestinationvalidation = saml_relaxdestinationvalidation + if saml_signmetadata is not None: + self.saml_signmetadata = saml_signmetadata + if saml_strict is not None: + self.saml_strict = saml_strict + if saml_sync_teams is not None: + self.saml_sync_teams = saml_sync_teams + if saml_team_create is not None: + self.saml_team_create = saml_team_create + if saml_team_default is not None: + self.saml_team_default = saml_team_default + if saml_toggle is not None: + self.saml_toggle = saml_toggle + if saml_user_default is not None: + self.saml_user_default = saml_user_default + if saml_wantassertionsencrypted is not None: + self.saml_wantassertionsencrypted = saml_wantassertionsencrypted + if saml_wantassertionssigned is not None: + self.saml_wantassertionssigned = saml_wantassertionssigned + if saml_wantmessagessigned is not None: + self.saml_wantmessagessigned = saml_wantmessagessigned + if saml_wantnameid is not None: + self.saml_wantnameid = saml_wantnameid + if saml_wantnameidencrypted is not None: + self.saml_wantnameidencrypted = saml_wantnameidencrypted + if saml_wantxmlvalidation is not None: + self.saml_wantxmlvalidation = saml_wantxmlvalidation + if saml_x509 is not None: + self.saml_x509 = saml_x509 + if saml_x509_new is not None: + self.saml_x509_new = saml_x509_new + if schema is not None: + self.schema = schema + if smtp_address is not None: + self.smtp_address = smtp_address + if smtp_encryption is not None: + self.smtp_encryption = smtp_encryption + if smtp_password is not None: + self.smtp_password = smtp_password + if smtp_port is not None: + self.smtp_port = smtp_port + if smtp_username is not None: + self.smtp_username = smtp_username + if support_url is not None: + self.support_url = support_url + if ts_authority is not None: + self.ts_authority = ts_authority + if ts_cert is not None: + self.ts_cert = ts_cert + if ts_hash is not None: + self.ts_hash = ts_hash + if ts_limit is not None: + self.ts_limit = ts_limit + if ts_login is not None: + self.ts_login = ts_login + if ts_password is not None: + self.ts_password = ts_password + if ts_url is not None: + self.ts_url = ts_url + if uploads_storage is not None: + self.uploads_storage = uploads_storage + if users_validity_is_externally_managed is not None: + self.users_validity_is_externally_managed = users_validity_is_externally_managed + + @property + def admins_create_users(self): + """Gets the admins_create_users of this Config. # noqa: E501 + + + :return: The admins_create_users of this Config. # noqa: E501 + :rtype: str + """ + return self._admins_create_users + + @admins_create_users.setter + def admins_create_users(self, admins_create_users): + """Sets the admins_create_users of this Config. + + + :param admins_create_users: The admins_create_users of this Config. # noqa: E501 + :type: str + """ + + self._admins_create_users = admins_create_users + + @property + def admins_create_users_remote_dir(self): + """Gets the admins_create_users_remote_dir of this Config. # noqa: E501 + + + :return: The admins_create_users_remote_dir of this Config. # noqa: E501 + :rtype: str + """ + return self._admins_create_users_remote_dir + + @admins_create_users_remote_dir.setter + def admins_create_users_remote_dir(self, admins_create_users_remote_dir): + """Sets the admins_create_users_remote_dir of this Config. + + + :param admins_create_users_remote_dir: The admins_create_users_remote_dir of this Config. # noqa: E501 + :type: str + """ + + self._admins_create_users_remote_dir = admins_create_users_remote_dir + + @property + def admin_panel_custom_msg(self): + """Gets the admin_panel_custom_msg of this Config. # noqa: E501 + + + :return: The admin_panel_custom_msg of this Config. # noqa: E501 + :rtype: str + """ + return self._admin_panel_custom_msg + + @admin_panel_custom_msg.setter + def admin_panel_custom_msg(self, admin_panel_custom_msg): + """Sets the admin_panel_custom_msg of this Config. + + + :param admin_panel_custom_msg: The admin_panel_custom_msg of this Config. # noqa: E501 + :type: str + """ + + self._admin_panel_custom_msg = admin_panel_custom_msg + + @property + def admin_validate(self): + """Gets the admin_validate of this Config. # noqa: E501 + + + :return: The admin_validate of this Config. # noqa: E501 + :rtype: str + """ + return self._admin_validate + + @admin_validate.setter + def admin_validate(self, admin_validate): + """Sets the admin_validate of this Config. + + + :param admin_validate: The admin_validate of this Config. # noqa: E501 + :type: str + """ + + self._admin_validate = admin_validate + + @property + def allow_permission_full(self): + """Gets the allow_permission_full of this Config. # noqa: E501 + + + :return: The allow_permission_full of this Config. # noqa: E501 + :rtype: str + """ + return self._allow_permission_full + + @allow_permission_full.setter + def allow_permission_full(self, allow_permission_full): + """Sets the allow_permission_full of this Config. + + + :param allow_permission_full: The allow_permission_full of this Config. # noqa: E501 + :type: str + """ + + self._allow_permission_full = allow_permission_full + + @property + def allow_permission_organization(self): + """Gets the allow_permission_organization of this Config. # noqa: E501 + + + :return: The allow_permission_organization of this Config. # noqa: E501 + :rtype: str + """ + return self._allow_permission_organization + + @allow_permission_organization.setter + def allow_permission_organization(self, allow_permission_organization): + """Sets the allow_permission_organization of this Config. + + + :param allow_permission_organization: The allow_permission_organization of this Config. # noqa: E501 + :type: str + """ + + self._allow_permission_organization = allow_permission_organization + + @property + def allow_permission_team(self): + """Gets the allow_permission_team of this Config. # noqa: E501 + + + :return: The allow_permission_team of this Config. # noqa: E501 + :rtype: str + """ + return self._allow_permission_team + + @allow_permission_team.setter + def allow_permission_team(self, allow_permission_team): + """Sets the allow_permission_team of this Config. + + + :param allow_permission_team: The allow_permission_team of this Config. # noqa: E501 + :type: str + """ + + self._allow_permission_team = allow_permission_team + + @property + def allow_permission_user(self): + """Gets the allow_permission_user of this Config. # noqa: E501 + + + :return: The allow_permission_user of this Config. # noqa: E501 + :rtype: str + """ + return self._allow_permission_user + + @allow_permission_user.setter + def allow_permission_user(self, allow_permission_user): + """Sets the allow_permission_user of this Config. + + + :param allow_permission_user: The allow_permission_user of this Config. # noqa: E501 + :type: str + """ + + self._allow_permission_user = allow_permission_user + + @property + def allow_permission_useronly(self): + """Gets the allow_permission_useronly of this Config. # noqa: E501 + + + :return: The allow_permission_useronly of this Config. # noqa: E501 + :rtype: str + """ + return self._allow_permission_useronly + + @allow_permission_useronly.setter + def allow_permission_useronly(self, allow_permission_useronly): + """Sets the allow_permission_useronly of this Config. + + + :param allow_permission_useronly: The allow_permission_useronly of this Config. # noqa: E501 + :type: str + """ + + self._allow_permission_useronly = allow_permission_useronly + + @property + def announcement(self): + """Gets the announcement of this Config. # noqa: E501 + + This text will be shown on every page, including login page. # noqa: E501 + + :return: The announcement of this Config. # noqa: E501 + :rtype: str + """ + return self._announcement + + @announcement.setter + def announcement(self, announcement): + """Sets the announcement of this Config. + + This text will be shown on every page, including login page. # noqa: E501 + + :param announcement: The announcement of this Config. # noqa: E501 + :type: str + """ + + self._announcement = announcement + + @property + def anon_users(self): + """Gets the anon_users of this Config. # noqa: E501 + + + :return: The anon_users of this Config. # noqa: E501 + :rtype: str + """ + return self._anon_users + + @anon_users.setter + def anon_users(self, anon_users): + """Sets the anon_users of this Config. + + + :param anon_users: The anon_users of this Config. # noqa: E501 + :type: str + """ + + self._anon_users = anon_users + + @property + def autologout_time(self): + """Gets the autologout_time of this Config. # noqa: E501 + + + :return: The autologout_time of this Config. # noqa: E501 + :rtype: str + """ + return self._autologout_time + + @autologout_time.setter + def autologout_time(self, autologout_time): + """Sets the autologout_time of this Config. + + + :param autologout_time: The autologout_time of this Config. # noqa: E501 + :type: str + """ + + self._autologout_time = autologout_time + + @property + def blox_anon(self): + """Gets the blox_anon of this Config. # noqa: E501 + + + :return: The blox_anon of this Config. # noqa: E501 + :rtype: str + """ + return self._blox_anon + + @blox_anon.setter + def blox_anon(self, blox_anon): + """Sets the blox_anon of this Config. + + + :param blox_anon: The blox_anon of this Config. # noqa: E501 + :type: str + """ + + self._blox_anon = blox_anon + + @property + def blox_enabled(self): + """Gets the blox_enabled of this Config. # noqa: E501 + + + :return: The blox_enabled of this Config. # noqa: E501 + :rtype: str + """ + return self._blox_enabled + + @blox_enabled.setter + def blox_enabled(self, blox_enabled): + """Sets the blox_enabled of this Config. + + + :param blox_enabled: The blox_enabled of this Config. # noqa: E501 + :type: str + """ + + self._blox_enabled = blox_enabled + + @property + def chat_url(self): + """Gets the chat_url of this Config. # noqa: E501 + + + :return: The chat_url of this Config. # noqa: E501 + :rtype: str + """ + return self._chat_url + + @chat_url.setter + def chat_url(self, chat_url): + """Sets the chat_url of this Config. + + + :param chat_url: The chat_url of this Config. # noqa: E501 + :type: str + """ + + self._chat_url = chat_url + + @property + def cookie_validity_time(self): + """Gets the cookie_validity_time of this Config. # noqa: E501 + + + :return: The cookie_validity_time of this Config. # noqa: E501 + :rtype: int + """ + return self._cookie_validity_time + + @cookie_validity_time.setter + def cookie_validity_time(self, cookie_validity_time): + """Sets the cookie_validity_time of this Config. + + + :param cookie_validity_time: The cookie_validity_time of this Config. # noqa: E501 + :type: int + """ + + self._cookie_validity_time = cookie_validity_time + + @property + def dspace_host(self): + """Gets the dspace_host of this Config. # noqa: E501 + + URL for dspace host # noqa: E501 + + :return: The dspace_host of this Config. # noqa: E501 + :rtype: str + """ + return self._dspace_host + + @dspace_host.setter + def dspace_host(self, dspace_host): + """Sets the dspace_host of this Config. + + URL for dspace host # noqa: E501 + + :param dspace_host: The dspace_host of this Config. # noqa: E501 + :type: str + """ + + self._dspace_host = dspace_host + + @property + def dspace_user(self): + """Gets the dspace_user of this Config. # noqa: E501 + + Username for dspace integration # noqa: E501 + + :return: The dspace_user of this Config. # noqa: E501 + :rtype: str + """ + return self._dspace_user + + @dspace_user.setter + def dspace_user(self, dspace_user): + """Sets the dspace_user of this Config. + + Username for dspace integration # noqa: E501 + + :param dspace_user: The dspace_user of this Config. # noqa: E501 + :type: str + """ + + self._dspace_user = dspace_user + + @property + def dspace_password(self): + """Gets the dspace_password of this Config. # noqa: E501 + + Password for the corresponding dspace user # noqa: E501 + + :return: The dspace_password of this Config. # noqa: E501 + :rtype: str + """ + return self._dspace_password + + @dspace_password.setter + def dspace_password(self, dspace_password): + """Sets the dspace_password of this Config. + + Password for the corresponding dspace user # noqa: E501 + + :param dspace_password: The dspace_password of this Config. # noqa: E501 + :type: str + """ + + self._dspace_password = dspace_password + + @property + def email_domain(self): + """Gets the email_domain of this Config. # noqa: E501 + + + :return: The email_domain of this Config. # noqa: E501 + :rtype: str + """ + return self._email_domain + + @email_domain.setter + def email_domain(self, email_domain): + """Sets the email_domain of this Config. + + + :param email_domain: The email_domain of this Config. # noqa: E501 + :type: str + """ + + self._email_domain = email_domain + + @property + def extauth_email(self): + """Gets the extauth_email of this Config. # noqa: E501 + + + :return: The extauth_email of this Config. # noqa: E501 + :rtype: str + """ + return self._extauth_email + + @extauth_email.setter + def extauth_email(self, extauth_email): + """Sets the extauth_email of this Config. + + + :param extauth_email: The extauth_email of this Config. # noqa: E501 + :type: str + """ + + self._extauth_email = extauth_email + + @property + def extauth_firstname(self): + """Gets the extauth_firstname of this Config. # noqa: E501 + + + :return: The extauth_firstname of this Config. # noqa: E501 + :rtype: str + """ + return self._extauth_firstname + + @extauth_firstname.setter + def extauth_firstname(self, extauth_firstname): + """Sets the extauth_firstname of this Config. + + + :param extauth_firstname: The extauth_firstname of this Config. # noqa: E501 + :type: str + """ + + self._extauth_firstname = extauth_firstname + + @property + def extauth_lastname(self): + """Gets the extauth_lastname of this Config. # noqa: E501 + + + :return: The extauth_lastname of this Config. # noqa: E501 + :rtype: str + """ + return self._extauth_lastname + + @extauth_lastname.setter + def extauth_lastname(self, extauth_lastname): + """Sets the extauth_lastname of this Config. + + + :param extauth_lastname: The extauth_lastname of this Config. # noqa: E501 + :type: str + """ + + self._extauth_lastname = extauth_lastname + + @property + def extauth_remote_user(self): + """Gets the extauth_remote_user of this Config. # noqa: E501 + + + :return: The extauth_remote_user of this Config. # noqa: E501 + :rtype: str + """ + return self._extauth_remote_user + + @extauth_remote_user.setter + def extauth_remote_user(self, extauth_remote_user): + """Sets the extauth_remote_user of this Config. + + + :param extauth_remote_user: The extauth_remote_user of this Config. # noqa: E501 + :type: str + """ + + self._extauth_remote_user = extauth_remote_user + + @property + def extauth_teams(self): + """Gets the extauth_teams of this Config. # noqa: E501 + + + :return: The extauth_teams of this Config. # noqa: E501 + :rtype: str + """ + return self._extauth_teams + + @extauth_teams.setter + def extauth_teams(self, extauth_teams): + """Sets the extauth_teams of this Config. + + + :param extauth_teams: The extauth_teams of this Config. # noqa: E501 + :type: str + """ + + self._extauth_teams = extauth_teams + + @property + def lang(self): + """Gets the lang of this Config. # noqa: E501 + + + :return: The lang of this Config. # noqa: E501 + :rtype: str + """ + return self._lang + + @lang.setter + def lang(self, lang): + """Sets the lang of this Config. + + + :param lang: The lang of this Config. # noqa: E501 + :type: str + """ + + self._lang = lang + + @property + def ldap_base_dn(self): + """Gets the ldap_base_dn of this Config. # noqa: E501 + + + :return: The ldap_base_dn of this Config. # noqa: E501 + :rtype: str + """ + return self._ldap_base_dn + + @ldap_base_dn.setter + def ldap_base_dn(self, ldap_base_dn): + """Sets the ldap_base_dn of this Config. + + + :param ldap_base_dn: The ldap_base_dn of this Config. # noqa: E501 + :type: str + """ + + self._ldap_base_dn = ldap_base_dn + + @property + def ldap_search_attr(self): + """Gets the ldap_search_attr of this Config. # noqa: E501 + + + :return: The ldap_search_attr of this Config. # noqa: E501 + :rtype: str + """ + return self._ldap_search_attr + + @ldap_search_attr.setter + def ldap_search_attr(self, ldap_search_attr): + """Sets the ldap_search_attr of this Config. + + + :param ldap_search_attr: The ldap_search_attr of this Config. # noqa: E501 + :type: str + """ + + self._ldap_search_attr = ldap_search_attr + + @property + def ldap_email(self): + """Gets the ldap_email of this Config. # noqa: E501 + + + :return: The ldap_email of this Config. # noqa: E501 + :rtype: str + """ + return self._ldap_email + + @ldap_email.setter + def ldap_email(self, ldap_email): + """Sets the ldap_email of this Config. + + + :param ldap_email: The ldap_email of this Config. # noqa: E501 + :type: str + """ + + self._ldap_email = ldap_email + + @property + def ldap_firstname(self): + """Gets the ldap_firstname of this Config. # noqa: E501 + + + :return: The ldap_firstname of this Config. # noqa: E501 + :rtype: str + """ + return self._ldap_firstname + + @ldap_firstname.setter + def ldap_firstname(self, ldap_firstname): + """Sets the ldap_firstname of this Config. + + + :param ldap_firstname: The ldap_firstname of this Config. # noqa: E501 + :type: str + """ + + self._ldap_firstname = ldap_firstname + + @property + def ldap_host(self): + """Gets the ldap_host of this Config. # noqa: E501 + + + :return: The ldap_host of this Config. # noqa: E501 + :rtype: str + """ + return self._ldap_host + + @ldap_host.setter + def ldap_host(self, ldap_host): + """Sets the ldap_host of this Config. + + + :param ldap_host: The ldap_host of this Config. # noqa: E501 + :type: str + """ + + self._ldap_host = ldap_host + + @property + def ldap_lastname(self): + """Gets the ldap_lastname of this Config. # noqa: E501 + + + :return: The ldap_lastname of this Config. # noqa: E501 + :rtype: str + """ + return self._ldap_lastname + + @ldap_lastname.setter + def ldap_lastname(self, ldap_lastname): + """Sets the ldap_lastname of this Config. + + + :param ldap_lastname: The ldap_lastname of this Config. # noqa: E501 + :type: str + """ + + self._ldap_lastname = ldap_lastname + + @property + def ldap_password(self): + """Gets the ldap_password of this Config. # noqa: E501 + + + :return: The ldap_password of this Config. # noqa: E501 + :rtype: str + """ + return self._ldap_password + + @ldap_password.setter + def ldap_password(self, ldap_password): + """Sets the ldap_password of this Config. + + + :param ldap_password: The ldap_password of this Config. # noqa: E501 + :type: str + """ + + self._ldap_password = ldap_password + + @property + def ldap_port(self): + """Gets the ldap_port of this Config. # noqa: E501 + + + :return: The ldap_port of this Config. # noqa: E501 + :rtype: str + """ + return self._ldap_port + + @ldap_port.setter + def ldap_port(self, ldap_port): + """Sets the ldap_port of this Config. + + + :param ldap_port: The ldap_port of this Config. # noqa: E501 + :type: str + """ + + self._ldap_port = ldap_port + + @property + def ldap_sync_teams(self): + """Gets the ldap_sync_teams of this Config. # noqa: E501 + + + :return: The ldap_sync_teams of this Config. # noqa: E501 + :rtype: str + """ + return self._ldap_sync_teams + + @ldap_sync_teams.setter + def ldap_sync_teams(self, ldap_sync_teams): + """Sets the ldap_sync_teams of this Config. + + + :param ldap_sync_teams: The ldap_sync_teams of this Config. # noqa: E501 + :type: str + """ + + self._ldap_sync_teams = ldap_sync_teams + + @property + def ldap_team(self): + """Gets the ldap_team of this Config. # noqa: E501 + + + :return: The ldap_team of this Config. # noqa: E501 + :rtype: str + """ + return self._ldap_team + + @ldap_team.setter + def ldap_team(self, ldap_team): + """Sets the ldap_team of this Config. + + + :param ldap_team: The ldap_team of this Config. # noqa: E501 + :type: str + """ + + self._ldap_team = ldap_team + + @property + def ldap_team_create(self): + """Gets the ldap_team_create of this Config. # noqa: E501 + + + :return: The ldap_team_create of this Config. # noqa: E501 + :rtype: str + """ + return self._ldap_team_create + + @ldap_team_create.setter + def ldap_team_create(self, ldap_team_create): + """Sets the ldap_team_create of this Config. + + + :param ldap_team_create: The ldap_team_create of this Config. # noqa: E501 + :type: str + """ + + self._ldap_team_create = ldap_team_create + + @property + def ldap_toggle(self): + """Gets the ldap_toggle of this Config. # noqa: E501 + + + :return: The ldap_toggle of this Config. # noqa: E501 + :rtype: str + """ + return self._ldap_toggle + + @ldap_toggle.setter + def ldap_toggle(self, ldap_toggle): + """Sets the ldap_toggle of this Config. + + + :param ldap_toggle: The ldap_toggle of this Config. # noqa: E501 + :type: str + """ + + self._ldap_toggle = ldap_toggle + + @property + def ldap_use_tls(self): + """Gets the ldap_use_tls of this Config. # noqa: E501 + + + :return: The ldap_use_tls of this Config. # noqa: E501 + :rtype: str + """ + return self._ldap_use_tls + + @ldap_use_tls.setter + def ldap_use_tls(self, ldap_use_tls): + """Sets the ldap_use_tls of this Config. + + + :param ldap_use_tls: The ldap_use_tls of this Config. # noqa: E501 + :type: str + """ + + self._ldap_use_tls = ldap_use_tls + + @property + def ldap_username(self): + """Gets the ldap_username of this Config. # noqa: E501 + + + :return: The ldap_username of this Config. # noqa: E501 + :rtype: str + """ + return self._ldap_username + + @ldap_username.setter + def ldap_username(self, ldap_username): + """Sets the ldap_username of this Config. + + + :param ldap_username: The ldap_username of this Config. # noqa: E501 + :type: str + """ + + self._ldap_username = ldap_username + + @property + def local_login(self): + """Gets the local_login of this Config. # noqa: E501 + + + :return: The local_login of this Config. # noqa: E501 + :rtype: str + """ + return self._local_login + + @local_login.setter + def local_login(self, local_login): + """Sets the local_login of this Config. + + + :param local_login: The local_login of this Config. # noqa: E501 + :type: str + """ + + self._local_login = local_login + + @property + def local_register(self): + """Gets the local_register of this Config. # noqa: E501 + + + :return: The local_register of this Config. # noqa: E501 + :rtype: str + """ + return self._local_register + + @local_register.setter + def local_register(self, local_register): + """Sets the local_register of this Config. + + + :param local_register: The local_register of this Config. # noqa: E501 + :type: str + """ + + self._local_register = local_register + + @property + def login_announcement(self): + """Gets the login_announcement of this Config. # noqa: E501 + + This text will only be shown on the login page. # noqa: E501 + + :return: The login_announcement of this Config. # noqa: E501 + :rtype: str + """ + return self._login_announcement + + @login_announcement.setter + def login_announcement(self, login_announcement): + """Sets the login_announcement of this Config. + + This text will only be shown on the login page. # noqa: E501 + + :param login_announcement: The login_announcement of this Config. # noqa: E501 + :type: str + """ + + self._login_announcement = login_announcement + + @property + def login_tries(self): + """Gets the login_tries of this Config. # noqa: E501 + + + :return: The login_tries of this Config. # noqa: E501 + :rtype: str + """ + return self._login_tries + + @login_tries.setter + def login_tries(self, login_tries): + """Sets the login_tries of this Config. + + + :param login_tries: The login_tries of this Config. # noqa: E501 + :type: str + """ + + self._login_tries = login_tries + + @property + def logout_url(self): + """Gets the logout_url of this Config. # noqa: E501 + + + :return: The logout_url of this Config. # noqa: E501 + :rtype: str + """ + return self._logout_url + + @logout_url.setter + def logout_url(self, logout_url): + """Sets the logout_url of this Config. + + + :param logout_url: The logout_url of this Config. # noqa: E501 + :type: str + """ + + self._logout_url = logout_url + + @property + def mail_from(self): + """Gets the mail_from of this Config. # noqa: E501 + + + :return: The mail_from of this Config. # noqa: E501 + :rtype: str + """ + return self._mail_from + + @mail_from.setter + def mail_from(self, mail_from): + """Sets the mail_from of this Config. + + + :param mail_from: The mail_from of this Config. # noqa: E501 + :type: str + """ + + self._mail_from = mail_from + + @property + def max_revisions(self): + """Gets the max_revisions of this Config. # noqa: E501 + + + :return: The max_revisions of this Config. # noqa: E501 + :rtype: str + """ + return self._max_revisions + + @max_revisions.setter + def max_revisions(self, max_revisions): + """Sets the max_revisions of this Config. + + + :param max_revisions: The max_revisions of this Config. # noqa: E501 + :type: str + """ + + self._max_revisions = max_revisions + + @property + def min_days_revisions(self): + """Gets the min_days_revisions of this Config. # noqa: E501 + + + :return: The min_days_revisions of this Config. # noqa: E501 + :rtype: str + """ + return self._min_days_revisions + + @min_days_revisions.setter + def min_days_revisions(self, min_days_revisions): + """Sets the min_days_revisions of this Config. + + + :param min_days_revisions: The min_days_revisions of this Config. # noqa: E501 + :type: str + """ + + self._min_days_revisions = min_days_revisions + + @property + def min_delta_revisions(self): + """Gets the min_delta_revisions of this Config. # noqa: E501 + + Minimum number of characters changed required to trigger a revision save. # noqa: E501 + + :return: The min_delta_revisions of this Config. # noqa: E501 + :rtype: str + """ + return self._min_delta_revisions + + @min_delta_revisions.setter + def min_delta_revisions(self, min_delta_revisions): + """Sets the min_delta_revisions of this Config. + + Minimum number of characters changed required to trigger a revision save. # noqa: E501 + + :param min_delta_revisions: The min_delta_revisions of this Config. # noqa: E501 + :type: str + """ + + self._min_delta_revisions = min_delta_revisions + + @property + def onboarding_email_active(self): + """Gets the onboarding_email_active of this Config. # noqa: E501 + + + :return: The onboarding_email_active of this Config. # noqa: E501 + :rtype: str + """ + return self._onboarding_email_active + + @onboarding_email_active.setter + def onboarding_email_active(self, onboarding_email_active): + """Sets the onboarding_email_active of this Config. + + + :param onboarding_email_active: The onboarding_email_active of this Config. # noqa: E501 + :type: str + """ + allowed_values = ["0", "1"] # noqa: E501 + if onboarding_email_active not in allowed_values: + raise ValueError( + "Invalid value for `onboarding_email_active` ({0}), must be one of {1}" # noqa: E501 + .format(onboarding_email_active, allowed_values) + ) + + self._onboarding_email_active = onboarding_email_active + + @property + def onboarding_email_admins_body(self): + """Gets the onboarding_email_admins_body of this Config. # noqa: E501 + + + :return: The onboarding_email_admins_body of this Config. # noqa: E501 + :rtype: str + """ + return self._onboarding_email_admins_body + + @onboarding_email_admins_body.setter + def onboarding_email_admins_body(self, onboarding_email_admins_body): + """Sets the onboarding_email_admins_body of this Config. + + + :param onboarding_email_admins_body: The onboarding_email_admins_body of this Config. # noqa: E501 + :type: str + """ + + self._onboarding_email_admins_body = onboarding_email_admins_body + + @property + def onboarding_email_admins_subject(self): + """Gets the onboarding_email_admins_subject of this Config. # noqa: E501 + + + :return: The onboarding_email_admins_subject of this Config. # noqa: E501 + :rtype: str + """ + return self._onboarding_email_admins_subject + + @onboarding_email_admins_subject.setter + def onboarding_email_admins_subject(self, onboarding_email_admins_subject): + """Sets the onboarding_email_admins_subject of this Config. + + + :param onboarding_email_admins_subject: The onboarding_email_admins_subject of this Config. # noqa: E501 + :type: str + """ + + self._onboarding_email_admins_subject = onboarding_email_admins_subject + + @property + def onboarding_email_body(self): + """Gets the onboarding_email_body of this Config. # noqa: E501 + + + :return: The onboarding_email_body of this Config. # noqa: E501 + :rtype: str + """ + return self._onboarding_email_body + + @onboarding_email_body.setter + def onboarding_email_body(self, onboarding_email_body): + """Sets the onboarding_email_body of this Config. + + + :param onboarding_email_body: The onboarding_email_body of this Config. # noqa: E501 + :type: str + """ + + self._onboarding_email_body = onboarding_email_body + + @property + def onboarding_email_different_for_admins(self): + """Gets the onboarding_email_different_for_admins of this Config. # noqa: E501 + + + :return: The onboarding_email_different_for_admins of this Config. # noqa: E501 + :rtype: str + """ + return self._onboarding_email_different_for_admins + + @onboarding_email_different_for_admins.setter + def onboarding_email_different_for_admins(self, onboarding_email_different_for_admins): + """Sets the onboarding_email_different_for_admins of this Config. + + + :param onboarding_email_different_for_admins: The onboarding_email_different_for_admins of this Config. # noqa: E501 + :type: str + """ + allowed_values = ["0", "1"] # noqa: E501 + if onboarding_email_different_for_admins not in allowed_values: + raise ValueError( + "Invalid value for `onboarding_email_different_for_admins` ({0}), must be one of {1}" # noqa: E501 + .format(onboarding_email_different_for_admins, allowed_values) + ) + + self._onboarding_email_different_for_admins = onboarding_email_different_for_admins + + @property + def onboarding_email_subject(self): + """Gets the onboarding_email_subject of this Config. # noqa: E501 + + + :return: The onboarding_email_subject of this Config. # noqa: E501 + :rtype: str + """ + return self._onboarding_email_subject + + @onboarding_email_subject.setter + def onboarding_email_subject(self, onboarding_email_subject): + """Sets the onboarding_email_subject of this Config. + + + :param onboarding_email_subject: The onboarding_email_subject of this Config. # noqa: E501 + :type: str + """ + + self._onboarding_email_subject = onboarding_email_subject + + @property + def privacy_policy(self): + """Gets the privacy_policy of this Config. # noqa: E501 + + + :return: The privacy_policy of this Config. # noqa: E501 + :rtype: str + """ + return self._privacy_policy + + @privacy_policy.setter + def privacy_policy(self, privacy_policy): + """Sets the privacy_policy of this Config. + + + :param privacy_policy: The privacy_policy of this Config. # noqa: E501 + :type: str + """ + + self._privacy_policy = privacy_policy + + @property + def proxy(self): + """Gets the proxy of this Config. # noqa: E501 + + + :return: The proxy of this Config. # noqa: E501 + :rtype: str + """ + return self._proxy + + @proxy.setter + def proxy(self, proxy): + """Sets the proxy of this Config. + + + :param proxy: The proxy of this Config. # noqa: E501 + :type: str + """ + + self._proxy = proxy + + @property + def remote_dir_config(self): + """Gets the remote_dir_config of this Config. # noqa: E501 + + + :return: The remote_dir_config of this Config. # noqa: E501 + :rtype: str + """ + return self._remote_dir_config + + @remote_dir_config.setter + def remote_dir_config(self, remote_dir_config): + """Sets the remote_dir_config of this Config. + + + :param remote_dir_config: The remote_dir_config of this Config. # noqa: E501 + :type: str + """ + + self._remote_dir_config = remote_dir_config + + @property + def remote_dir_service(self): + """Gets the remote_dir_service of this Config. # noqa: E501 + + + :return: The remote_dir_service of this Config. # noqa: E501 + :rtype: str + """ + return self._remote_dir_service + + @remote_dir_service.setter + def remote_dir_service(self, remote_dir_service): + """Sets the remote_dir_service of this Config. + + + :param remote_dir_service: The remote_dir_service of this Config. # noqa: E501 + :type: str + """ + + self._remote_dir_service = remote_dir_service + + @property + def s3_bucket_name(self): + """Gets the s3_bucket_name of this Config. # noqa: E501 + + + :return: The s3_bucket_name of this Config. # noqa: E501 + :rtype: str + """ + return self._s3_bucket_name + + @s3_bucket_name.setter + def s3_bucket_name(self, s3_bucket_name): + """Sets the s3_bucket_name of this Config. + + + :param s3_bucket_name: The s3_bucket_name of this Config. # noqa: E501 + :type: str + """ + + self._s3_bucket_name = s3_bucket_name + + @property + def s3_endpoint(self): + """Gets the s3_endpoint of this Config. # noqa: E501 + + + :return: The s3_endpoint of this Config. # noqa: E501 + :rtype: str + """ + return self._s3_endpoint + + @s3_endpoint.setter + def s3_endpoint(self, s3_endpoint): + """Sets the s3_endpoint of this Config. + + + :param s3_endpoint: The s3_endpoint of this Config. # noqa: E501 + :type: str + """ + + self._s3_endpoint = s3_endpoint + + @property + def s3_path_prefix(self): + """Gets the s3_path_prefix of this Config. # noqa: E501 + + + :return: The s3_path_prefix of this Config. # noqa: E501 + :rtype: str + """ + return self._s3_path_prefix + + @s3_path_prefix.setter + def s3_path_prefix(self, s3_path_prefix): + """Sets the s3_path_prefix of this Config. + + + :param s3_path_prefix: The s3_path_prefix of this Config. # noqa: E501 + :type: str + """ + + self._s3_path_prefix = s3_path_prefix + + @property + def s3_region(self): + """Gets the s3_region of this Config. # noqa: E501 + + + :return: The s3_region of this Config. # noqa: E501 + :rtype: str + """ + return self._s3_region + + @s3_region.setter + def s3_region(self, s3_region): + """Sets the s3_region of this Config. + + + :param s3_region: The s3_region of this Config. # noqa: E501 + :type: str + """ + + self._s3_region = s3_region + + @property + def s3_verify_cert(self): + """Gets the s3_verify_cert of this Config. # noqa: E501 + + + :return: The s3_verify_cert of this Config. # noqa: E501 + :rtype: str + """ + return self._s3_verify_cert + + @s3_verify_cert.setter + def s3_verify_cert(self, s3_verify_cert): + """Sets the s3_verify_cert of this Config. + + + :param s3_verify_cert: The s3_verify_cert of this Config. # noqa: E501 + :type: str + """ + + self._s3_verify_cert = s3_verify_cert + + @property + def saml_allowrepeatattributename(self): + """Gets the saml_allowrepeatattributename of this Config. # noqa: E501 + + + :return: The saml_allowrepeatattributename of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_allowrepeatattributename + + @saml_allowrepeatattributename.setter + def saml_allowrepeatattributename(self, saml_allowrepeatattributename): + """Sets the saml_allowrepeatattributename of this Config. + + + :param saml_allowrepeatattributename: The saml_allowrepeatattributename of this Config. # noqa: E501 + :type: str + """ + + self._saml_allowrepeatattributename = saml_allowrepeatattributename + + @property + def saml_authnrequestssigned(self): + """Gets the saml_authnrequestssigned of this Config. # noqa: E501 + + + :return: The saml_authnrequestssigned of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_authnrequestssigned + + @saml_authnrequestssigned.setter + def saml_authnrequestssigned(self, saml_authnrequestssigned): + """Sets the saml_authnrequestssigned of this Config. + + + :param saml_authnrequestssigned: The saml_authnrequestssigned of this Config. # noqa: E501 + :type: str + """ + + self._saml_authnrequestssigned = saml_authnrequestssigned + + @property + def saml_baseurl(self): + """Gets the saml_baseurl of this Config. # noqa: E501 + + + :return: The saml_baseurl of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_baseurl + + @saml_baseurl.setter + def saml_baseurl(self, saml_baseurl): + """Sets the saml_baseurl of this Config. + + + :param saml_baseurl: The saml_baseurl of this Config. # noqa: E501 + :type: str + """ + + self._saml_baseurl = saml_baseurl + + @property + def saml_debug(self): + """Gets the saml_debug of this Config. # noqa: E501 + + + :return: The saml_debug of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_debug + + @saml_debug.setter + def saml_debug(self, saml_debug): + """Sets the saml_debug of this Config. + + + :param saml_debug: The saml_debug of this Config. # noqa: E501 + :type: str + """ + + self._saml_debug = saml_debug + + @property + def saml_entityid(self): + """Gets the saml_entityid of this Config. # noqa: E501 + + + :return: The saml_entityid of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_entityid + + @saml_entityid.setter + def saml_entityid(self, saml_entityid): + """Sets the saml_entityid of this Config. + + + :param saml_entityid: The saml_entityid of this Config. # noqa: E501 + :type: str + """ + + self._saml_entityid = saml_entityid + + @property + def saml_logoutrequestsigned(self): + """Gets the saml_logoutrequestsigned of this Config. # noqa: E501 + + + :return: The saml_logoutrequestsigned of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_logoutrequestsigned + + @saml_logoutrequestsigned.setter + def saml_logoutrequestsigned(self, saml_logoutrequestsigned): + """Sets the saml_logoutrequestsigned of this Config. + + + :param saml_logoutrequestsigned: The saml_logoutrequestsigned of this Config. # noqa: E501 + :type: str + """ + + self._saml_logoutrequestsigned = saml_logoutrequestsigned + + @property + def saml_logoutresponsesigned(self): + """Gets the saml_logoutresponsesigned of this Config. # noqa: E501 + + + :return: The saml_logoutresponsesigned of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_logoutresponsesigned + + @saml_logoutresponsesigned.setter + def saml_logoutresponsesigned(self, saml_logoutresponsesigned): + """Sets the saml_logoutresponsesigned of this Config. + + + :param saml_logoutresponsesigned: The saml_logoutresponsesigned of this Config. # noqa: E501 + :type: str + """ + + self._saml_logoutresponsesigned = saml_logoutresponsesigned + + @property + def saml_lowercaseurlencoding(self): + """Gets the saml_lowercaseurlencoding of this Config. # noqa: E501 + + + :return: The saml_lowercaseurlencoding of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_lowercaseurlencoding + + @saml_lowercaseurlencoding.setter + def saml_lowercaseurlencoding(self, saml_lowercaseurlencoding): + """Sets the saml_lowercaseurlencoding of this Config. + + + :param saml_lowercaseurlencoding: The saml_lowercaseurlencoding of this Config. # noqa: E501 + :type: str + """ + + self._saml_lowercaseurlencoding = saml_lowercaseurlencoding + + @property + def saml_nameidencrypted(self): + """Gets the saml_nameidencrypted of this Config. # noqa: E501 + + + :return: The saml_nameidencrypted of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_nameidencrypted + + @saml_nameidencrypted.setter + def saml_nameidencrypted(self, saml_nameidencrypted): + """Sets the saml_nameidencrypted of this Config. + + + :param saml_nameidencrypted: The saml_nameidencrypted of this Config. # noqa: E501 + :type: str + """ + + self._saml_nameidencrypted = saml_nameidencrypted + + @property + def saml_nameidformat(self): + """Gets the saml_nameidformat of this Config. # noqa: E501 + + + :return: The saml_nameidformat of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_nameidformat + + @saml_nameidformat.setter + def saml_nameidformat(self, saml_nameidformat): + """Sets the saml_nameidformat of this Config. + + + :param saml_nameidformat: The saml_nameidformat of this Config. # noqa: E501 + :type: str + """ + + self._saml_nameidformat = saml_nameidformat + + @property + def saml_privatekey(self): + """Gets the saml_privatekey of this Config. # noqa: E501 + + + :return: The saml_privatekey of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_privatekey + + @saml_privatekey.setter + def saml_privatekey(self, saml_privatekey): + """Sets the saml_privatekey of this Config. + + + :param saml_privatekey: The saml_privatekey of this Config. # noqa: E501 + :type: str + """ + + self._saml_privatekey = saml_privatekey + + @property + def saml_relaxdestinationvalidation(self): + """Gets the saml_relaxdestinationvalidation of this Config. # noqa: E501 + + + :return: The saml_relaxdestinationvalidation of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_relaxdestinationvalidation + + @saml_relaxdestinationvalidation.setter + def saml_relaxdestinationvalidation(self, saml_relaxdestinationvalidation): + """Sets the saml_relaxdestinationvalidation of this Config. + + + :param saml_relaxdestinationvalidation: The saml_relaxdestinationvalidation of this Config. # noqa: E501 + :type: str + """ + + self._saml_relaxdestinationvalidation = saml_relaxdestinationvalidation + + @property + def saml_signmetadata(self): + """Gets the saml_signmetadata of this Config. # noqa: E501 + + + :return: The saml_signmetadata of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_signmetadata + + @saml_signmetadata.setter + def saml_signmetadata(self, saml_signmetadata): + """Sets the saml_signmetadata of this Config. + + + :param saml_signmetadata: The saml_signmetadata of this Config. # noqa: E501 + :type: str + """ + + self._saml_signmetadata = saml_signmetadata + + @property + def saml_strict(self): + """Gets the saml_strict of this Config. # noqa: E501 + + + :return: The saml_strict of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_strict + + @saml_strict.setter + def saml_strict(self, saml_strict): + """Sets the saml_strict of this Config. + + + :param saml_strict: The saml_strict of this Config. # noqa: E501 + :type: str + """ + + self._saml_strict = saml_strict + + @property + def saml_sync_teams(self): + """Gets the saml_sync_teams of this Config. # noqa: E501 + + + :return: The saml_sync_teams of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_sync_teams + + @saml_sync_teams.setter + def saml_sync_teams(self, saml_sync_teams): + """Sets the saml_sync_teams of this Config. + + + :param saml_sync_teams: The saml_sync_teams of this Config. # noqa: E501 + :type: str + """ + + self._saml_sync_teams = saml_sync_teams + + @property + def saml_team_create(self): + """Gets the saml_team_create of this Config. # noqa: E501 + + + :return: The saml_team_create of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_team_create + + @saml_team_create.setter + def saml_team_create(self, saml_team_create): + """Sets the saml_team_create of this Config. + + + :param saml_team_create: The saml_team_create of this Config. # noqa: E501 + :type: str + """ + + self._saml_team_create = saml_team_create + + @property + def saml_team_default(self): + """Gets the saml_team_default of this Config. # noqa: E501 + + + :return: The saml_team_default of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_team_default + + @saml_team_default.setter + def saml_team_default(self, saml_team_default): + """Sets the saml_team_default of this Config. + + + :param saml_team_default: The saml_team_default of this Config. # noqa: E501 + :type: str + """ + + self._saml_team_default = saml_team_default + + @property + def saml_toggle(self): + """Gets the saml_toggle of this Config. # noqa: E501 + + + :return: The saml_toggle of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_toggle + + @saml_toggle.setter + def saml_toggle(self, saml_toggle): + """Sets the saml_toggle of this Config. + + + :param saml_toggle: The saml_toggle of this Config. # noqa: E501 + :type: str + """ + + self._saml_toggle = saml_toggle + + @property + def saml_user_default(self): + """Gets the saml_user_default of this Config. # noqa: E501 + + + :return: The saml_user_default of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_user_default + + @saml_user_default.setter + def saml_user_default(self, saml_user_default): + """Sets the saml_user_default of this Config. + + + :param saml_user_default: The saml_user_default of this Config. # noqa: E501 + :type: str + """ + + self._saml_user_default = saml_user_default + + @property + def saml_wantassertionsencrypted(self): + """Gets the saml_wantassertionsencrypted of this Config. # noqa: E501 + + + :return: The saml_wantassertionsencrypted of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_wantassertionsencrypted + + @saml_wantassertionsencrypted.setter + def saml_wantassertionsencrypted(self, saml_wantassertionsencrypted): + """Sets the saml_wantassertionsencrypted of this Config. + + + :param saml_wantassertionsencrypted: The saml_wantassertionsencrypted of this Config. # noqa: E501 + :type: str + """ + + self._saml_wantassertionsencrypted = saml_wantassertionsencrypted + + @property + def saml_wantassertionssigned(self): + """Gets the saml_wantassertionssigned of this Config. # noqa: E501 + + + :return: The saml_wantassertionssigned of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_wantassertionssigned + + @saml_wantassertionssigned.setter + def saml_wantassertionssigned(self, saml_wantassertionssigned): + """Sets the saml_wantassertionssigned of this Config. + + + :param saml_wantassertionssigned: The saml_wantassertionssigned of this Config. # noqa: E501 + :type: str + """ + + self._saml_wantassertionssigned = saml_wantassertionssigned + + @property + def saml_wantmessagessigned(self): + """Gets the saml_wantmessagessigned of this Config. # noqa: E501 + + + :return: The saml_wantmessagessigned of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_wantmessagessigned + + @saml_wantmessagessigned.setter + def saml_wantmessagessigned(self, saml_wantmessagessigned): + """Sets the saml_wantmessagessigned of this Config. + + + :param saml_wantmessagessigned: The saml_wantmessagessigned of this Config. # noqa: E501 + :type: str + """ + + self._saml_wantmessagessigned = saml_wantmessagessigned + + @property + def saml_wantnameid(self): + """Gets the saml_wantnameid of this Config. # noqa: E501 + + + :return: The saml_wantnameid of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_wantnameid + + @saml_wantnameid.setter + def saml_wantnameid(self, saml_wantnameid): + """Sets the saml_wantnameid of this Config. + + + :param saml_wantnameid: The saml_wantnameid of this Config. # noqa: E501 + :type: str + """ + + self._saml_wantnameid = saml_wantnameid + + @property + def saml_wantnameidencrypted(self): + """Gets the saml_wantnameidencrypted of this Config. # noqa: E501 + + + :return: The saml_wantnameidencrypted of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_wantnameidencrypted + + @saml_wantnameidencrypted.setter + def saml_wantnameidencrypted(self, saml_wantnameidencrypted): + """Sets the saml_wantnameidencrypted of this Config. + + + :param saml_wantnameidencrypted: The saml_wantnameidencrypted of this Config. # noqa: E501 + :type: str + """ + + self._saml_wantnameidencrypted = saml_wantnameidencrypted + + @property + def saml_wantxmlvalidation(self): + """Gets the saml_wantxmlvalidation of this Config. # noqa: E501 + + + :return: The saml_wantxmlvalidation of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_wantxmlvalidation + + @saml_wantxmlvalidation.setter + def saml_wantxmlvalidation(self, saml_wantxmlvalidation): + """Sets the saml_wantxmlvalidation of this Config. + + + :param saml_wantxmlvalidation: The saml_wantxmlvalidation of this Config. # noqa: E501 + :type: str + """ + + self._saml_wantxmlvalidation = saml_wantxmlvalidation + + @property + def saml_x509(self): + """Gets the saml_x509 of this Config. # noqa: E501 + + + :return: The saml_x509 of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_x509 + + @saml_x509.setter + def saml_x509(self, saml_x509): + """Sets the saml_x509 of this Config. + + + :param saml_x509: The saml_x509 of this Config. # noqa: E501 + :type: str + """ + + self._saml_x509 = saml_x509 + + @property + def saml_x509_new(self): + """Gets the saml_x509_new of this Config. # noqa: E501 + + + :return: The saml_x509_new of this Config. # noqa: E501 + :rtype: str + """ + return self._saml_x509_new + + @saml_x509_new.setter + def saml_x509_new(self, saml_x509_new): + """Sets the saml_x509_new of this Config. + + + :param saml_x509_new: The saml_x509_new of this Config. # noqa: E501 + :type: str + """ + + self._saml_x509_new = saml_x509_new + + @property + def schema(self): + """Gets the schema of this Config. # noqa: E501 + + + :return: The schema of this Config. # noqa: E501 + :rtype: str + """ + return self._schema + + @schema.setter + def schema(self, schema): + """Sets the schema of this Config. + + + :param schema: The schema of this Config. # noqa: E501 + :type: str + """ + + self._schema = schema + + @property + def smtp_address(self): + """Gets the smtp_address of this Config. # noqa: E501 + + + :return: The smtp_address of this Config. # noqa: E501 + :rtype: str + """ + return self._smtp_address + + @smtp_address.setter + def smtp_address(self, smtp_address): + """Sets the smtp_address of this Config. + + + :param smtp_address: The smtp_address of this Config. # noqa: E501 + :type: str + """ + + self._smtp_address = smtp_address + + @property + def smtp_encryption(self): + """Gets the smtp_encryption of this Config. # noqa: E501 + + + :return: The smtp_encryption of this Config. # noqa: E501 + :rtype: str + """ + return self._smtp_encryption + + @smtp_encryption.setter + def smtp_encryption(self, smtp_encryption): + """Sets the smtp_encryption of this Config. + + + :param smtp_encryption: The smtp_encryption of this Config. # noqa: E501 + :type: str + """ + + self._smtp_encryption = smtp_encryption + + @property + def smtp_password(self): + """Gets the smtp_password of this Config. # noqa: E501 + + + :return: The smtp_password of this Config. # noqa: E501 + :rtype: str + """ + return self._smtp_password + + @smtp_password.setter + def smtp_password(self, smtp_password): + """Sets the smtp_password of this Config. + + + :param smtp_password: The smtp_password of this Config. # noqa: E501 + :type: str + """ + + self._smtp_password = smtp_password + + @property + def smtp_port(self): + """Gets the smtp_port of this Config. # noqa: E501 + + + :return: The smtp_port of this Config. # noqa: E501 + :rtype: str + """ + return self._smtp_port + + @smtp_port.setter + def smtp_port(self, smtp_port): + """Sets the smtp_port of this Config. + + + :param smtp_port: The smtp_port of this Config. # noqa: E501 + :type: str + """ + + self._smtp_port = smtp_port + + @property + def smtp_username(self): + """Gets the smtp_username of this Config. # noqa: E501 + + + :return: The smtp_username of this Config. # noqa: E501 + :rtype: str + """ + return self._smtp_username + + @smtp_username.setter + def smtp_username(self, smtp_username): + """Sets the smtp_username of this Config. + + + :param smtp_username: The smtp_username of this Config. # noqa: E501 + :type: str + """ + + self._smtp_username = smtp_username + + @property + def support_url(self): + """Gets the support_url of this Config. # noqa: E501 + + + :return: The support_url of this Config. # noqa: E501 + :rtype: str + """ + return self._support_url + + @support_url.setter + def support_url(self, support_url): + """Sets the support_url of this Config. + + + :param support_url: The support_url of this Config. # noqa: E501 + :type: str + """ + + self._support_url = support_url + + @property + def ts_authority(self): + """Gets the ts_authority of this Config. # noqa: E501 + + + :return: The ts_authority of this Config. # noqa: E501 + :rtype: str + """ + return self._ts_authority + + @ts_authority.setter + def ts_authority(self, ts_authority): + """Sets the ts_authority of this Config. + + + :param ts_authority: The ts_authority of this Config. # noqa: E501 + :type: str + """ + + self._ts_authority = ts_authority + + @property + def ts_cert(self): + """Gets the ts_cert of this Config. # noqa: E501 + + + :return: The ts_cert of this Config. # noqa: E501 + :rtype: str + """ + return self._ts_cert + + @ts_cert.setter + def ts_cert(self, ts_cert): + """Sets the ts_cert of this Config. + + + :param ts_cert: The ts_cert of this Config. # noqa: E501 + :type: str + """ + + self._ts_cert = ts_cert + + @property + def ts_hash(self): + """Gets the ts_hash of this Config. # noqa: E501 + + + :return: The ts_hash of this Config. # noqa: E501 + :rtype: str + """ + return self._ts_hash + + @ts_hash.setter + def ts_hash(self, ts_hash): + """Sets the ts_hash of this Config. + + + :param ts_hash: The ts_hash of this Config. # noqa: E501 + :type: str + """ + + self._ts_hash = ts_hash + + @property + def ts_limit(self): + """Gets the ts_limit of this Config. # noqa: E501 + + + :return: The ts_limit of this Config. # noqa: E501 + :rtype: str + """ + return self._ts_limit + + @ts_limit.setter + def ts_limit(self, ts_limit): + """Sets the ts_limit of this Config. + + + :param ts_limit: The ts_limit of this Config. # noqa: E501 + :type: str + """ + + self._ts_limit = ts_limit + + @property + def ts_login(self): + """Gets the ts_login of this Config. # noqa: E501 + + + :return: The ts_login of this Config. # noqa: E501 + :rtype: str + """ + return self._ts_login + + @ts_login.setter + def ts_login(self, ts_login): + """Sets the ts_login of this Config. + + + :param ts_login: The ts_login of this Config. # noqa: E501 + :type: str + """ + + self._ts_login = ts_login + + @property + def ts_password(self): + """Gets the ts_password of this Config. # noqa: E501 + + + :return: The ts_password of this Config. # noqa: E501 + :rtype: str + """ + return self._ts_password + + @ts_password.setter + def ts_password(self, ts_password): + """Sets the ts_password of this Config. + + + :param ts_password: The ts_password of this Config. # noqa: E501 + :type: str + """ + + self._ts_password = ts_password + + @property + def ts_url(self): + """Gets the ts_url of this Config. # noqa: E501 + + + :return: The ts_url of this Config. # noqa: E501 + :rtype: str + """ + return self._ts_url + + @ts_url.setter + def ts_url(self, ts_url): + """Sets the ts_url of this Config. + + + :param ts_url: The ts_url of this Config. # noqa: E501 + :type: str + """ + + self._ts_url = ts_url + + @property + def uploads_storage(self): + """Gets the uploads_storage of this Config. # noqa: E501 + + + :return: The uploads_storage of this Config. # noqa: E501 + :rtype: str + """ + return self._uploads_storage + + @uploads_storage.setter + def uploads_storage(self, uploads_storage): + """Sets the uploads_storage of this Config. + + + :param uploads_storage: The uploads_storage of this Config. # noqa: E501 + :type: str + """ + + self._uploads_storage = uploads_storage + + @property + def users_validity_is_externally_managed(self): + """Gets the users_validity_is_externally_managed of this Config. # noqa: E501 + + + :return: The users_validity_is_externally_managed of this Config. # noqa: E501 + :rtype: str + """ + return self._users_validity_is_externally_managed + + @users_validity_is_externally_managed.setter + def users_validity_is_externally_managed(self, users_validity_is_externally_managed): + """Sets the users_validity_is_externally_managed of this Config. + + + :param users_validity_is_externally_managed: The users_validity_is_externally_managed of this Config. # noqa: E501 + :type: str + """ + + self._users_validity_is_externally_managed = users_validity_is_externally_managed + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Config, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Config): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/container.py b/vendor/elabapi-python/elabapi_python/models/container.py new file mode 100644 index 0000000..1e43d97 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/container.py @@ -0,0 +1,342 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Container(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'qty_stored': 'str', + 'qty_unit': 'str', + 'storage_id': 'int', + 'item_id': 'int', + 'created_at': 'str', + 'modified_at': 'str', + 'storage_name': 'str', + 'full_path': 'str' + } + + attribute_map = { + 'id': 'id', + 'qty_stored': 'qty_stored', + 'qty_unit': 'qty_unit', + 'storage_id': 'storage_id', + 'item_id': 'item_id', + 'created_at': 'created_at', + 'modified_at': 'modified_at', + 'storage_name': 'storage_name', + 'full_path': 'full_path' + } + + def __init__(self, id=None, qty_stored=None, qty_unit=None, storage_id=None, item_id=None, created_at=None, modified_at=None, storage_name=None, full_path=None): # noqa: E501 + """Container - a model defined in Swagger""" # noqa: E501 + self._id = None + self._qty_stored = None + self._qty_unit = None + self._storage_id = None + self._item_id = None + self._created_at = None + self._modified_at = None + self._storage_name = None + self._full_path = None + self.discriminator = None + if id is not None: + self.id = id + if qty_stored is not None: + self.qty_stored = qty_stored + if qty_unit is not None: + self.qty_unit = qty_unit + if storage_id is not None: + self.storage_id = storage_id + if item_id is not None: + self.item_id = item_id + if created_at is not None: + self.created_at = created_at + if modified_at is not None: + self.modified_at = modified_at + if storage_name is not None: + self.storage_name = storage_name + if full_path is not None: + self.full_path = full_path + + @property + def id(self): + """Gets the id of this Container. # noqa: E501 + + The container link ID # noqa: E501 + + :return: The id of this Container. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this Container. + + The container link ID # noqa: E501 + + :param id: The id of this Container. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def qty_stored(self): + """Gets the qty_stored of this Container. # noqa: E501 + + Quantity stored in this container # noqa: E501 + + :return: The qty_stored of this Container. # noqa: E501 + :rtype: str + """ + return self._qty_stored + + @qty_stored.setter + def qty_stored(self, qty_stored): + """Sets the qty_stored of this Container. + + Quantity stored in this container # noqa: E501 + + :param qty_stored: The qty_stored of this Container. # noqa: E501 + :type: str + """ + + self._qty_stored = qty_stored + + @property + def qty_unit(self): + """Gets the qty_unit of this Container. # noqa: E501 + + Unit of the quantity stored # noqa: E501 + + :return: The qty_unit of this Container. # noqa: E501 + :rtype: str + """ + return self._qty_unit + + @qty_unit.setter + def qty_unit(self, qty_unit): + """Sets the qty_unit of this Container. + + Unit of the quantity stored # noqa: E501 + + :param qty_unit: The qty_unit of this Container. # noqa: E501 + :type: str + """ + allowed_values = ["bar", "•", "m", "μL", "mL", "L", "μg", "mg", "g", "kg"] # noqa: E501 + if qty_unit not in allowed_values: + raise ValueError( + "Invalid value for `qty_unit` ({0}), must be one of {1}" # noqa: E501 + .format(qty_unit, allowed_values) + ) + + self._qty_unit = qty_unit + + @property + def storage_id(self): + """Gets the storage_id of this Container. # noqa: E501 + + ID of the storage unit # noqa: E501 + + :return: The storage_id of this Container. # noqa: E501 + :rtype: int + """ + return self._storage_id + + @storage_id.setter + def storage_id(self, storage_id): + """Sets the storage_id of this Container. + + ID of the storage unit # noqa: E501 + + :param storage_id: The storage_id of this Container. # noqa: E501 + :type: int + """ + + self._storage_id = storage_id + + @property + def item_id(self): + """Gets the item_id of this Container. # noqa: E501 + + ID of the entity (experiment or resource) # noqa: E501 + + :return: The item_id of this Container. # noqa: E501 + :rtype: int + """ + return self._item_id + + @item_id.setter + def item_id(self, item_id): + """Sets the item_id of this Container. + + ID of the entity (experiment or resource) # noqa: E501 + + :param item_id: The item_id of this Container. # noqa: E501 + :type: int + """ + + self._item_id = item_id + + @property + def created_at(self): + """Gets the created_at of this Container. # noqa: E501 + + When the container entry was created # noqa: E501 + + :return: The created_at of this Container. # noqa: E501 + :rtype: str + """ + return self._created_at + + @created_at.setter + def created_at(self, created_at): + """Sets the created_at of this Container. + + When the container entry was created # noqa: E501 + + :param created_at: The created_at of this Container. # noqa: E501 + :type: str + """ + + self._created_at = created_at + + @property + def modified_at(self): + """Gets the modified_at of this Container. # noqa: E501 + + When the container entry was last modified # noqa: E501 + + :return: The modified_at of this Container. # noqa: E501 + :rtype: str + """ + return self._modified_at + + @modified_at.setter + def modified_at(self, modified_at): + """Sets the modified_at of this Container. + + When the container entry was last modified # noqa: E501 + + :param modified_at: The modified_at of this Container. # noqa: E501 + :type: str + """ + + self._modified_at = modified_at + + @property + def storage_name(self): + """Gets the storage_name of this Container. # noqa: E501 + + Name of the storage unit # noqa: E501 + + :return: The storage_name of this Container. # noqa: E501 + :rtype: str + """ + return self._storage_name + + @storage_name.setter + def storage_name(self, storage_name): + """Sets the storage_name of this Container. + + Name of the storage unit # noqa: E501 + + :param storage_name: The storage_name of this Container. # noqa: E501 + :type: str + """ + + self._storage_name = storage_name + + @property + def full_path(self): + """Gets the full_path of this Container. # noqa: E501 + + Full hierarchical path of the storage unit # noqa: E501 + + :return: The full_path of this Container. # noqa: E501 + :rtype: str + """ + return self._full_path + + @full_path.setter + def full_path(self, full_path): + """Sets the full_path of this Container. + + Full hierarchical path of the storage unit # noqa: E501 + + :param full_path: The full_path of this Container. # noqa: E501 + :type: str + """ + + self._full_path = full_path + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Container, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Container): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/containers_subid_body.py b/vendor/elabapi-python/elabapi_python/models/containers_subid_body.py new file mode 100644 index 0000000..c64d67b --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/containers_subid_body.py @@ -0,0 +1,147 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class ContainersSubidBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'qty_stored': 'float', + 'qty_unit': 'str' + } + + attribute_map = { + 'qty_stored': 'qty_stored', + 'qty_unit': 'qty_unit' + } + + def __init__(self, qty_stored=None, qty_unit=None): # noqa: E501 + """ContainersSubidBody - a model defined in Swagger""" # noqa: E501 + self._qty_stored = None + self._qty_unit = None + self.discriminator = None + self.qty_stored = qty_stored + if qty_unit is not None: + self.qty_unit = qty_unit + + @property + def qty_stored(self): + """Gets the qty_stored of this ContainersSubidBody. # noqa: E501 + + Quantity stored. # noqa: E501 + + :return: The qty_stored of this ContainersSubidBody. # noqa: E501 + :rtype: float + """ + return self._qty_stored + + @qty_stored.setter + def qty_stored(self, qty_stored): + """Sets the qty_stored of this ContainersSubidBody. + + Quantity stored. # noqa: E501 + + :param qty_stored: The qty_stored of this ContainersSubidBody. # noqa: E501 + :type: float + """ + if qty_stored is None: + raise ValueError("Invalid value for `qty_stored`, must not be `None`") # noqa: E501 + + self._qty_stored = qty_stored + + @property + def qty_unit(self): + """Gets the qty_unit of this ContainersSubidBody. # noqa: E501 + + Unit of the quantity. Defaults to \"unit\" if not provided. # noqa: E501 + + :return: The qty_unit of this ContainersSubidBody. # noqa: E501 + :rtype: str + """ + return self._qty_unit + + @qty_unit.setter + def qty_unit(self, qty_unit): + """Sets the qty_unit of this ContainersSubidBody. + + Unit of the quantity. Defaults to \"unit\" if not provided. # noqa: E501 + + :param qty_unit: The qty_unit of this ContainersSubidBody. # noqa: E501 + :type: str + """ + allowed_values = ["bar", "•", "m", "μL", "mL", "L", "μg", "mg", "g", "kg"] # noqa: E501 + if qty_unit not in allowed_values: + raise ValueError( + "Invalid value for `qty_unit` ({0}), must be one of {1}" # noqa: E501 + .format(qty_unit, allowed_values) + ) + + self._qty_unit = qty_unit + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(ContainersSubidBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, ContainersSubidBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/containers_subid_body1.py b/vendor/elabapi-python/elabapi_python/models/containers_subid_body1.py new file mode 100644 index 0000000..887bfd8 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/containers_subid_body1.py @@ -0,0 +1,168 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class ContainersSubidBody1(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'qty_stored': 'float', + 'qty_unit': 'str', + 'storage_id': 'int' + } + + attribute_map = { + 'qty_stored': 'qty_stored', + 'qty_unit': 'qty_unit', + 'storage_id': 'storage_id' + } + + def __init__(self, qty_stored=None, qty_unit=None, storage_id=None): # noqa: E501 + """ContainersSubidBody1 - a model defined in Swagger""" # noqa: E501 + self._qty_stored = None + self._qty_unit = None + self._storage_id = None + self.discriminator = None + if qty_stored is not None: + self.qty_stored = qty_stored + if qty_unit is not None: + self.qty_unit = qty_unit + if storage_id is not None: + self.storage_id = storage_id + + @property + def qty_stored(self): + """Gets the qty_stored of this ContainersSubidBody1. # noqa: E501 + + New quantity stored. # noqa: E501 + + :return: The qty_stored of this ContainersSubidBody1. # noqa: E501 + :rtype: float + """ + return self._qty_stored + + @qty_stored.setter + def qty_stored(self, qty_stored): + """Sets the qty_stored of this ContainersSubidBody1. + + New quantity stored. # noqa: E501 + + :param qty_stored: The qty_stored of this ContainersSubidBody1. # noqa: E501 + :type: float + """ + + self._qty_stored = qty_stored + + @property + def qty_unit(self): + """Gets the qty_unit of this ContainersSubidBody1. # noqa: E501 + + New unit of the quantity. # noqa: E501 + + :return: The qty_unit of this ContainersSubidBody1. # noqa: E501 + :rtype: str + """ + return self._qty_unit + + @qty_unit.setter + def qty_unit(self, qty_unit): + """Sets the qty_unit of this ContainersSubidBody1. + + New unit of the quantity. # noqa: E501 + + :param qty_unit: The qty_unit of this ContainersSubidBody1. # noqa: E501 + :type: str + """ + + self._qty_unit = qty_unit + + @property + def storage_id(self): + """Gets the storage_id of this ContainersSubidBody1. # noqa: E501 + + New storage unit id. Moves the container to that storage unit. Requires write access on the parent entity and (when `inventory_require_edit_rights=1`) the `can_manage_inventory_locations` permission. # noqa: E501 + + :return: The storage_id of this ContainersSubidBody1. # noqa: E501 + :rtype: int + """ + return self._storage_id + + @storage_id.setter + def storage_id(self, storage_id): + """Sets the storage_id of this ContainersSubidBody1. + + New storage unit id. Moves the container to that storage unit. Requires write access on the parent entity and (when `inventory_require_edit_rights=1`) the `can_manage_inventory_locations` permission. # noqa: E501 + + :param storage_id: The storage_id of this ContainersSubidBody1. # noqa: E501 + :type: int + """ + + self._storage_id = storage_id + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(ContainersSubidBody1, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, ContainersSubidBody1): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/dspace_body.py b/vendor/elabapi-python/elabapi_python/models/dspace_body.py new file mode 100644 index 0000000..e6bc00e --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/dspace_body.py @@ -0,0 +1,142 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class DspaceBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'collection': 'str', + 'metadata': 'list[DspaceMetadata]' + } + + attribute_map = { + 'collection': 'collection', + 'metadata': 'metadata' + } + + def __init__(self, collection=None, metadata=None): # noqa: E501 + """DspaceBody - a model defined in Swagger""" # noqa: E501 + self._collection = None + self._metadata = None + self.discriminator = None + self.collection = collection + self.metadata = metadata + + @property + def collection(self): + """Gets the collection of this DspaceBody. # noqa: E501 + + UUID of the DSpace collection to submit to. # noqa: E501 + + :return: The collection of this DspaceBody. # noqa: E501 + :rtype: str + """ + return self._collection + + @collection.setter + def collection(self, collection): + """Sets the collection of this DspaceBody. + + UUID of the DSpace collection to submit to. # noqa: E501 + + :param collection: The collection of this DspaceBody. # noqa: E501 + :type: str + """ + if collection is None: + raise ValueError("Invalid value for `collection`, must not be `None`") # noqa: E501 + + self._collection = collection + + @property + def metadata(self): + """Gets the metadata of this DspaceBody. # noqa: E501 + + Metadata fields to populate the submission. # noqa: E501 + + :return: The metadata of this DspaceBody. # noqa: E501 + :rtype: list[DspaceMetadata] + """ + return self._metadata + + @metadata.setter + def metadata(self, metadata): + """Sets the metadata of this DspaceBody. + + Metadata fields to populate the submission. # noqa: E501 + + :param metadata: The metadata of this DspaceBody. # noqa: E501 + :type: list[DspaceMetadata] + """ + if metadata is None: + raise ValueError("Invalid value for `metadata`, must not be `None`") # noqa: E501 + + self._metadata = metadata + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(DspaceBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, DspaceBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/dspace_body1.py b/vendor/elabapi-python/elabapi_python/models/dspace_body1.py new file mode 100644 index 0000000..071dcde --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/dspace_body1.py @@ -0,0 +1,169 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class DspaceBody1(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'collection': 'str', + 'metadata': 'list[DspaceMetadata1]', + 'entity': 'DspaceEntity' + } + + attribute_map = { + 'collection': 'collection', + 'metadata': 'metadata', + 'entity': 'entity' + } + + def __init__(self, collection=None, metadata=None, entity=None): # noqa: E501 + """DspaceBody1 - a model defined in Swagger""" # noqa: E501 + self._collection = None + self._metadata = None + self._entity = None + self.discriminator = None + self.collection = collection + self.metadata = metadata + self.entity = entity + + @property + def collection(self): + """Gets the collection of this DspaceBody1. # noqa: E501 + + UUID of the collection. # noqa: E501 + + :return: The collection of this DspaceBody1. # noqa: E501 + :rtype: str + """ + return self._collection + + @collection.setter + def collection(self, collection): + """Sets the collection of this DspaceBody1. + + UUID of the collection. # noqa: E501 + + :param collection: The collection of this DspaceBody1. # noqa: E501 + :type: str + """ + if collection is None: + raise ValueError("Invalid value for `collection`, must not be `None`") # noqa: E501 + + self._collection = collection + + @property + def metadata(self): + """Gets the metadata of this DspaceBody1. # noqa: E501 + + DSpace metadata entries. At minimum, dc.title is required by most DSpace configurations. # noqa: E501 + + :return: The metadata of this DspaceBody1. # noqa: E501 + :rtype: list[DspaceMetadata1] + """ + return self._metadata + + @metadata.setter + def metadata(self, metadata): + """Sets the metadata of this DspaceBody1. + + DSpace metadata entries. At minimum, dc.title is required by most DSpace configurations. # noqa: E501 + + :param metadata: The metadata of this DspaceBody1. # noqa: E501 + :type: list[DspaceMetadata1] + """ + if metadata is None: + raise ValueError("Invalid value for `metadata`, must not be `None`") # noqa: E501 + + self._metadata = metadata + + @property + def entity(self): + """Gets the entity of this DspaceBody1. # noqa: E501 + + + :return: The entity of this DspaceBody1. # noqa: E501 + :rtype: DspaceEntity + """ + return self._entity + + @entity.setter + def entity(self, entity): + """Sets the entity of this DspaceBody1. + + + :param entity: The entity of this DspaceBody1. # noqa: E501 + :type: DspaceEntity + """ + if entity is None: + raise ValueError("Invalid value for `entity`, must not be `None`") # noqa: E501 + + self._entity = entity + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(DspaceBody1, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, DspaceBody1): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/dspace_entity.py b/vendor/elabapi-python/elabapi_python/models/dspace_entity.py new file mode 100644 index 0000000..ffa429f --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/dspace_entity.py @@ -0,0 +1,142 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class DspaceEntity(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'type': 'str', + 'id': 'int' + } + + attribute_map = { + 'type': 'type', + 'id': 'id' + } + + def __init__(self, type=None, id=None): # noqa: E501 + """DspaceEntity - a model defined in Swagger""" # noqa: E501 + self._type = None + self._id = None + self.discriminator = None + self.type = type + self.id = id + + @property + def type(self): + """Gets the type of this DspaceEntity. # noqa: E501 + + eLabFTW entity type. # noqa: E501 + + :return: The type of this DspaceEntity. # noqa: E501 + :rtype: str + """ + return self._type + + @type.setter + def type(self, type): + """Sets the type of this DspaceEntity. + + eLabFTW entity type. # noqa: E501 + + :param type: The type of this DspaceEntity. # noqa: E501 + :type: str + """ + if type is None: + raise ValueError("Invalid value for `type`, must not be `None`") # noqa: E501 + + self._type = type + + @property + def id(self): + """Gets the id of this DspaceEntity. # noqa: E501 + + ID of the entity to export. # noqa: E501 + + :return: The id of this DspaceEntity. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this DspaceEntity. + + ID of the entity to export. # noqa: E501 + + :param id: The id of this DspaceEntity. # noqa: E501 + :type: int + """ + if id is None: + raise ValueError("Invalid value for `id`, must not be `None`") # noqa: E501 + + self._id = id + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(DspaceEntity, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, DspaceEntity): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/dspace_metadata.py b/vendor/elabapi-python/elabapi_python/models/dspace_metadata.py new file mode 100644 index 0000000..3d626e9 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/dspace_metadata.py @@ -0,0 +1,138 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class DspaceMetadata(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'key': 'str', + 'value': 'str' + } + + attribute_map = { + 'key': 'key', + 'value': 'value' + } + + def __init__(self, key=None, value=None): # noqa: E501 + """DspaceMetadata - a model defined in Swagger""" # noqa: E501 + self._key = None + self._value = None + self.discriminator = None + self.key = key + self.value = value + + @property + def key(self): + """Gets the key of this DspaceMetadata. # noqa: E501 + + + :return: The key of this DspaceMetadata. # noqa: E501 + :rtype: str + """ + return self._key + + @key.setter + def key(self, key): + """Sets the key of this DspaceMetadata. + + + :param key: The key of this DspaceMetadata. # noqa: E501 + :type: str + """ + if key is None: + raise ValueError("Invalid value for `key`, must not be `None`") # noqa: E501 + + self._key = key + + @property + def value(self): + """Gets the value of this DspaceMetadata. # noqa: E501 + + + :return: The value of this DspaceMetadata. # noqa: E501 + :rtype: str + """ + return self._value + + @value.setter + def value(self, value): + """Sets the value of this DspaceMetadata. + + + :param value: The value of this DspaceMetadata. # noqa: E501 + :type: str + """ + if value is None: + raise ValueError("Invalid value for `value`, must not be `None`") # noqa: E501 + + self._value = value + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(DspaceMetadata, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, DspaceMetadata): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/dspace_metadata1.py b/vendor/elabapi-python/elabapi_python/models/dspace_metadata1.py new file mode 100644 index 0000000..37c59fb --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/dspace_metadata1.py @@ -0,0 +1,138 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class DspaceMetadata1(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'key': 'str', + 'value': 'str' + } + + attribute_map = { + 'key': 'key', + 'value': 'value' + } + + def __init__(self, key=None, value=None): # noqa: E501 + """DspaceMetadata1 - a model defined in Swagger""" # noqa: E501 + self._key = None + self._value = None + self.discriminator = None + self.key = key + self.value = value + + @property + def key(self): + """Gets the key of this DspaceMetadata1. # noqa: E501 + + + :return: The key of this DspaceMetadata1. # noqa: E501 + :rtype: str + """ + return self._key + + @key.setter + def key(self, key): + """Sets the key of this DspaceMetadata1. + + + :param key: The key of this DspaceMetadata1. # noqa: E501 + :type: str + """ + if key is None: + raise ValueError("Invalid value for `key`, must not be `None`") # noqa: E501 + + self._key = key + + @property + def value(self): + """Gets the value of this DspaceMetadata1. # noqa: E501 + + + :return: The value of this DspaceMetadata1. # noqa: E501 + :rtype: str + """ + return self._value + + @value.setter + def value(self, value): + """Sets the value of this DspaceMetadata1. + + + :param value: The value of this DspaceMetadata1. # noqa: E501 + :type: str + """ + if value is None: + raise ValueError("Invalid value for `value`, must not be `None`") # noqa: E501 + + self._value = value + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(DspaceMetadata1, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, DspaceMetadata1): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/entity.py b/vendor/elabapi-python/elabapi_python/models/entity.py new file mode 100644 index 0000000..e1b9669 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/entity.py @@ -0,0 +1,1222 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six +from elabapi_python.models.entity_editable import EntityEditable # noqa: F401,E501 + +class Entity(EntityEditable): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'access_key': 'str', + 'body_html': 'str', + 'category_color': 'str', + 'category_title': 'str', + 'changelog': 'list[Changelog]', + 'comments': 'list[Comment]', + 'compounds_links': 'list[Compound]', + 'created_at': 'str', + 'created_from_id': 'int', + 'created_from_type': 'int', + 'created_from_type_human': 'str', + 'elabid': 'str', + 'exclusive_edit_mode': 'ExclusiveEditMode', + 'experiments_links': 'list[Link]', + 'firstname': 'str', + 'fullname': 'str', + 'hide_main_text': 'int', + 'id': 'int', + 'items_links': 'list[Link]', + 'lastchangeby': 'int', + 'lastname': 'str', + 'locked': 'int', + 'lockedby': 'int', + 'locked_at': 'str', + 'modified_at': 'str', + 'next_step': 'str', + 'orcid': 'str', + 'page': 'str', + 'recent_comment': 'str', + 'related_experiments_links': 'list[Link]', + 'related_items_links': 'list[Link]', + 'sharelink': 'str', + 'status_color': 'str', + 'status_title': 'str', + 'steps': 'list[Step]', + 'tags': 'str', + 'tags_id': 'str', + 'team': 'int', + 'timestamped': 'int', + 'timestampedby': 'int', + 'timestamped_at': 'str', + 'type': 'str', + 'uploads': 'list[Upload]' + } + if hasattr(EntityEditable, "swagger_types"): + swagger_types.update(EntityEditable.swagger_types) + + attribute_map = { + 'access_key': 'access_key', + 'body_html': 'body_html', + 'category_color': 'category_color', + 'category_title': 'category_title', + 'changelog': 'changelog', + 'comments': 'comments', + 'compounds_links': 'compounds_links', + 'created_at': 'created_at', + 'created_from_id': 'created_from_id', + 'created_from_type': 'created_from_type', + 'created_from_type_human': 'created_from_type_human', + 'elabid': 'elabid', + 'exclusive_edit_mode': 'exclusive_edit_mode', + 'experiments_links': 'experiments_links', + 'firstname': 'firstname', + 'fullname': 'fullname', + 'hide_main_text': 'hide_main_text', + 'id': 'id', + 'items_links': 'items_links', + 'lastchangeby': 'lastchangeby', + 'lastname': 'lastname', + 'locked': 'locked', + 'lockedby': 'lockedby', + 'locked_at': 'locked_at', + 'modified_at': 'modified_at', + 'next_step': 'next_step', + 'orcid': 'orcid', + 'page': 'page', + 'recent_comment': 'recent_comment', + 'related_experiments_links': 'related_experiments_links', + 'related_items_links': 'related_items_links', + 'sharelink': 'sharelink', + 'status_color': 'status_color', + 'status_title': 'status_title', + 'steps': 'steps', + 'tags': 'tags', + 'tags_id': 'tags_id', + 'team': 'team', + 'timestamped': 'timestamped', + 'timestampedby': 'timestampedby', + 'timestamped_at': 'timestamped_at', + 'type': 'type', + 'uploads': 'uploads' + } + if hasattr(EntityEditable, "attribute_map"): + attribute_map.update(EntityEditable.attribute_map) + + def __init__(self, access_key=None, body_html=None, category_color=None, category_title=None, changelog=None, comments=None, compounds_links=None, created_at=None, created_from_id=None, created_from_type=None, created_from_type_human=None, elabid=None, exclusive_edit_mode=None, experiments_links=None, firstname=None, fullname=None, hide_main_text=None, id=None, items_links=None, lastchangeby=None, lastname=None, locked=None, lockedby=None, locked_at=None, modified_at=None, next_step=None, orcid=None, page=None, recent_comment=None, related_experiments_links=None, related_items_links=None, sharelink=None, status_color=None, status_title=None, steps=None, tags=None, tags_id=None, team=None, timestamped=None, timestampedby=None, timestamped_at=None, type=None, uploads=None, *args, **kwargs): # noqa: E501 + """Entity - a model defined in Swagger""" # noqa: E501 + self._access_key = None + self._body_html = None + self._category_color = None + self._category_title = None + self._changelog = None + self._comments = None + self._compounds_links = None + self._created_at = None + self._created_from_id = None + self._created_from_type = None + self._created_from_type_human = None + self._elabid = None + self._exclusive_edit_mode = None + self._experiments_links = None + self._firstname = None + self._fullname = None + self._hide_main_text = None + self._id = None + self._items_links = None + self._lastchangeby = None + self._lastname = None + self._locked = None + self._lockedby = None + self._locked_at = None + self._modified_at = None + self._next_step = None + self._orcid = None + self._page = None + self._recent_comment = None + self._related_experiments_links = None + self._related_items_links = None + self._sharelink = None + self._status_color = None + self._status_title = None + self._steps = None + self._tags = None + self._tags_id = None + self._team = None + self._timestamped = None + self._timestampedby = None + self._timestamped_at = None + self._type = None + self._uploads = None + self.discriminator = None + if access_key is not None: + self.access_key = access_key + if body_html is not None: + self.body_html = body_html + if category_color is not None: + self.category_color = category_color + if category_title is not None: + self.category_title = category_title + if changelog is not None: + self.changelog = changelog + if comments is not None: + self.comments = comments + if compounds_links is not None: + self.compounds_links = compounds_links + if created_at is not None: + self.created_at = created_at + if created_from_id is not None: + self.created_from_id = created_from_id + if created_from_type is not None: + self.created_from_type = created_from_type + if created_from_type_human is not None: + self.created_from_type_human = created_from_type_human + if elabid is not None: + self.elabid = elabid + if exclusive_edit_mode is not None: + self.exclusive_edit_mode = exclusive_edit_mode + if experiments_links is not None: + self.experiments_links = experiments_links + if firstname is not None: + self.firstname = firstname + if fullname is not None: + self.fullname = fullname + if hide_main_text is not None: + self.hide_main_text = hide_main_text + if id is not None: + self.id = id + if items_links is not None: + self.items_links = items_links + if lastchangeby is not None: + self.lastchangeby = lastchangeby + if lastname is not None: + self.lastname = lastname + if locked is not None: + self.locked = locked + if lockedby is not None: + self.lockedby = lockedby + if locked_at is not None: + self.locked_at = locked_at + if modified_at is not None: + self.modified_at = modified_at + if next_step is not None: + self.next_step = next_step + if orcid is not None: + self.orcid = orcid + if page is not None: + self.page = page + if recent_comment is not None: + self.recent_comment = recent_comment + if related_experiments_links is not None: + self.related_experiments_links = related_experiments_links + if related_items_links is not None: + self.related_items_links = related_items_links + if sharelink is not None: + self.sharelink = sharelink + if status_color is not None: + self.status_color = status_color + if status_title is not None: + self.status_title = status_title + if steps is not None: + self.steps = steps + if tags is not None: + self.tags = tags + if tags_id is not None: + self.tags_id = tags_id + if team is not None: + self.team = team + if timestamped is not None: + self.timestamped = timestamped + if timestampedby is not None: + self.timestampedby = timestampedby + if timestamped_at is not None: + self.timestamped_at = timestamped_at + if type is not None: + self.type = type + if uploads is not None: + self.uploads = uploads + EntityEditable.__init__(self, *args, **kwargs) + + @property + def access_key(self): + """Gets the access_key of this Entity. # noqa: E501 + + + :return: The access_key of this Entity. # noqa: E501 + :rtype: str + """ + return self._access_key + + @access_key.setter + def access_key(self, access_key): + """Sets the access_key of this Entity. + + + :param access_key: The access_key of this Entity. # noqa: E501 + :type: str + """ + + self._access_key = access_key + + @property + def body_html(self): + """Gets the body_html of this Entity. # noqa: E501 + + + :return: The body_html of this Entity. # noqa: E501 + :rtype: str + """ + return self._body_html + + @body_html.setter + def body_html(self, body_html): + """Sets the body_html of this Entity. + + + :param body_html: The body_html of this Entity. # noqa: E501 + :type: str + """ + + self._body_html = body_html + + @property + def category_color(self): + """Gets the category_color of this Entity. # noqa: E501 + + + :return: The category_color of this Entity. # noqa: E501 + :rtype: str + """ + return self._category_color + + @category_color.setter + def category_color(self, category_color): + """Sets the category_color of this Entity. + + + :param category_color: The category_color of this Entity. # noqa: E501 + :type: str + """ + + self._category_color = category_color + + @property + def category_title(self): + """Gets the category_title of this Entity. # noqa: E501 + + + :return: The category_title of this Entity. # noqa: E501 + :rtype: str + """ + return self._category_title + + @category_title.setter + def category_title(self, category_title): + """Sets the category_title of this Entity. + + + :param category_title: The category_title of this Entity. # noqa: E501 + :type: str + """ + + self._category_title = category_title + + @property + def changelog(self): + """Gets the changelog of this Entity. # noqa: E501 + + + :return: The changelog of this Entity. # noqa: E501 + :rtype: list[Changelog] + """ + return self._changelog + + @changelog.setter + def changelog(self, changelog): + """Sets the changelog of this Entity. + + + :param changelog: The changelog of this Entity. # noqa: E501 + :type: list[Changelog] + """ + + self._changelog = changelog + + @property + def comments(self): + """Gets the comments of this Entity. # noqa: E501 + + + :return: The comments of this Entity. # noqa: E501 + :rtype: list[Comment] + """ + return self._comments + + @comments.setter + def comments(self, comments): + """Sets the comments of this Entity. + + + :param comments: The comments of this Entity. # noqa: E501 + :type: list[Comment] + """ + + self._comments = comments + + @property + def compounds_links(self): + """Gets the compounds_links of this Entity. # noqa: E501 + + + :return: The compounds_links of this Entity. # noqa: E501 + :rtype: list[Compound] + """ + return self._compounds_links + + @compounds_links.setter + def compounds_links(self, compounds_links): + """Sets the compounds_links of this Entity. + + + :param compounds_links: The compounds_links of this Entity. # noqa: E501 + :type: list[Compound] + """ + + self._compounds_links = compounds_links + + @property + def created_at(self): + """Gets the created_at of this Entity. # noqa: E501 + + + :return: The created_at of this Entity. # noqa: E501 + :rtype: str + """ + return self._created_at + + @created_at.setter + def created_at(self, created_at): + """Sets the created_at of this Entity. + + + :param created_at: The created_at of this Entity. # noqa: E501 + :type: str + """ + + self._created_at = created_at + + @property + def created_from_id(self): + """Gets the created_from_id of this Entity. # noqa: E501 + + Id of the template used to create this entry. # noqa: E501 + + :return: The created_from_id of this Entity. # noqa: E501 + :rtype: int + """ + return self._created_from_id + + @created_from_id.setter + def created_from_id(self, created_from_id): + """Sets the created_from_id of this Entity. + + Id of the template used to create this entry. # noqa: E501 + + :param created_from_id: The created_from_id of this Entity. # noqa: E501 + :type: int + """ + + self._created_from_id = created_from_id + + @property + def created_from_type(self): + """Gets the created_from_type of this Entity. # noqa: E501 + + Type of the entity used to create this entry: template or concrete type if duplicate # noqa: E501 + + :return: The created_from_type of this Entity. # noqa: E501 + :rtype: int + """ + return self._created_from_type + + @created_from_type.setter + def created_from_type(self, created_from_type): + """Sets the created_from_type of this Entity. + + Type of the entity used to create this entry: template or concrete type if duplicate # noqa: E501 + + :param created_from_type: The created_from_type of this Entity. # noqa: E501 + :type: int + """ + + self._created_from_type = created_from_type + + @property + def created_from_type_human(self): + """Gets the created_from_type_human of this Entity. # noqa: E501 + + Human readable version of created_from_type integer. # noqa: E501 + + :return: The created_from_type_human of this Entity. # noqa: E501 + :rtype: str + """ + return self._created_from_type_human + + @created_from_type_human.setter + def created_from_type_human(self, created_from_type_human): + """Sets the created_from_type_human of this Entity. + + Human readable version of created_from_type integer. # noqa: E501 + + :param created_from_type_human: The created_from_type_human of this Entity. # noqa: E501 + :type: str + """ + + self._created_from_type_human = created_from_type_human + + @property + def elabid(self): + """Gets the elabid of this Entity. # noqa: E501 + + + :return: The elabid of this Entity. # noqa: E501 + :rtype: str + """ + return self._elabid + + @elabid.setter + def elabid(self, elabid): + """Sets the elabid of this Entity. + + + :param elabid: The elabid of this Entity. # noqa: E501 + :type: str + """ + + self._elabid = elabid + + @property + def exclusive_edit_mode(self): + """Gets the exclusive_edit_mode of this Entity. # noqa: E501 + + + :return: The exclusive_edit_mode of this Entity. # noqa: E501 + :rtype: ExclusiveEditMode + """ + return self._exclusive_edit_mode + + @exclusive_edit_mode.setter + def exclusive_edit_mode(self, exclusive_edit_mode): + """Sets the exclusive_edit_mode of this Entity. + + + :param exclusive_edit_mode: The exclusive_edit_mode of this Entity. # noqa: E501 + :type: ExclusiveEditMode + """ + + self._exclusive_edit_mode = exclusive_edit_mode + + @property + def experiments_links(self): + """Gets the experiments_links of this Entity. # noqa: E501 + + + :return: The experiments_links of this Entity. # noqa: E501 + :rtype: list[Link] + """ + return self._experiments_links + + @experiments_links.setter + def experiments_links(self, experiments_links): + """Sets the experiments_links of this Entity. + + + :param experiments_links: The experiments_links of this Entity. # noqa: E501 + :type: list[Link] + """ + + self._experiments_links = experiments_links + + @property + def firstname(self): + """Gets the firstname of this Entity. # noqa: E501 + + + :return: The firstname of this Entity. # noqa: E501 + :rtype: str + """ + return self._firstname + + @firstname.setter + def firstname(self, firstname): + """Sets the firstname of this Entity. + + + :param firstname: The firstname of this Entity. # noqa: E501 + :type: str + """ + + self._firstname = firstname + + @property + def fullname(self): + """Gets the fullname of this Entity. # noqa: E501 + + + :return: The fullname of this Entity. # noqa: E501 + :rtype: str + """ + return self._fullname + + @fullname.setter + def fullname(self, fullname): + """Sets the fullname of this Entity. + + + :param fullname: The fullname of this Entity. # noqa: E501 + :type: str + """ + + self._fullname = fullname + + @property + def hide_main_text(self): + """Gets the hide_main_text of this Entity. # noqa: E501 + + Hide the main text of an entry. When applied to templates, this setting also applies to derived entries. # noqa: E501 + + :return: The hide_main_text of this Entity. # noqa: E501 + :rtype: int + """ + return self._hide_main_text + + @hide_main_text.setter + def hide_main_text(self, hide_main_text): + """Sets the hide_main_text of this Entity. + + Hide the main text of an entry. When applied to templates, this setting also applies to derived entries. # noqa: E501 + + :param hide_main_text: The hide_main_text of this Entity. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if hide_main_text not in allowed_values: + raise ValueError( + "Invalid value for `hide_main_text` ({0}), must be one of {1}" # noqa: E501 + .format(hide_main_text, allowed_values) + ) + + self._hide_main_text = hide_main_text + + @property + def id(self): + """Gets the id of this Entity. # noqa: E501 + + + :return: The id of this Entity. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this Entity. + + + :param id: The id of this Entity. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def items_links(self): + """Gets the items_links of this Entity. # noqa: E501 + + + :return: The items_links of this Entity. # noqa: E501 + :rtype: list[Link] + """ + return self._items_links + + @items_links.setter + def items_links(self, items_links): + """Sets the items_links of this Entity. + + + :param items_links: The items_links of this Entity. # noqa: E501 + :type: list[Link] + """ + + self._items_links = items_links + + @property + def lastchangeby(self): + """Gets the lastchangeby of this Entity. # noqa: E501 + + + :return: The lastchangeby of this Entity. # noqa: E501 + :rtype: int + """ + return self._lastchangeby + + @lastchangeby.setter + def lastchangeby(self, lastchangeby): + """Sets the lastchangeby of this Entity. + + + :param lastchangeby: The lastchangeby of this Entity. # noqa: E501 + :type: int + """ + + self._lastchangeby = lastchangeby + + @property + def lastname(self): + """Gets the lastname of this Entity. # noqa: E501 + + + :return: The lastname of this Entity. # noqa: E501 + :rtype: str + """ + return self._lastname + + @lastname.setter + def lastname(self, lastname): + """Sets the lastname of this Entity. + + + :param lastname: The lastname of this Entity. # noqa: E501 + :type: str + """ + + self._lastname = lastname + + @property + def locked(self): + """Gets the locked of this Entity. # noqa: E501 + + + :return: The locked of this Entity. # noqa: E501 + :rtype: int + """ + return self._locked + + @locked.setter + def locked(self, locked): + """Sets the locked of this Entity. + + + :param locked: The locked of this Entity. # noqa: E501 + :type: int + """ + + self._locked = locked + + @property + def lockedby(self): + """Gets the lockedby of this Entity. # noqa: E501 + + + :return: The lockedby of this Entity. # noqa: E501 + :rtype: int + """ + return self._lockedby + + @lockedby.setter + def lockedby(self, lockedby): + """Sets the lockedby of this Entity. + + + :param lockedby: The lockedby of this Entity. # noqa: E501 + :type: int + """ + + self._lockedby = lockedby + + @property + def locked_at(self): + """Gets the locked_at of this Entity. # noqa: E501 + + + :return: The locked_at of this Entity. # noqa: E501 + :rtype: str + """ + return self._locked_at + + @locked_at.setter + def locked_at(self, locked_at): + """Sets the locked_at of this Entity. + + + :param locked_at: The locked_at of this Entity. # noqa: E501 + :type: str + """ + + self._locked_at = locked_at + + @property + def modified_at(self): + """Gets the modified_at of this Entity. # noqa: E501 + + + :return: The modified_at of this Entity. # noqa: E501 + :rtype: str + """ + return self._modified_at + + @modified_at.setter + def modified_at(self, modified_at): + """Sets the modified_at of this Entity. + + + :param modified_at: The modified_at of this Entity. # noqa: E501 + :type: str + """ + + self._modified_at = modified_at + + @property + def next_step(self): + """Gets the next_step of this Entity. # noqa: E501 + + + :return: The next_step of this Entity. # noqa: E501 + :rtype: str + """ + return self._next_step + + @next_step.setter + def next_step(self, next_step): + """Sets the next_step of this Entity. + + + :param next_step: The next_step of this Entity. # noqa: E501 + :type: str + """ + + self._next_step = next_step + + @property + def orcid(self): + """Gets the orcid of this Entity. # noqa: E501 + + + :return: The orcid of this Entity. # noqa: E501 + :rtype: str + """ + return self._orcid + + @orcid.setter + def orcid(self, orcid): + """Sets the orcid of this Entity. + + + :param orcid: The orcid of this Entity. # noqa: E501 + :type: str + """ + + self._orcid = orcid + + @property + def page(self): + """Gets the page of this Entity. # noqa: E501 + + + :return: The page of this Entity. # noqa: E501 + :rtype: str + """ + return self._page + + @page.setter + def page(self, page): + """Sets the page of this Entity. + + + :param page: The page of this Entity. # noqa: E501 + :type: str + """ + + self._page = page + + @property + def recent_comment(self): + """Gets the recent_comment of this Entity. # noqa: E501 + + + :return: The recent_comment of this Entity. # noqa: E501 + :rtype: str + """ + return self._recent_comment + + @recent_comment.setter + def recent_comment(self, recent_comment): + """Sets the recent_comment of this Entity. + + + :param recent_comment: The recent_comment of this Entity. # noqa: E501 + :type: str + """ + + self._recent_comment = recent_comment + + @property + def related_experiments_links(self): + """Gets the related_experiments_links of this Entity. # noqa: E501 + + + :return: The related_experiments_links of this Entity. # noqa: E501 + :rtype: list[Link] + """ + return self._related_experiments_links + + @related_experiments_links.setter + def related_experiments_links(self, related_experiments_links): + """Sets the related_experiments_links of this Entity. + + + :param related_experiments_links: The related_experiments_links of this Entity. # noqa: E501 + :type: list[Link] + """ + + self._related_experiments_links = related_experiments_links + + @property + def related_items_links(self): + """Gets the related_items_links of this Entity. # noqa: E501 + + + :return: The related_items_links of this Entity. # noqa: E501 + :rtype: list[Link] + """ + return self._related_items_links + + @related_items_links.setter + def related_items_links(self, related_items_links): + """Sets the related_items_links of this Entity. + + + :param related_items_links: The related_items_links of this Entity. # noqa: E501 + :type: list[Link] + """ + + self._related_items_links = related_items_links + + @property + def sharelink(self): + """Gets the sharelink of this Entity. # noqa: E501 + + + :return: The sharelink of this Entity. # noqa: E501 + :rtype: str + """ + return self._sharelink + + @sharelink.setter + def sharelink(self, sharelink): + """Sets the sharelink of this Entity. + + + :param sharelink: The sharelink of this Entity. # noqa: E501 + :type: str + """ + + self._sharelink = sharelink + + @property + def status_color(self): + """Gets the status_color of this Entity. # noqa: E501 + + + :return: The status_color of this Entity. # noqa: E501 + :rtype: str + """ + return self._status_color + + @status_color.setter + def status_color(self, status_color): + """Sets the status_color of this Entity. + + + :param status_color: The status_color of this Entity. # noqa: E501 + :type: str + """ + + self._status_color = status_color + + @property + def status_title(self): + """Gets the status_title of this Entity. # noqa: E501 + + + :return: The status_title of this Entity. # noqa: E501 + :rtype: str + """ + return self._status_title + + @status_title.setter + def status_title(self, status_title): + """Sets the status_title of this Entity. + + + :param status_title: The status_title of this Entity. # noqa: E501 + :type: str + """ + + self._status_title = status_title + + @property + def steps(self): + """Gets the steps of this Entity. # noqa: E501 + + + :return: The steps of this Entity. # noqa: E501 + :rtype: list[Step] + """ + return self._steps + + @steps.setter + def steps(self, steps): + """Sets the steps of this Entity. + + + :param steps: The steps of this Entity. # noqa: E501 + :type: list[Step] + """ + + self._steps = steps + + @property + def tags(self): + """Gets the tags of this Entity. # noqa: E501 + + + :return: The tags of this Entity. # noqa: E501 + :rtype: str + """ + return self._tags + + @tags.setter + def tags(self, tags): + """Sets the tags of this Entity. + + + :param tags: The tags of this Entity. # noqa: E501 + :type: str + """ + + self._tags = tags + + @property + def tags_id(self): + """Gets the tags_id of this Entity. # noqa: E501 + + + :return: The tags_id of this Entity. # noqa: E501 + :rtype: str + """ + return self._tags_id + + @tags_id.setter + def tags_id(self, tags_id): + """Sets the tags_id of this Entity. + + + :param tags_id: The tags_id of this Entity. # noqa: E501 + :type: str + """ + + self._tags_id = tags_id + + @property + def team(self): + """Gets the team of this Entity. # noqa: E501 + + + :return: The team of this Entity. # noqa: E501 + :rtype: int + """ + return self._team + + @team.setter + def team(self, team): + """Sets the team of this Entity. + + + :param team: The team of this Entity. # noqa: E501 + :type: int + """ + + self._team = team + + @property + def timestamped(self): + """Gets the timestamped of this Entity. # noqa: E501 + + + :return: The timestamped of this Entity. # noqa: E501 + :rtype: int + """ + return self._timestamped + + @timestamped.setter + def timestamped(self, timestamped): + """Sets the timestamped of this Entity. + + + :param timestamped: The timestamped of this Entity. # noqa: E501 + :type: int + """ + + self._timestamped = timestamped + + @property + def timestampedby(self): + """Gets the timestampedby of this Entity. # noqa: E501 + + + :return: The timestampedby of this Entity. # noqa: E501 + :rtype: int + """ + return self._timestampedby + + @timestampedby.setter + def timestampedby(self, timestampedby): + """Sets the timestampedby of this Entity. + + + :param timestampedby: The timestampedby of this Entity. # noqa: E501 + :type: int + """ + + self._timestampedby = timestampedby + + @property + def timestamped_at(self): + """Gets the timestamped_at of this Entity. # noqa: E501 + + + :return: The timestamped_at of this Entity. # noqa: E501 + :rtype: str + """ + return self._timestamped_at + + @timestamped_at.setter + def timestamped_at(self, timestamped_at): + """Sets the timestamped_at of this Entity. + + + :param timestamped_at: The timestamped_at of this Entity. # noqa: E501 + :type: str + """ + + self._timestamped_at = timestamped_at + + @property + def type(self): + """Gets the type of this Entity. # noqa: E501 + + + :return: The type of this Entity. # noqa: E501 + :rtype: str + """ + return self._type + + @type.setter + def type(self, type): + """Sets the type of this Entity. + + + :param type: The type of this Entity. # noqa: E501 + :type: str + """ + + self._type = type + + @property + def uploads(self): + """Gets the uploads of this Entity. # noqa: E501 + + + :return: The uploads of this Entity. # noqa: E501 + :rtype: list[Upload] + """ + return self._uploads + + @uploads.setter + def uploads(self, uploads): + """Sets the uploads of this Entity. + + + :param uploads: The uploads of this Entity. # noqa: E501 + :type: list[Upload] + """ + + self._uploads = uploads + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Entity, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Entity): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/entity_and_item_editable.py b/vendor/elabapi-python/elabapi_python/models/entity_and_item_editable.py new file mode 100644 index 0000000..7ee994c --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/entity_and_item_editable.py @@ -0,0 +1,450 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six +from elabapi_python.models.entity_editable import EntityEditable # noqa: F401,E501 + +class EntityAndItemEditable(EntityEditable): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'is_bookable': 'int', + 'canbook_base': 'float', + 'canbook': 'str', + 'book_max_minutes': 'int', + 'book_max_slots': 'int', + 'book_can_overlap': 'int', + 'book_users_can_in_past': 'int', + 'book_is_cancellable': 'int', + 'book_cancel_minutes': 'int', + 'booking_window_days': 'int', + 'booking_hourly_rate_notax': 'float', + 'booking_hourly_rate_tax': 'float', + 'booking_hourly_rate_currency': 'int' + } + if hasattr(EntityEditable, "swagger_types"): + swagger_types.update(EntityEditable.swagger_types) + + attribute_map = { + 'is_bookable': 'is_bookable', + 'canbook_base': 'canbook_base', + 'canbook': 'canbook', + 'book_max_minutes': 'book_max_minutes', + 'book_max_slots': 'book_max_slots', + 'book_can_overlap': 'book_can_overlap', + 'book_users_can_in_past': 'book_users_can_in_past', + 'book_is_cancellable': 'book_is_cancellable', + 'book_cancel_minutes': 'book_cancel_minutes', + 'booking_window_days': 'booking_window_days', + 'booking_hourly_rate_notax': 'booking_hourly_rate_notax', + 'booking_hourly_rate_tax': 'booking_hourly_rate_tax', + 'booking_hourly_rate_currency': 'booking_hourly_rate_currency' + } + if hasattr(EntityEditable, "attribute_map"): + attribute_map.update(EntityEditable.attribute_map) + + def __init__(self, is_bookable=None, canbook_base=None, canbook=None, book_max_minutes=None, book_max_slots=None, book_can_overlap=None, book_users_can_in_past=None, book_is_cancellable=None, book_cancel_minutes=None, booking_window_days=None, booking_hourly_rate_notax=None, booking_hourly_rate_tax=None, booking_hourly_rate_currency=None, *args, **kwargs): # noqa: E501 + """EntityAndItemEditable - a model defined in Swagger""" # noqa: E501 + self._is_bookable = None + self._canbook_base = None + self._canbook = None + self._book_max_minutes = None + self._book_max_slots = None + self._book_can_overlap = None + self._book_users_can_in_past = None + self._book_is_cancellable = None + self._book_cancel_minutes = None + self._booking_window_days = None + self._booking_hourly_rate_notax = None + self._booking_hourly_rate_tax = None + self._booking_hourly_rate_currency = None + self.discriminator = None + if is_bookable is not None: + self.is_bookable = is_bookable + if canbook_base is not None: + self.canbook_base = canbook_base + if canbook is not None: + self.canbook = canbook + if book_max_minutes is not None: + self.book_max_minutes = book_max_minutes + if book_max_slots is not None: + self.book_max_slots = book_max_slots + if book_can_overlap is not None: + self.book_can_overlap = book_can_overlap + if book_users_can_in_past is not None: + self.book_users_can_in_past = book_users_can_in_past + if book_is_cancellable is not None: + self.book_is_cancellable = book_is_cancellable + if book_cancel_minutes is not None: + self.book_cancel_minutes = book_cancel_minutes + if booking_window_days is not None: + self.booking_window_days = booking_window_days + if booking_hourly_rate_notax is not None: + self.booking_hourly_rate_notax = booking_hourly_rate_notax + if booking_hourly_rate_tax is not None: + self.booking_hourly_rate_tax = booking_hourly_rate_tax + if booking_hourly_rate_currency is not None: + self.booking_hourly_rate_currency = booking_hourly_rate_currency + EntityEditable.__init__(self, *args, **kwargs) + + @property + def is_bookable(self): + """Gets the is_bookable of this EntityAndItemEditable. # noqa: E501 + + + :return: The is_bookable of this EntityAndItemEditable. # noqa: E501 + :rtype: int + """ + return self._is_bookable + + @is_bookable.setter + def is_bookable(self, is_bookable): + """Sets the is_bookable of this EntityAndItemEditable. + + + :param is_bookable: The is_bookable of this EntityAndItemEditable. # noqa: E501 + :type: int + """ + + self._is_bookable = is_bookable + + @property + def canbook_base(self): + """Gets the canbook_base of this EntityAndItemEditable. # noqa: E501 + + Base permission for booking access: - 10: Owner only - 20: Owner + Admins - 30: Team members - 40: Everyone with an account - 50: Everyone including anonymous users # noqa: E501 + + :return: The canbook_base of this EntityAndItemEditable. # noqa: E501 + :rtype: float + """ + return self._canbook_base + + @canbook_base.setter + def canbook_base(self, canbook_base): + """Sets the canbook_base of this EntityAndItemEditable. + + Base permission for booking access: - 10: Owner only - 20: Owner + Admins - 30: Team members - 40: Everyone with an account - 50: Everyone including anonymous users # noqa: E501 + + :param canbook_base: The canbook_base of this EntityAndItemEditable. # noqa: E501 + :type: float + """ + allowed_values = [10, 20, 30, 40, 50] # noqa: E501 + if canbook_base not in allowed_values: + raise ValueError( + "Invalid value for `canbook_base` ({0}), must be one of {1}" # noqa: E501 + .format(canbook_base, allowed_values) + ) + + self._canbook_base = canbook_base + + @property + def canbook(self): + """Gets the canbook of this EntityAndItemEditable. # noqa: E501 + + + :return: The canbook of this EntityAndItemEditable. # noqa: E501 + :rtype: str + """ + return self._canbook + + @canbook.setter + def canbook(self, canbook): + """Sets the canbook of this EntityAndItemEditable. + + + :param canbook: The canbook of this EntityAndItemEditable. # noqa: E501 + :type: str + """ + + self._canbook = canbook + + @property + def book_max_minutes(self): + """Gets the book_max_minutes of this EntityAndItemEditable. # noqa: E501 + + + :return: The book_max_minutes of this EntityAndItemEditable. # noqa: E501 + :rtype: int + """ + return self._book_max_minutes + + @book_max_minutes.setter + def book_max_minutes(self, book_max_minutes): + """Sets the book_max_minutes of this EntityAndItemEditable. + + + :param book_max_minutes: The book_max_minutes of this EntityAndItemEditable. # noqa: E501 + :type: int + """ + + self._book_max_minutes = book_max_minutes + + @property + def book_max_slots(self): + """Gets the book_max_slots of this EntityAndItemEditable. # noqa: E501 + + + :return: The book_max_slots of this EntityAndItemEditable. # noqa: E501 + :rtype: int + """ + return self._book_max_slots + + @book_max_slots.setter + def book_max_slots(self, book_max_slots): + """Sets the book_max_slots of this EntityAndItemEditable. + + + :param book_max_slots: The book_max_slots of this EntityAndItemEditable. # noqa: E501 + :type: int + """ + + self._book_max_slots = book_max_slots + + @property + def book_can_overlap(self): + """Gets the book_can_overlap of this EntityAndItemEditable. # noqa: E501 + + + :return: The book_can_overlap of this EntityAndItemEditable. # noqa: E501 + :rtype: int + """ + return self._book_can_overlap + + @book_can_overlap.setter + def book_can_overlap(self, book_can_overlap): + """Sets the book_can_overlap of this EntityAndItemEditable. + + + :param book_can_overlap: The book_can_overlap of this EntityAndItemEditable. # noqa: E501 + :type: int + """ + + self._book_can_overlap = book_can_overlap + + @property + def book_users_can_in_past(self): + """Gets the book_users_can_in_past of this EntityAndItemEditable. # noqa: E501 + + + :return: The book_users_can_in_past of this EntityAndItemEditable. # noqa: E501 + :rtype: int + """ + return self._book_users_can_in_past + + @book_users_can_in_past.setter + def book_users_can_in_past(self, book_users_can_in_past): + """Sets the book_users_can_in_past of this EntityAndItemEditable. + + + :param book_users_can_in_past: The book_users_can_in_past of this EntityAndItemEditable. # noqa: E501 + :type: int + """ + + self._book_users_can_in_past = book_users_can_in_past + + @property + def book_is_cancellable(self): + """Gets the book_is_cancellable of this EntityAndItemEditable. # noqa: E501 + + + :return: The book_is_cancellable of this EntityAndItemEditable. # noqa: E501 + :rtype: int + """ + return self._book_is_cancellable + + @book_is_cancellable.setter + def book_is_cancellable(self, book_is_cancellable): + """Sets the book_is_cancellable of this EntityAndItemEditable. + + + :param book_is_cancellable: The book_is_cancellable of this EntityAndItemEditable. # noqa: E501 + :type: int + """ + + self._book_is_cancellable = book_is_cancellable + + @property + def book_cancel_minutes(self): + """Gets the book_cancel_minutes of this EntityAndItemEditable. # noqa: E501 + + + :return: The book_cancel_minutes of this EntityAndItemEditable. # noqa: E501 + :rtype: int + """ + return self._book_cancel_minutes + + @book_cancel_minutes.setter + def book_cancel_minutes(self, book_cancel_minutes): + """Sets the book_cancel_minutes of this EntityAndItemEditable. + + + :param book_cancel_minutes: The book_cancel_minutes of this EntityAndItemEditable. # noqa: E501 + :type: int + """ + + self._book_cancel_minutes = book_cancel_minutes + + @property + def booking_window_days(self): + """Gets the booking_window_days of this EntityAndItemEditable. # noqa: E501 + + How many days in advance users can book an item. 0 means no limit. # noqa: E501 + + :return: The booking_window_days of this EntityAndItemEditable. # noqa: E501 + :rtype: int + """ + return self._booking_window_days + + @booking_window_days.setter + def booking_window_days(self, booking_window_days): + """Sets the booking_window_days of this EntityAndItemEditable. + + How many days in advance users can book an item. 0 means no limit. # noqa: E501 + + :param booking_window_days: The booking_window_days of this EntityAndItemEditable. # noqa: E501 + :type: int + """ + + self._booking_window_days = booking_window_days + + @property + def booking_hourly_rate_notax(self): + """Gets the booking_hourly_rate_notax of this EntityAndItemEditable. # noqa: E501 + + The hourly rate of booked resource, without taxes. # noqa: E501 + + :return: The booking_hourly_rate_notax of this EntityAndItemEditable. # noqa: E501 + :rtype: float + """ + return self._booking_hourly_rate_notax + + @booking_hourly_rate_notax.setter + def booking_hourly_rate_notax(self, booking_hourly_rate_notax): + """Sets the booking_hourly_rate_notax of this EntityAndItemEditable. + + The hourly rate of booked resource, without taxes. # noqa: E501 + + :param booking_hourly_rate_notax: The booking_hourly_rate_notax of this EntityAndItemEditable. # noqa: E501 + :type: float + """ + + self._booking_hourly_rate_notax = booking_hourly_rate_notax + + @property + def booking_hourly_rate_tax(self): + """Gets the booking_hourly_rate_tax of this EntityAndItemEditable. # noqa: E501 + + The hourly rate of booked resource, with taxes. # noqa: E501 + + :return: The booking_hourly_rate_tax of this EntityAndItemEditable. # noqa: E501 + :rtype: float + """ + return self._booking_hourly_rate_tax + + @booking_hourly_rate_tax.setter + def booking_hourly_rate_tax(self, booking_hourly_rate_tax): + """Sets the booking_hourly_rate_tax of this EntityAndItemEditable. + + The hourly rate of booked resource, with taxes. # noqa: E501 + + :param booking_hourly_rate_tax: The booking_hourly_rate_tax of this EntityAndItemEditable. # noqa: E501 + :type: float + """ + + self._booking_hourly_rate_tax = booking_hourly_rate_tax + + @property + def booking_hourly_rate_currency(self): + """Gets the booking_hourly_rate_currency of this EntityAndItemEditable. # noqa: E501 + + The currency of the hourly rate: - 0: CAD - 1: CHF - 2: CNY - 3: DKK - 4: EUR - 5: GBP - 6: JPY - 7: USD - 8: SEK - 9: NOK # noqa: E501 + + :return: The booking_hourly_rate_currency of this EntityAndItemEditable. # noqa: E501 + :rtype: int + """ + return self._booking_hourly_rate_currency + + @booking_hourly_rate_currency.setter + def booking_hourly_rate_currency(self, booking_hourly_rate_currency): + """Sets the booking_hourly_rate_currency of this EntityAndItemEditable. + + The currency of the hourly rate: - 0: CAD - 1: CHF - 2: CNY - 3: DKK - 4: EUR - 5: GBP - 6: JPY - 7: USD - 8: SEK - 9: NOK # noqa: E501 + + :param booking_hourly_rate_currency: The booking_hourly_rate_currency of this EntityAndItemEditable. # noqa: E501 + :type: int + """ + allowed_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # noqa: E501 + if booking_hourly_rate_currency not in allowed_values: + raise ValueError( + "Invalid value for `booking_hourly_rate_currency` ({0}), must be one of {1}" # noqa: E501 + .format(booking_hourly_rate_currency, allowed_values) + ) + + self._booking_hourly_rate_currency = booking_hourly_rate_currency + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(EntityAndItemEditable, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, EntityAndItemEditable): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/entity_duplicate.py b/vendor/elabapi-python/elabapi_python/models/entity_duplicate.py new file mode 100644 index 0000000..e47253e --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/entity_duplicate.py @@ -0,0 +1,168 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class EntityDuplicate(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'action': 'str', + 'copy_files': 'bool', + 'link_to_original': 'bool' + } + + attribute_map = { + 'action': 'action', + 'copy_files': 'copyFiles', + 'link_to_original': 'linkToOriginal' + } + + def __init__(self, action='duplicate', copy_files=False, link_to_original=True): # noqa: E501 + """EntityDuplicate - a model defined in Swagger""" # noqa: E501 + self._action = None + self._copy_files = None + self._link_to_original = None + self.discriminator = None + if action is not None: + self.action = action + if copy_files is not None: + self.copy_files = copy_files + if link_to_original is not None: + self.link_to_original = link_to_original + + @property + def action(self): + """Gets the action of this EntityDuplicate. # noqa: E501 + + The \"duplicate\" action creates a new entity based from the given entity id. # noqa: E501 + + :return: The action of this EntityDuplicate. # noqa: E501 + :rtype: str + """ + return self._action + + @action.setter + def action(self, action): + """Sets the action of this EntityDuplicate. + + The \"duplicate\" action creates a new entity based from the given entity id. # noqa: E501 + + :param action: The action of this EntityDuplicate. # noqa: E501 + :type: str + """ + + self._action = action + + @property + def copy_files(self): + """Gets the copy_files of this EntityDuplicate. # noqa: E501 + + If \"true\", the action will import the files of the original entity. # noqa: E501 + + :return: The copy_files of this EntityDuplicate. # noqa: E501 + :rtype: bool + """ + return self._copy_files + + @copy_files.setter + def copy_files(self, copy_files): + """Sets the copy_files of this EntityDuplicate. + + If \"true\", the action will import the files of the original entity. # noqa: E501 + + :param copy_files: The copy_files of this EntityDuplicate. # noqa: E501 + :type: bool + """ + + self._copy_files = copy_files + + @property + def link_to_original(self): + """Gets the link_to_original of this EntityDuplicate. # noqa: E501 + + If \"true\", the action will create a link to the original entity. # noqa: E501 + + :return: The link_to_original of this EntityDuplicate. # noqa: E501 + :rtype: bool + """ + return self._link_to_original + + @link_to_original.setter + def link_to_original(self, link_to_original): + """Sets the link_to_original of this EntityDuplicate. + + If \"true\", the action will create a link to the original entity. # noqa: E501 + + :param link_to_original: The link_to_original of this EntityDuplicate. # noqa: E501 + :type: bool + """ + + self._link_to_original = link_to_original + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(EntityDuplicate, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, EntityDuplicate): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/entity_editable.py b/vendor/elabapi-python/elabapi_python/models/entity_editable.py new file mode 100644 index 0000000..b3bf451 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/entity_editable.py @@ -0,0 +1,628 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class EntityEditable(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'body': 'str', + 'bodyappend': 'str', + 'canread_base': 'float', + 'canread': 'str', + 'canwrite_base': 'float', + 'canwrite': 'str', + 'category': 'int', + '_date': 'str', + 'content_type': 'int', + 'custom_id': 'int', + 'metadata': 'Metadata', + 'metadatamerge': 'AllOfentityEditableMetadatamerge', + 'rating': 'int', + 'state': 'int', + 'status': 'int', + 'title': 'str', + 'template': 'int', + 'userid': 'int', + 'team': 'int' + } + + attribute_map = { + 'body': 'body', + 'bodyappend': 'bodyappend', + 'canread_base': 'canread_base', + 'canread': 'canread', + 'canwrite_base': 'canwrite_base', + 'canwrite': 'canwrite', + 'category': 'category', + '_date': 'date', + 'content_type': 'content_type', + 'custom_id': 'custom_id', + 'metadata': 'metadata', + 'metadatamerge': 'metadatamerge', + 'rating': 'rating', + 'state': 'state', + 'status': 'status', + 'title': 'title', + 'template': 'template', + 'userid': 'userid', + 'team': 'team' + } + + def __init__(self, body=None, bodyappend=None, canread_base=None, canread='{"teams": [], "users": [], "teamgroups": []}', canwrite_base=None, canwrite='{"teams": [], "users": [], "teamgroups": []}', category=None, _date=None, content_type=None, custom_id=None, metadata=None, metadatamerge=None, rating=0, state=None, status=None, title='Untitled', template=-1, userid=None, team=None): # noqa: E501 + """EntityEditable - a model defined in Swagger""" # noqa: E501 + self._body = None + self._bodyappend = None + self._canread_base = None + self._canread = None + self._canwrite_base = None + self._canwrite = None + self._category = None + self.__date = None + self._content_type = None + self._custom_id = None + self._metadata = None + self._metadatamerge = None + self._rating = None + self._state = None + self._status = None + self._title = None + self._template = None + self._userid = None + self._team = None + self.discriminator = None + if body is not None: + self.body = body + if bodyappend is not None: + self.bodyappend = bodyappend + if canread_base is not None: + self.canread_base = canread_base + if canread is not None: + self.canread = canread + if canwrite_base is not None: + self.canwrite_base = canwrite_base + if canwrite is not None: + self.canwrite = canwrite + if category is not None: + self.category = category + if _date is not None: + self._date = _date + if content_type is not None: + self.content_type = content_type + if custom_id is not None: + self.custom_id = custom_id + if metadata is not None: + self.metadata = metadata + if metadatamerge is not None: + self.metadatamerge = metadatamerge + if rating is not None: + self.rating = rating + if state is not None: + self.state = state + if status is not None: + self.status = status + if title is not None: + self.title = title + if template is not None: + self.template = template + if userid is not None: + self.userid = userid + if team is not None: + self.team = team + + @property + def body(self): + """Gets the body of this EntityEditable. # noqa: E501 + + The main text content (HTML or Markdown) # noqa: E501 + + :return: The body of this EntityEditable. # noqa: E501 + :rtype: str + """ + return self._body + + @body.setter + def body(self, body): + """Sets the body of this EntityEditable. + + The main text content (HTML or Markdown) # noqa: E501 + + :param body: The body of this EntityEditable. # noqa: E501 + :type: str + """ + + self._body = body + + @property + def bodyappend(self): + """Gets the bodyappend of this EntityEditable. # noqa: E501 + + Append content to the existing entity body instead of replacing it. # noqa: E501 + + :return: The bodyappend of this EntityEditable. # noqa: E501 + :rtype: str + """ + return self._bodyappend + + @bodyappend.setter + def bodyappend(self, bodyappend): + """Sets the bodyappend of this EntityEditable. + + Append content to the existing entity body instead of replacing it. # noqa: E501 + + :param bodyappend: The bodyappend of this EntityEditable. # noqa: E501 + :type: str + """ + + self._bodyappend = bodyappend + + @property + def canread_base(self): + """Gets the canread_base of this EntityEditable. # noqa: E501 + + Base permission for read access: - 10: Owner only - 20: Owner + Admins - 30: Team members - 40: Everyone with an account - 50: Everyone including anonymous users # noqa: E501 + + :return: The canread_base of this EntityEditable. # noqa: E501 + :rtype: float + """ + return self._canread_base + + @canread_base.setter + def canread_base(self, canread_base): + """Sets the canread_base of this EntityEditable. + + Base permission for read access: - 10: Owner only - 20: Owner + Admins - 30: Team members - 40: Everyone with an account - 50: Everyone including anonymous users # noqa: E501 + + :param canread_base: The canread_base of this EntityEditable. # noqa: E501 + :type: float + """ + allowed_values = [10, 20, 30, 40, 50] # noqa: E501 + if canread_base not in allowed_values: + raise ValueError( + "Invalid value for `canread_base` ({0}), must be one of {1}" # noqa: E501 + .format(canread_base, allowed_values) + ) + + self._canread_base = canread_base + + @property + def canread(self): + """Gets the canread of this EntityEditable. # noqa: E501 + + JSON permissions for reading the entry # noqa: E501 + + :return: The canread of this EntityEditable. # noqa: E501 + :rtype: str + """ + return self._canread + + @canread.setter + def canread(self, canread): + """Sets the canread of this EntityEditable. + + JSON permissions for reading the entry # noqa: E501 + + :param canread: The canread of this EntityEditable. # noqa: E501 + :type: str + """ + + self._canread = canread + + @property + def canwrite_base(self): + """Gets the canwrite_base of this EntityEditable. # noqa: E501 + + Base permission for write access: - 10: Owner only - 20: Owner + Admins - 30: Team members - 40: Everyone with an account - 50: Everyone including anonymous users # noqa: E501 + + :return: The canwrite_base of this EntityEditable. # noqa: E501 + :rtype: float + """ + return self._canwrite_base + + @canwrite_base.setter + def canwrite_base(self, canwrite_base): + """Sets the canwrite_base of this EntityEditable. + + Base permission for write access: - 10: Owner only - 20: Owner + Admins - 30: Team members - 40: Everyone with an account - 50: Everyone including anonymous users # noqa: E501 + + :param canwrite_base: The canwrite_base of this EntityEditable. # noqa: E501 + :type: float + """ + allowed_values = [10, 20, 30, 40, 50] # noqa: E501 + if canwrite_base not in allowed_values: + raise ValueError( + "Invalid value for `canwrite_base` ({0}), must be one of {1}" # noqa: E501 + .format(canwrite_base, allowed_values) + ) + + self._canwrite_base = canwrite_base + + @property + def canwrite(self): + """Gets the canwrite of this EntityEditable. # noqa: E501 + + JSON permissions for writing the entry # noqa: E501 + + :return: The canwrite of this EntityEditable. # noqa: E501 + :rtype: str + """ + return self._canwrite + + @canwrite.setter + def canwrite(self, canwrite): + """Sets the canwrite of this EntityEditable. + + JSON permissions for writing the entry # noqa: E501 + + :param canwrite: The canwrite of this EntityEditable. # noqa: E501 + :type: str + """ + + self._canwrite = canwrite + + @property + def category(self): + """Gets the category of this EntityEditable. # noqa: E501 + + The experiment category ID # noqa: E501 + + :return: The category of this EntityEditable. # noqa: E501 + :rtype: int + """ + return self._category + + @category.setter + def category(self, category): + """Sets the category of this EntityEditable. + + The experiment category ID # noqa: E501 + + :param category: The category of this EntityEditable. # noqa: E501 + :type: int + """ + + self._category = category + + @property + def _date(self): + """Gets the _date of this EntityEditable. # noqa: E501 + + + :return: The _date of this EntityEditable. # noqa: E501 + :rtype: str + """ + return self.__date + + @_date.setter + def _date(self, _date): + """Sets the _date of this EntityEditable. + + + :param _date: The _date of this EntityEditable. # noqa: E501 + :type: str + """ + + self.__date = _date + + @property + def content_type(self): + """Gets the content_type of this EntityEditable. # noqa: E501 + + Set the content type for main text: - 1: HTML (default) - 2: Markdown If unset, it will use the user's preference value. # noqa: E501 + + :return: The content_type of this EntityEditable. # noqa: E501 + :rtype: int + """ + return self._content_type + + @content_type.setter + def content_type(self, content_type): + """Sets the content_type of this EntityEditable. + + Set the content type for main text: - 1: HTML (default) - 2: Markdown If unset, it will use the user's preference value. # noqa: E501 + + :param content_type: The content_type of this EntityEditable. # noqa: E501 + :type: int + """ + allowed_values = [1, 2] # noqa: E501 + if content_type not in allowed_values: + raise ValueError( + "Invalid value for `content_type` ({0}), must be one of {1}" # noqa: E501 + .format(content_type, allowed_values) + ) + + self._content_type = content_type + + @property + def custom_id(self): + """Gets the custom_id of this EntityEditable. # noqa: E501 + + Cannot be negative. Can be reset with \"0\", null or empty string. # noqa: E501 + + :return: The custom_id of this EntityEditable. # noqa: E501 + :rtype: int + """ + return self._custom_id + + @custom_id.setter + def custom_id(self, custom_id): + """Sets the custom_id of this EntityEditable. + + Cannot be negative. Can be reset with \"0\", null or empty string. # noqa: E501 + + :param custom_id: The custom_id of this EntityEditable. # noqa: E501 + :type: int + """ + + self._custom_id = custom_id + + @property + def metadata(self): + """Gets the metadata of this EntityEditable. # noqa: E501 + + + :return: The metadata of this EntityEditable. # noqa: E501 + :rtype: Metadata + """ + return self._metadata + + @metadata.setter + def metadata(self, metadata): + """Sets the metadata of this EntityEditable. + + + :param metadata: The metadata of this EntityEditable. # noqa: E501 + :type: Metadata + """ + + self._metadata = metadata + + @property + def metadatamerge(self): + """Gets the metadatamerge of this EntityEditable. # noqa: E501 + + Merge incoming metadata into the existing entity metadata. Existing extra fields keep their schema such as type, options, units and description; only their value is updated. Incoming extra fields that do not already exist are added. # noqa: E501 + + :return: The metadatamerge of this EntityEditable. # noqa: E501 + :rtype: AllOfentityEditableMetadatamerge + """ + return self._metadatamerge + + @metadatamerge.setter + def metadatamerge(self, metadatamerge): + """Sets the metadatamerge of this EntityEditable. + + Merge incoming metadata into the existing entity metadata. Existing extra fields keep their schema such as type, options, units and description; only their value is updated. Incoming extra fields that do not already exist are added. # noqa: E501 + + :param metadatamerge: The metadatamerge of this EntityEditable. # noqa: E501 + :type: AllOfentityEditableMetadatamerge + """ + + self._metadatamerge = metadatamerge + + @property + def rating(self): + """Gets the rating of this EntityEditable. # noqa: E501 + + Rating value from 0 to 5 # noqa: E501 + + :return: The rating of this EntityEditable. # noqa: E501 + :rtype: int + """ + return self._rating + + @rating.setter + def rating(self, rating): + """Sets the rating of this EntityEditable. + + Rating value from 0 to 5 # noqa: E501 + + :param rating: The rating of this EntityEditable. # noqa: E501 + :type: int + """ + + self._rating = rating + + @property + def state(self): + """Gets the state of this EntityEditable. # noqa: E501 + + + :return: The state of this EntityEditable. # noqa: E501 + :rtype: int + """ + return self._state + + @state.setter + def state(self, state): + """Sets the state of this EntityEditable. + + + :param state: The state of this EntityEditable. # noqa: E501 + :type: int + """ + + self._state = state + + @property + def status(self): + """Gets the status of this EntityEditable. # noqa: E501 + + Cannot be negative nor empty string. Can be reset with \"0\" and null. # noqa: E501 + + :return: The status of this EntityEditable. # noqa: E501 + :rtype: int + """ + return self._status + + @status.setter + def status(self, status): + """Sets the status of this EntityEditable. + + Cannot be negative nor empty string. Can be reset with \"0\" and null. # noqa: E501 + + :param status: The status of this EntityEditable. # noqa: E501 + :type: int + """ + + self._status = status + + @property + def title(self): + """Gets the title of this EntityEditable. # noqa: E501 + + The title of the entry # noqa: E501 + + :return: The title of this EntityEditable. # noqa: E501 + :rtype: str + """ + return self._title + + @title.setter + def title(self, title): + """Sets the title of this EntityEditable. + + The title of the entry # noqa: E501 + + :param title: The title of this EntityEditable. # noqa: E501 + :type: str + """ + + self._title = title + + @property + def template(self): + """Gets the template of this EntityEditable. # noqa: E501 + + The template id to use, or 0 to use the common team template, or -1 to have an empty body. # noqa: E501 + + :return: The template of this EntityEditable. # noqa: E501 + :rtype: int + """ + return self._template + + @template.setter + def template(self, template): + """Sets the template of this EntityEditable. + + The template id to use, or 0 to use the common team template, or -1 to have an empty body. # noqa: E501 + + :param template: The template of this EntityEditable. # noqa: E501 + :type: int + """ + + self._template = template + + @property + def userid(self): + """Gets the userid of this EntityEditable. # noqa: E501 + + User ID of the entity owner. When transferring ownership, the `team` field should also be provided (optional). # noqa: E501 + + :return: The userid of this EntityEditable. # noqa: E501 + :rtype: int + """ + return self._userid + + @userid.setter + def userid(self, userid): + """Sets the userid of this EntityEditable. + + User ID of the entity owner. When transferring ownership, the `team` field should also be provided (optional). # noqa: E501 + + :param userid: The userid of this EntityEditable. # noqa: E501 + :type: int + """ + + self._userid = userid + + @property + def team(self): + """Gets the team of this EntityEditable. # noqa: E501 + + Optional team context for ownership transfer. If omitted, the requester’s team is used by default. If provided, the API validates that the target user is a member of the specified team. # noqa: E501 + + :return: The team of this EntityEditable. # noqa: E501 + :rtype: int + """ + return self._team + + @team.setter + def team(self, team): + """Sets the team of this EntityEditable. + + Optional team context for ownership transfer. If omitted, the requester’s team is used by default. If provided, the API validates that the target user is a member of the specified team. # noqa: E501 + + :param team: The team of this EntityEditable. # noqa: E501 + :type: int + """ + + self._team = team + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(EntityEditable, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, EntityEditable): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/entity_template.py b/vendor/elabapi-python/elabapi_python/models/entity_template.py new file mode 100644 index 0000000..15555fa --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/entity_template.py @@ -0,0 +1,1222 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six +from elabapi_python.models.entity_template_editable import EntityTemplateEditable # noqa: F401,E501 + +class EntityTemplate(EntityTemplateEditable): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'access_key': 'str', + 'body_html': 'str', + 'category_color': 'str', + 'category_title': 'str', + 'changelog': 'list[Changelog]', + 'comments': 'list[Comment]', + 'compounds_links': 'list[Compound]', + 'created_at': 'str', + 'created_from_id': 'int', + 'created_from_type': 'int', + 'created_from_type_human': 'str', + 'elabid': 'str', + 'exclusive_edit_mode': 'ExclusiveEditMode', + 'experiments_links': 'list[Link]', + 'firstname': 'str', + 'fullname': 'str', + 'hide_main_text': 'int', + 'id': 'int', + 'items_links': 'list[Link]', + 'lastchangeby': 'int', + 'lastname': 'str', + 'locked': 'int', + 'lockedby': 'int', + 'locked_at': 'str', + 'modified_at': 'str', + 'next_step': 'str', + 'orcid': 'str', + 'page': 'str', + 'recent_comment': 'str', + 'related_experiments_links': 'list[Link]', + 'related_items_links': 'list[Link]', + 'sharelink': 'str', + 'status_color': 'str', + 'status_title': 'str', + 'steps': 'list[Step]', + 'tags': 'str', + 'tags_id': 'str', + 'team': 'int', + 'timestamped': 'int', + 'timestampedby': 'int', + 'timestamped_at': 'str', + 'type': 'str', + 'uploads': 'list[Upload]' + } + if hasattr(EntityTemplateEditable, "swagger_types"): + swagger_types.update(EntityTemplateEditable.swagger_types) + + attribute_map = { + 'access_key': 'access_key', + 'body_html': 'body_html', + 'category_color': 'category_color', + 'category_title': 'category_title', + 'changelog': 'changelog', + 'comments': 'comments', + 'compounds_links': 'compounds_links', + 'created_at': 'created_at', + 'created_from_id': 'created_from_id', + 'created_from_type': 'created_from_type', + 'created_from_type_human': 'created_from_type_human', + 'elabid': 'elabid', + 'exclusive_edit_mode': 'exclusive_edit_mode', + 'experiments_links': 'experiments_links', + 'firstname': 'firstname', + 'fullname': 'fullname', + 'hide_main_text': 'hide_main_text', + 'id': 'id', + 'items_links': 'items_links', + 'lastchangeby': 'lastchangeby', + 'lastname': 'lastname', + 'locked': 'locked', + 'lockedby': 'lockedby', + 'locked_at': 'locked_at', + 'modified_at': 'modified_at', + 'next_step': 'next_step', + 'orcid': 'orcid', + 'page': 'page', + 'recent_comment': 'recent_comment', + 'related_experiments_links': 'related_experiments_links', + 'related_items_links': 'related_items_links', + 'sharelink': 'sharelink', + 'status_color': 'status_color', + 'status_title': 'status_title', + 'steps': 'steps', + 'tags': 'tags', + 'tags_id': 'tags_id', + 'team': 'team', + 'timestamped': 'timestamped', + 'timestampedby': 'timestampedby', + 'timestamped_at': 'timestamped_at', + 'type': 'type', + 'uploads': 'uploads' + } + if hasattr(EntityTemplateEditable, "attribute_map"): + attribute_map.update(EntityTemplateEditable.attribute_map) + + def __init__(self, access_key=None, body_html=None, category_color=None, category_title=None, changelog=None, comments=None, compounds_links=None, created_at=None, created_from_id=None, created_from_type=None, created_from_type_human=None, elabid=None, exclusive_edit_mode=None, experiments_links=None, firstname=None, fullname=None, hide_main_text=None, id=None, items_links=None, lastchangeby=None, lastname=None, locked=None, lockedby=None, locked_at=None, modified_at=None, next_step=None, orcid=None, page=None, recent_comment=None, related_experiments_links=None, related_items_links=None, sharelink=None, status_color=None, status_title=None, steps=None, tags=None, tags_id=None, team=None, timestamped=None, timestampedby=None, timestamped_at=None, type=None, uploads=None, *args, **kwargs): # noqa: E501 + """EntityTemplate - a model defined in Swagger""" # noqa: E501 + self._access_key = None + self._body_html = None + self._category_color = None + self._category_title = None + self._changelog = None + self._comments = None + self._compounds_links = None + self._created_at = None + self._created_from_id = None + self._created_from_type = None + self._created_from_type_human = None + self._elabid = None + self._exclusive_edit_mode = None + self._experiments_links = None + self._firstname = None + self._fullname = None + self._hide_main_text = None + self._id = None + self._items_links = None + self._lastchangeby = None + self._lastname = None + self._locked = None + self._lockedby = None + self._locked_at = None + self._modified_at = None + self._next_step = None + self._orcid = None + self._page = None + self._recent_comment = None + self._related_experiments_links = None + self._related_items_links = None + self._sharelink = None + self._status_color = None + self._status_title = None + self._steps = None + self._tags = None + self._tags_id = None + self._team = None + self._timestamped = None + self._timestampedby = None + self._timestamped_at = None + self._type = None + self._uploads = None + self.discriminator = None + if access_key is not None: + self.access_key = access_key + if body_html is not None: + self.body_html = body_html + if category_color is not None: + self.category_color = category_color + if category_title is not None: + self.category_title = category_title + if changelog is not None: + self.changelog = changelog + if comments is not None: + self.comments = comments + if compounds_links is not None: + self.compounds_links = compounds_links + if created_at is not None: + self.created_at = created_at + if created_from_id is not None: + self.created_from_id = created_from_id + if created_from_type is not None: + self.created_from_type = created_from_type + if created_from_type_human is not None: + self.created_from_type_human = created_from_type_human + if elabid is not None: + self.elabid = elabid + if exclusive_edit_mode is not None: + self.exclusive_edit_mode = exclusive_edit_mode + if experiments_links is not None: + self.experiments_links = experiments_links + if firstname is not None: + self.firstname = firstname + if fullname is not None: + self.fullname = fullname + if hide_main_text is not None: + self.hide_main_text = hide_main_text + if id is not None: + self.id = id + if items_links is not None: + self.items_links = items_links + if lastchangeby is not None: + self.lastchangeby = lastchangeby + if lastname is not None: + self.lastname = lastname + if locked is not None: + self.locked = locked + if lockedby is not None: + self.lockedby = lockedby + if locked_at is not None: + self.locked_at = locked_at + if modified_at is not None: + self.modified_at = modified_at + if next_step is not None: + self.next_step = next_step + if orcid is not None: + self.orcid = orcid + if page is not None: + self.page = page + if recent_comment is not None: + self.recent_comment = recent_comment + if related_experiments_links is not None: + self.related_experiments_links = related_experiments_links + if related_items_links is not None: + self.related_items_links = related_items_links + if sharelink is not None: + self.sharelink = sharelink + if status_color is not None: + self.status_color = status_color + if status_title is not None: + self.status_title = status_title + if steps is not None: + self.steps = steps + if tags is not None: + self.tags = tags + if tags_id is not None: + self.tags_id = tags_id + if team is not None: + self.team = team + if timestamped is not None: + self.timestamped = timestamped + if timestampedby is not None: + self.timestampedby = timestampedby + if timestamped_at is not None: + self.timestamped_at = timestamped_at + if type is not None: + self.type = type + if uploads is not None: + self.uploads = uploads + EntityTemplateEditable.__init__(self, *args, **kwargs) + + @property + def access_key(self): + """Gets the access_key of this EntityTemplate. # noqa: E501 + + + :return: The access_key of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._access_key + + @access_key.setter + def access_key(self, access_key): + """Sets the access_key of this EntityTemplate. + + + :param access_key: The access_key of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._access_key = access_key + + @property + def body_html(self): + """Gets the body_html of this EntityTemplate. # noqa: E501 + + + :return: The body_html of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._body_html + + @body_html.setter + def body_html(self, body_html): + """Sets the body_html of this EntityTemplate. + + + :param body_html: The body_html of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._body_html = body_html + + @property + def category_color(self): + """Gets the category_color of this EntityTemplate. # noqa: E501 + + + :return: The category_color of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._category_color + + @category_color.setter + def category_color(self, category_color): + """Sets the category_color of this EntityTemplate. + + + :param category_color: The category_color of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._category_color = category_color + + @property + def category_title(self): + """Gets the category_title of this EntityTemplate. # noqa: E501 + + + :return: The category_title of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._category_title + + @category_title.setter + def category_title(self, category_title): + """Sets the category_title of this EntityTemplate. + + + :param category_title: The category_title of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._category_title = category_title + + @property + def changelog(self): + """Gets the changelog of this EntityTemplate. # noqa: E501 + + + :return: The changelog of this EntityTemplate. # noqa: E501 + :rtype: list[Changelog] + """ + return self._changelog + + @changelog.setter + def changelog(self, changelog): + """Sets the changelog of this EntityTemplate. + + + :param changelog: The changelog of this EntityTemplate. # noqa: E501 + :type: list[Changelog] + """ + + self._changelog = changelog + + @property + def comments(self): + """Gets the comments of this EntityTemplate. # noqa: E501 + + + :return: The comments of this EntityTemplate. # noqa: E501 + :rtype: list[Comment] + """ + return self._comments + + @comments.setter + def comments(self, comments): + """Sets the comments of this EntityTemplate. + + + :param comments: The comments of this EntityTemplate. # noqa: E501 + :type: list[Comment] + """ + + self._comments = comments + + @property + def compounds_links(self): + """Gets the compounds_links of this EntityTemplate. # noqa: E501 + + + :return: The compounds_links of this EntityTemplate. # noqa: E501 + :rtype: list[Compound] + """ + return self._compounds_links + + @compounds_links.setter + def compounds_links(self, compounds_links): + """Sets the compounds_links of this EntityTemplate. + + + :param compounds_links: The compounds_links of this EntityTemplate. # noqa: E501 + :type: list[Compound] + """ + + self._compounds_links = compounds_links + + @property + def created_at(self): + """Gets the created_at of this EntityTemplate. # noqa: E501 + + + :return: The created_at of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._created_at + + @created_at.setter + def created_at(self, created_at): + """Sets the created_at of this EntityTemplate. + + + :param created_at: The created_at of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._created_at = created_at + + @property + def created_from_id(self): + """Gets the created_from_id of this EntityTemplate. # noqa: E501 + + Id of the template used to create this entry. # noqa: E501 + + :return: The created_from_id of this EntityTemplate. # noqa: E501 + :rtype: int + """ + return self._created_from_id + + @created_from_id.setter + def created_from_id(self, created_from_id): + """Sets the created_from_id of this EntityTemplate. + + Id of the template used to create this entry. # noqa: E501 + + :param created_from_id: The created_from_id of this EntityTemplate. # noqa: E501 + :type: int + """ + + self._created_from_id = created_from_id + + @property + def created_from_type(self): + """Gets the created_from_type of this EntityTemplate. # noqa: E501 + + Type of the entity used to create this entry: template or concrete type if duplicate # noqa: E501 + + :return: The created_from_type of this EntityTemplate. # noqa: E501 + :rtype: int + """ + return self._created_from_type + + @created_from_type.setter + def created_from_type(self, created_from_type): + """Sets the created_from_type of this EntityTemplate. + + Type of the entity used to create this entry: template or concrete type if duplicate # noqa: E501 + + :param created_from_type: The created_from_type of this EntityTemplate. # noqa: E501 + :type: int + """ + + self._created_from_type = created_from_type + + @property + def created_from_type_human(self): + """Gets the created_from_type_human of this EntityTemplate. # noqa: E501 + + Human readable version of created_from_type integer. # noqa: E501 + + :return: The created_from_type_human of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._created_from_type_human + + @created_from_type_human.setter + def created_from_type_human(self, created_from_type_human): + """Sets the created_from_type_human of this EntityTemplate. + + Human readable version of created_from_type integer. # noqa: E501 + + :param created_from_type_human: The created_from_type_human of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._created_from_type_human = created_from_type_human + + @property + def elabid(self): + """Gets the elabid of this EntityTemplate. # noqa: E501 + + + :return: The elabid of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._elabid + + @elabid.setter + def elabid(self, elabid): + """Sets the elabid of this EntityTemplate. + + + :param elabid: The elabid of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._elabid = elabid + + @property + def exclusive_edit_mode(self): + """Gets the exclusive_edit_mode of this EntityTemplate. # noqa: E501 + + + :return: The exclusive_edit_mode of this EntityTemplate. # noqa: E501 + :rtype: ExclusiveEditMode + """ + return self._exclusive_edit_mode + + @exclusive_edit_mode.setter + def exclusive_edit_mode(self, exclusive_edit_mode): + """Sets the exclusive_edit_mode of this EntityTemplate. + + + :param exclusive_edit_mode: The exclusive_edit_mode of this EntityTemplate. # noqa: E501 + :type: ExclusiveEditMode + """ + + self._exclusive_edit_mode = exclusive_edit_mode + + @property + def experiments_links(self): + """Gets the experiments_links of this EntityTemplate. # noqa: E501 + + + :return: The experiments_links of this EntityTemplate. # noqa: E501 + :rtype: list[Link] + """ + return self._experiments_links + + @experiments_links.setter + def experiments_links(self, experiments_links): + """Sets the experiments_links of this EntityTemplate. + + + :param experiments_links: The experiments_links of this EntityTemplate. # noqa: E501 + :type: list[Link] + """ + + self._experiments_links = experiments_links + + @property + def firstname(self): + """Gets the firstname of this EntityTemplate. # noqa: E501 + + + :return: The firstname of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._firstname + + @firstname.setter + def firstname(self, firstname): + """Sets the firstname of this EntityTemplate. + + + :param firstname: The firstname of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._firstname = firstname + + @property + def fullname(self): + """Gets the fullname of this EntityTemplate. # noqa: E501 + + + :return: The fullname of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._fullname + + @fullname.setter + def fullname(self, fullname): + """Sets the fullname of this EntityTemplate. + + + :param fullname: The fullname of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._fullname = fullname + + @property + def hide_main_text(self): + """Gets the hide_main_text of this EntityTemplate. # noqa: E501 + + Hide the main text of an entry. When applied to templates, this setting also applies to derived entries. # noqa: E501 + + :return: The hide_main_text of this EntityTemplate. # noqa: E501 + :rtype: int + """ + return self._hide_main_text + + @hide_main_text.setter + def hide_main_text(self, hide_main_text): + """Sets the hide_main_text of this EntityTemplate. + + Hide the main text of an entry. When applied to templates, this setting also applies to derived entries. # noqa: E501 + + :param hide_main_text: The hide_main_text of this EntityTemplate. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if hide_main_text not in allowed_values: + raise ValueError( + "Invalid value for `hide_main_text` ({0}), must be one of {1}" # noqa: E501 + .format(hide_main_text, allowed_values) + ) + + self._hide_main_text = hide_main_text + + @property + def id(self): + """Gets the id of this EntityTemplate. # noqa: E501 + + + :return: The id of this EntityTemplate. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this EntityTemplate. + + + :param id: The id of this EntityTemplate. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def items_links(self): + """Gets the items_links of this EntityTemplate. # noqa: E501 + + + :return: The items_links of this EntityTemplate. # noqa: E501 + :rtype: list[Link] + """ + return self._items_links + + @items_links.setter + def items_links(self, items_links): + """Sets the items_links of this EntityTemplate. + + + :param items_links: The items_links of this EntityTemplate. # noqa: E501 + :type: list[Link] + """ + + self._items_links = items_links + + @property + def lastchangeby(self): + """Gets the lastchangeby of this EntityTemplate. # noqa: E501 + + + :return: The lastchangeby of this EntityTemplate. # noqa: E501 + :rtype: int + """ + return self._lastchangeby + + @lastchangeby.setter + def lastchangeby(self, lastchangeby): + """Sets the lastchangeby of this EntityTemplate. + + + :param lastchangeby: The lastchangeby of this EntityTemplate. # noqa: E501 + :type: int + """ + + self._lastchangeby = lastchangeby + + @property + def lastname(self): + """Gets the lastname of this EntityTemplate. # noqa: E501 + + + :return: The lastname of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._lastname + + @lastname.setter + def lastname(self, lastname): + """Sets the lastname of this EntityTemplate. + + + :param lastname: The lastname of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._lastname = lastname + + @property + def locked(self): + """Gets the locked of this EntityTemplate. # noqa: E501 + + + :return: The locked of this EntityTemplate. # noqa: E501 + :rtype: int + """ + return self._locked + + @locked.setter + def locked(self, locked): + """Sets the locked of this EntityTemplate. + + + :param locked: The locked of this EntityTemplate. # noqa: E501 + :type: int + """ + + self._locked = locked + + @property + def lockedby(self): + """Gets the lockedby of this EntityTemplate. # noqa: E501 + + + :return: The lockedby of this EntityTemplate. # noqa: E501 + :rtype: int + """ + return self._lockedby + + @lockedby.setter + def lockedby(self, lockedby): + """Sets the lockedby of this EntityTemplate. + + + :param lockedby: The lockedby of this EntityTemplate. # noqa: E501 + :type: int + """ + + self._lockedby = lockedby + + @property + def locked_at(self): + """Gets the locked_at of this EntityTemplate. # noqa: E501 + + + :return: The locked_at of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._locked_at + + @locked_at.setter + def locked_at(self, locked_at): + """Sets the locked_at of this EntityTemplate. + + + :param locked_at: The locked_at of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._locked_at = locked_at + + @property + def modified_at(self): + """Gets the modified_at of this EntityTemplate. # noqa: E501 + + + :return: The modified_at of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._modified_at + + @modified_at.setter + def modified_at(self, modified_at): + """Sets the modified_at of this EntityTemplate. + + + :param modified_at: The modified_at of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._modified_at = modified_at + + @property + def next_step(self): + """Gets the next_step of this EntityTemplate. # noqa: E501 + + + :return: The next_step of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._next_step + + @next_step.setter + def next_step(self, next_step): + """Sets the next_step of this EntityTemplate. + + + :param next_step: The next_step of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._next_step = next_step + + @property + def orcid(self): + """Gets the orcid of this EntityTemplate. # noqa: E501 + + + :return: The orcid of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._orcid + + @orcid.setter + def orcid(self, orcid): + """Sets the orcid of this EntityTemplate. + + + :param orcid: The orcid of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._orcid = orcid + + @property + def page(self): + """Gets the page of this EntityTemplate. # noqa: E501 + + + :return: The page of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._page + + @page.setter + def page(self, page): + """Sets the page of this EntityTemplate. + + + :param page: The page of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._page = page + + @property + def recent_comment(self): + """Gets the recent_comment of this EntityTemplate. # noqa: E501 + + + :return: The recent_comment of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._recent_comment + + @recent_comment.setter + def recent_comment(self, recent_comment): + """Sets the recent_comment of this EntityTemplate. + + + :param recent_comment: The recent_comment of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._recent_comment = recent_comment + + @property + def related_experiments_links(self): + """Gets the related_experiments_links of this EntityTemplate. # noqa: E501 + + + :return: The related_experiments_links of this EntityTemplate. # noqa: E501 + :rtype: list[Link] + """ + return self._related_experiments_links + + @related_experiments_links.setter + def related_experiments_links(self, related_experiments_links): + """Sets the related_experiments_links of this EntityTemplate. + + + :param related_experiments_links: The related_experiments_links of this EntityTemplate. # noqa: E501 + :type: list[Link] + """ + + self._related_experiments_links = related_experiments_links + + @property + def related_items_links(self): + """Gets the related_items_links of this EntityTemplate. # noqa: E501 + + + :return: The related_items_links of this EntityTemplate. # noqa: E501 + :rtype: list[Link] + """ + return self._related_items_links + + @related_items_links.setter + def related_items_links(self, related_items_links): + """Sets the related_items_links of this EntityTemplate. + + + :param related_items_links: The related_items_links of this EntityTemplate. # noqa: E501 + :type: list[Link] + """ + + self._related_items_links = related_items_links + + @property + def sharelink(self): + """Gets the sharelink of this EntityTemplate. # noqa: E501 + + + :return: The sharelink of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._sharelink + + @sharelink.setter + def sharelink(self, sharelink): + """Sets the sharelink of this EntityTemplate. + + + :param sharelink: The sharelink of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._sharelink = sharelink + + @property + def status_color(self): + """Gets the status_color of this EntityTemplate. # noqa: E501 + + + :return: The status_color of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._status_color + + @status_color.setter + def status_color(self, status_color): + """Sets the status_color of this EntityTemplate. + + + :param status_color: The status_color of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._status_color = status_color + + @property + def status_title(self): + """Gets the status_title of this EntityTemplate. # noqa: E501 + + + :return: The status_title of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._status_title + + @status_title.setter + def status_title(self, status_title): + """Sets the status_title of this EntityTemplate. + + + :param status_title: The status_title of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._status_title = status_title + + @property + def steps(self): + """Gets the steps of this EntityTemplate. # noqa: E501 + + + :return: The steps of this EntityTemplate. # noqa: E501 + :rtype: list[Step] + """ + return self._steps + + @steps.setter + def steps(self, steps): + """Sets the steps of this EntityTemplate. + + + :param steps: The steps of this EntityTemplate. # noqa: E501 + :type: list[Step] + """ + + self._steps = steps + + @property + def tags(self): + """Gets the tags of this EntityTemplate. # noqa: E501 + + + :return: The tags of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._tags + + @tags.setter + def tags(self, tags): + """Sets the tags of this EntityTemplate. + + + :param tags: The tags of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._tags = tags + + @property + def tags_id(self): + """Gets the tags_id of this EntityTemplate. # noqa: E501 + + + :return: The tags_id of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._tags_id + + @tags_id.setter + def tags_id(self, tags_id): + """Sets the tags_id of this EntityTemplate. + + + :param tags_id: The tags_id of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._tags_id = tags_id + + @property + def team(self): + """Gets the team of this EntityTemplate. # noqa: E501 + + + :return: The team of this EntityTemplate. # noqa: E501 + :rtype: int + """ + return self._team + + @team.setter + def team(self, team): + """Sets the team of this EntityTemplate. + + + :param team: The team of this EntityTemplate. # noqa: E501 + :type: int + """ + + self._team = team + + @property + def timestamped(self): + """Gets the timestamped of this EntityTemplate. # noqa: E501 + + + :return: The timestamped of this EntityTemplate. # noqa: E501 + :rtype: int + """ + return self._timestamped + + @timestamped.setter + def timestamped(self, timestamped): + """Sets the timestamped of this EntityTemplate. + + + :param timestamped: The timestamped of this EntityTemplate. # noqa: E501 + :type: int + """ + + self._timestamped = timestamped + + @property + def timestampedby(self): + """Gets the timestampedby of this EntityTemplate. # noqa: E501 + + + :return: The timestampedby of this EntityTemplate. # noqa: E501 + :rtype: int + """ + return self._timestampedby + + @timestampedby.setter + def timestampedby(self, timestampedby): + """Sets the timestampedby of this EntityTemplate. + + + :param timestampedby: The timestampedby of this EntityTemplate. # noqa: E501 + :type: int + """ + + self._timestampedby = timestampedby + + @property + def timestamped_at(self): + """Gets the timestamped_at of this EntityTemplate. # noqa: E501 + + + :return: The timestamped_at of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._timestamped_at + + @timestamped_at.setter + def timestamped_at(self, timestamped_at): + """Sets the timestamped_at of this EntityTemplate. + + + :param timestamped_at: The timestamped_at of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._timestamped_at = timestamped_at + + @property + def type(self): + """Gets the type of this EntityTemplate. # noqa: E501 + + + :return: The type of this EntityTemplate. # noqa: E501 + :rtype: str + """ + return self._type + + @type.setter + def type(self, type): + """Sets the type of this EntityTemplate. + + + :param type: The type of this EntityTemplate. # noqa: E501 + :type: str + """ + + self._type = type + + @property + def uploads(self): + """Gets the uploads of this EntityTemplate. # noqa: E501 + + + :return: The uploads of this EntityTemplate. # noqa: E501 + :rtype: list[Upload] + """ + return self._uploads + + @uploads.setter + def uploads(self, uploads): + """Sets the uploads of this EntityTemplate. + + + :param uploads: The uploads of this EntityTemplate. # noqa: E501 + :type: list[Upload] + """ + + self._uploads = uploads + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(EntityTemplate, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, EntityTemplate): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/entity_template_editable.py b/vendor/elabapi-python/elabapi_python/models/entity_template_editable.py new file mode 100644 index 0000000..e809e3e --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/entity_template_editable.py @@ -0,0 +1,146 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six +from elabapi_python.models.entity_editable import EntityEditable # noqa: F401,E501 + +class EntityTemplateEditable(EntityEditable): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'canread_is_immutable': 'int', + 'canwrite_is_immutable': 'int' + } + if hasattr(EntityEditable, "swagger_types"): + swagger_types.update(EntityEditable.swagger_types) + + attribute_map = { + 'canread_is_immutable': 'canread_is_immutable', + 'canwrite_is_immutable': 'canwrite_is_immutable' + } + if hasattr(EntityEditable, "attribute_map"): + attribute_map.update(EntityEditable.attribute_map) + + def __init__(self, canread_is_immutable=0, canwrite_is_immutable=0, *args, **kwargs): # noqa: E501 + """EntityTemplateEditable - a model defined in Swagger""" # noqa: E501 + self._canread_is_immutable = None + self._canwrite_is_immutable = None + self.discriminator = None + if canread_is_immutable is not None: + self.canread_is_immutable = canread_is_immutable + if canwrite_is_immutable is not None: + self.canwrite_is_immutable = canwrite_is_immutable + EntityEditable.__init__(self, *args, **kwargs) + + @property + def canread_is_immutable(self): + """Gets the canread_is_immutable of this EntityTemplateEditable. # noqa: E501 + + Set to 1 to prevent further changes to the permissions setting for read access # noqa: E501 + + :return: The canread_is_immutable of this EntityTemplateEditable. # noqa: E501 + :rtype: int + """ + return self._canread_is_immutable + + @canread_is_immutable.setter + def canread_is_immutable(self, canread_is_immutable): + """Sets the canread_is_immutable of this EntityTemplateEditable. + + Set to 1 to prevent further changes to the permissions setting for read access # noqa: E501 + + :param canread_is_immutable: The canread_is_immutable of this EntityTemplateEditable. # noqa: E501 + :type: int + """ + + self._canread_is_immutable = canread_is_immutable + + @property + def canwrite_is_immutable(self): + """Gets the canwrite_is_immutable of this EntityTemplateEditable. # noqa: E501 + + Set to 1 to prevent further changes to the permissions setting for write access # noqa: E501 + + :return: The canwrite_is_immutable of this EntityTemplateEditable. # noqa: E501 + :rtype: int + """ + return self._canwrite_is_immutable + + @canwrite_is_immutable.setter + def canwrite_is_immutable(self, canwrite_is_immutable): + """Sets the canwrite_is_immutable of this EntityTemplateEditable. + + Set to 1 to prevent further changes to the permissions setting for write access # noqa: E501 + + :param canwrite_is_immutable: The canwrite_is_immutable of this EntityTemplateEditable. # noqa: E501 + :type: int + """ + + self._canwrite_is_immutable = canwrite_is_immutable + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(EntityTemplateEditable, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, EntityTemplateEditable): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/error.py b/vendor/elabapi-python/elabapi_python/models/error.py new file mode 100644 index 0000000..1577787 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/error.py @@ -0,0 +1,165 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Error(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'code': 'str', + 'message': 'str', + 'description': 'str' + } + + attribute_map = { + 'code': 'code', + 'message': 'message', + 'description': 'description' + } + + def __init__(self, code=None, message=None, description=None): # noqa: E501 + """Error - a model defined in Swagger""" # noqa: E501 + self._code = None + self._message = None + self._description = None + self.discriminator = None + self.code = code + self.message = message + self.description = description + + @property + def code(self): + """Gets the code of this Error. # noqa: E501 + + + :return: The code of this Error. # noqa: E501 + :rtype: str + """ + return self._code + + @code.setter + def code(self, code): + """Sets the code of this Error. + + + :param code: The code of this Error. # noqa: E501 + :type: str + """ + if code is None: + raise ValueError("Invalid value for `code`, must not be `None`") # noqa: E501 + + self._code = code + + @property + def message(self): + """Gets the message of this Error. # noqa: E501 + + + :return: The message of this Error. # noqa: E501 + :rtype: str + """ + return self._message + + @message.setter + def message(self, message): + """Sets the message of this Error. + + + :param message: The message of this Error. # noqa: E501 + :type: str + """ + if message is None: + raise ValueError("Invalid value for `message`, must not be `None`") # noqa: E501 + + self._message = message + + @property + def description(self): + """Gets the description of this Error. # noqa: E501 + + + :return: The description of this Error. # noqa: E501 + :rtype: str + """ + return self._description + + @description.setter + def description(self, description): + """Sets the description of this Error. + + + :param description: The description of this Error. # noqa: E501 + :type: str + """ + if description is None: + raise ValueError("Invalid value for `description`, must not be `None`") # noqa: E501 + + self._description = description + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Error, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Error): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/event.py b/vendor/elabapi-python/elabapi_python/models/event.py new file mode 100644 index 0000000..15334b0 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/event.py @@ -0,0 +1,726 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Event(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'team': 'int', + 'team_name': 'str', + 'title': 'str', + 'title_only': 'str', + 'book_cancel_minutes': 'int', + 'book_is_cancellable': 'int', + 'canbook': 'int', + 'created_at': 'datetime', + 'modified_at': 'datetime', + 'start': 'datetime', + 'end': 'datetime', + 'event_duration_minutes': 'int', + 'userid': 'int', + 'fullname': 'str', + 'experiment': 'int', + 'experiment_title': 'str', + 'items_id': 'int', + 'item_title': 'str', + 'items_category': 'int', + 'items_category_title': 'str', + 'item_link': 'int', + 'item_link_title': 'str', + 'color': 'str' + } + + attribute_map = { + 'id': 'id', + 'team': 'team', + 'team_name': 'team_name', + 'title': 'title', + 'title_only': 'title_only', + 'book_cancel_minutes': 'book_cancel_minutes', + 'book_is_cancellable': 'book_is_cancellable', + 'canbook': 'canbook', + 'created_at': 'created_at', + 'modified_at': 'modified_at', + 'start': 'start', + 'end': 'end', + 'event_duration_minutes': 'event_duration_minutes', + 'userid': 'userid', + 'fullname': 'fullname', + 'experiment': 'experiment', + 'experiment_title': 'experiment_title', + 'items_id': 'items_id', + 'item_title': 'item_title', + 'items_category': 'items_category', + 'items_category_title': 'items_category_title', + 'item_link': 'item_link', + 'item_link_title': 'item_link_title', + 'color': 'color' + } + + def __init__(self, id=None, team=None, team_name=None, title=None, title_only=None, book_cancel_minutes=None, book_is_cancellable=None, canbook=None, created_at=None, modified_at=None, start=None, end=None, event_duration_minutes=None, userid=None, fullname=None, experiment=None, experiment_title=None, items_id=None, item_title=None, items_category=None, items_category_title=None, item_link=None, item_link_title=None, color=None): # noqa: E501 + """Event - a model defined in Swagger""" # noqa: E501 + self._id = None + self._team = None + self._team_name = None + self._title = None + self._title_only = None + self._book_cancel_minutes = None + self._book_is_cancellable = None + self._canbook = None + self._created_at = None + self._modified_at = None + self._start = None + self._end = None + self._event_duration_minutes = None + self._userid = None + self._fullname = None + self._experiment = None + self._experiment_title = None + self._items_id = None + self._item_title = None + self._items_category = None + self._items_category_title = None + self._item_link = None + self._item_link_title = None + self._color = None + self.discriminator = None + if id is not None: + self.id = id + if team is not None: + self.team = team + if team_name is not None: + self.team_name = team_name + if title is not None: + self.title = title + if title_only is not None: + self.title_only = title_only + if book_cancel_minutes is not None: + self.book_cancel_minutes = book_cancel_minutes + if book_is_cancellable is not None: + self.book_is_cancellable = book_is_cancellable + if canbook is not None: + self.canbook = canbook + if created_at is not None: + self.created_at = created_at + if modified_at is not None: + self.modified_at = modified_at + if start is not None: + self.start = start + if end is not None: + self.end = end + if event_duration_minutes is not None: + self.event_duration_minutes = event_duration_minutes + if userid is not None: + self.userid = userid + if fullname is not None: + self.fullname = fullname + if experiment is not None: + self.experiment = experiment + if experiment_title is not None: + self.experiment_title = experiment_title + if items_id is not None: + self.items_id = items_id + if item_title is not None: + self.item_title = item_title + if items_category is not None: + self.items_category = items_category + if items_category_title is not None: + self.items_category_title = items_category_title + if item_link is not None: + self.item_link = item_link + if item_link_title is not None: + self.item_link_title = item_link_title + if color is not None: + self.color = color + + @property + def id(self): + """Gets the id of this Event. # noqa: E501 + + + :return: The id of this Event. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this Event. + + + :param id: The id of this Event. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def team(self): + """Gets the team of this Event. # noqa: E501 + + + :return: The team of this Event. # noqa: E501 + :rtype: int + """ + return self._team + + @team.setter + def team(self, team): + """Sets the team of this Event. + + + :param team: The team of this Event. # noqa: E501 + :type: int + """ + + self._team = team + + @property + def team_name(self): + """Gets the team_name of this Event. # noqa: E501 + + + :return: The team_name of this Event. # noqa: E501 + :rtype: str + """ + return self._team_name + + @team_name.setter + def team_name(self, team_name): + """Sets the team_name of this Event. + + + :param team_name: The team_name of this Event. # noqa: E501 + :type: str + """ + + self._team_name = team_name + + @property + def title(self): + """Gets the title of this Event. # noqa: E501 + + Optional comment added to the event # noqa: E501 + + :return: The title of this Event. # noqa: E501 + :rtype: str + """ + return self._title + + @title.setter + def title(self, title): + """Sets the title of this Event. + + Optional comment added to the event # noqa: E501 + + :param title: The title of this Event. # noqa: E501 + :type: str + """ + + self._title = title + + @property + def title_only(self): + """Gets the title_only of this Event. # noqa: E501 + + Title of the event. # noqa: E501 + + :return: The title_only of this Event. # noqa: E501 + :rtype: str + """ + return self._title_only + + @title_only.setter + def title_only(self, title_only): + """Sets the title_only of this Event. + + Title of the event. # noqa: E501 + + :param title_only: The title_only of this Event. # noqa: E501 + :type: str + """ + + self._title_only = title_only + + @property + def book_cancel_minutes(self): + """Gets the book_cancel_minutes of this Event. # noqa: E501 + + Minutes before start when cancellation is allowed # noqa: E501 + + :return: The book_cancel_minutes of this Event. # noqa: E501 + :rtype: int + """ + return self._book_cancel_minutes + + @book_cancel_minutes.setter + def book_cancel_minutes(self, book_cancel_minutes): + """Sets the book_cancel_minutes of this Event. + + Minutes before start when cancellation is allowed # noqa: E501 + + :param book_cancel_minutes: The book_cancel_minutes of this Event. # noqa: E501 + :type: int + """ + + self._book_cancel_minutes = book_cancel_minutes + + @property + def book_is_cancellable(self): + """Gets the book_is_cancellable of this Event. # noqa: E501 + + Whether the booking can be cancelled (1 = yes, 0 = no) # noqa: E501 + + :return: The book_is_cancellable of this Event. # noqa: E501 + :rtype: int + """ + return self._book_is_cancellable + + @book_is_cancellable.setter + def book_is_cancellable(self, book_is_cancellable): + """Sets the book_is_cancellable of this Event. + + Whether the booking can be cancelled (1 = yes, 0 = no) # noqa: E501 + + :param book_is_cancellable: The book_is_cancellable of this Event. # noqa: E501 + :type: int + """ + + self._book_is_cancellable = book_is_cancellable + + @property + def canbook(self): + """Gets the canbook of this Event. # noqa: E501 + + Whether the event is bookable (1 = yes, 0 = no) # noqa: E501 + + :return: The canbook of this Event. # noqa: E501 + :rtype: int + """ + return self._canbook + + @canbook.setter + def canbook(self, canbook): + """Sets the canbook of this Event. + + Whether the event is bookable (1 = yes, 0 = no) # noqa: E501 + + :param canbook: The canbook of this Event. # noqa: E501 + :type: int + """ + + self._canbook = canbook + + @property + def created_at(self): + """Gets the created_at of this Event. # noqa: E501 + + + :return: The created_at of this Event. # noqa: E501 + :rtype: datetime + """ + return self._created_at + + @created_at.setter + def created_at(self, created_at): + """Sets the created_at of this Event. + + + :param created_at: The created_at of this Event. # noqa: E501 + :type: datetime + """ + + self._created_at = created_at + + @property + def modified_at(self): + """Gets the modified_at of this Event. # noqa: E501 + + + :return: The modified_at of this Event. # noqa: E501 + :rtype: datetime + """ + return self._modified_at + + @modified_at.setter + def modified_at(self, modified_at): + """Sets the modified_at of this Event. + + + :param modified_at: The modified_at of this Event. # noqa: E501 + :type: datetime + """ + + self._modified_at = modified_at + + @property + def start(self): + """Gets the start of this Event. # noqa: E501 + + + :return: The start of this Event. # noqa: E501 + :rtype: datetime + """ + return self._start + + @start.setter + def start(self, start): + """Sets the start of this Event. + + + :param start: The start of this Event. # noqa: E501 + :type: datetime + """ + + self._start = start + + @property + def end(self): + """Gets the end of this Event. # noqa: E501 + + + :return: The end of this Event. # noqa: E501 + :rtype: datetime + """ + return self._end + + @end.setter + def end(self, end): + """Sets the end of this Event. + + + :param end: The end of this Event. # noqa: E501 + :type: datetime + """ + + self._end = end + + @property + def event_duration_minutes(self): + """Gets the event_duration_minutes of this Event. # noqa: E501 + + + :return: The event_duration_minutes of this Event. # noqa: E501 + :rtype: int + """ + return self._event_duration_minutes + + @event_duration_minutes.setter + def event_duration_minutes(self, event_duration_minutes): + """Sets the event_duration_minutes of this Event. + + + :param event_duration_minutes: The event_duration_minutes of this Event. # noqa: E501 + :type: int + """ + + self._event_duration_minutes = event_duration_minutes + + @property + def userid(self): + """Gets the userid of this Event. # noqa: E501 + + + :return: The userid of this Event. # noqa: E501 + :rtype: int + """ + return self._userid + + @userid.setter + def userid(self, userid): + """Sets the userid of this Event. + + + :param userid: The userid of this Event. # noqa: E501 + :type: int + """ + + self._userid = userid + + @property + def fullname(self): + """Gets the fullname of this Event. # noqa: E501 + + Full name of the user who created the event. # noqa: E501 + + :return: The fullname of this Event. # noqa: E501 + :rtype: str + """ + return self._fullname + + @fullname.setter + def fullname(self, fullname): + """Sets the fullname of this Event. + + Full name of the user who created the event. # noqa: E501 + + :param fullname: The fullname of this Event. # noqa: E501 + :type: str + """ + + self._fullname = fullname + + @property + def experiment(self): + """Gets the experiment of this Event. # noqa: E501 + + + :return: The experiment of this Event. # noqa: E501 + :rtype: int + """ + return self._experiment + + @experiment.setter + def experiment(self, experiment): + """Sets the experiment of this Event. + + + :param experiment: The experiment of this Event. # noqa: E501 + :type: int + """ + + self._experiment = experiment + + @property + def experiment_title(self): + """Gets the experiment_title of this Event. # noqa: E501 + + The experiment that has been bound to the event. # noqa: E501 + + :return: The experiment_title of this Event. # noqa: E501 + :rtype: str + """ + return self._experiment_title + + @experiment_title.setter + def experiment_title(self, experiment_title): + """Sets the experiment_title of this Event. + + The experiment that has been bound to the event. # noqa: E501 + + :param experiment_title: The experiment_title of this Event. # noqa: E501 + :type: str + """ + + self._experiment_title = experiment_title + + @property + def items_id(self): + """Gets the items_id of this Event. # noqa: E501 + + ID of the Resource being booked # noqa: E501 + + :return: The items_id of this Event. # noqa: E501 + :rtype: int + """ + return self._items_id + + @items_id.setter + def items_id(self, items_id): + """Sets the items_id of this Event. + + ID of the Resource being booked # noqa: E501 + + :param items_id: The items_id of this Event. # noqa: E501 + :type: int + """ + + self._items_id = items_id + + @property + def item_title(self): + """Gets the item_title of this Event. # noqa: E501 + + + :return: The item_title of this Event. # noqa: E501 + :rtype: str + """ + return self._item_title + + @item_title.setter + def item_title(self, item_title): + """Sets the item_title of this Event. + + + :param item_title: The item_title of this Event. # noqa: E501 + :type: str + """ + + self._item_title = item_title + + @property + def items_category(self): + """Gets the items_category of this Event. # noqa: E501 + + + :return: The items_category of this Event. # noqa: E501 + :rtype: int + """ + return self._items_category + + @items_category.setter + def items_category(self, items_category): + """Sets the items_category of this Event. + + + :param items_category: The items_category of this Event. # noqa: E501 + :type: int + """ + + self._items_category = items_category + + @property + def items_category_title(self): + """Gets the items_category_title of this Event. # noqa: E501 + + + :return: The items_category_title of this Event. # noqa: E501 + :rtype: str + """ + return self._items_category_title + + @items_category_title.setter + def items_category_title(self, items_category_title): + """Sets the items_category_title of this Event. + + + :param items_category_title: The items_category_title of this Event. # noqa: E501 + :type: str + """ + + self._items_category_title = items_category_title + + @property + def item_link(self): + """Gets the item_link of this Event. # noqa: E501 + + + :return: The item_link of this Event. # noqa: E501 + :rtype: int + """ + return self._item_link + + @item_link.setter + def item_link(self, item_link): + """Sets the item_link of this Event. + + + :param item_link: The item_link of this Event. # noqa: E501 + :type: int + """ + + self._item_link = item_link + + @property + def item_link_title(self): + """Gets the item_link_title of this Event. # noqa: E501 + + The item that has been bound to the event. # noqa: E501 + + :return: The item_link_title of this Event. # noqa: E501 + :rtype: str + """ + return self._item_link_title + + @item_link_title.setter + def item_link_title(self, item_link_title): + """Sets the item_link_title of this Event. + + The item that has been bound to the event. # noqa: E501 + + :param item_link_title: The item_link_title of this Event. # noqa: E501 + :type: str + """ + + self._item_link_title = item_link_title + + @property + def color(self): + """Gets the color of this Event. # noqa: E501 + + + :return: The color of this Event. # noqa: E501 + :rtype: str + """ + return self._color + + @color.setter + def color(self, color): + """Sets the color of this Event. + + + :param color: The color of this Event. # noqa: E501 + :type: str + """ + + self._color = color + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Event, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Event): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/event_id_body.py b/vendor/elabapi-python/elabapi_python/models/event_id_body.py new file mode 100644 index 0000000..78d3bd6 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/event_id_body.py @@ -0,0 +1,84 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class EventIdBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + } + + attribute_map = { + } + + def __init__(self): # noqa: E501 + """EventIdBody - a model defined in Swagger""" # noqa: E501 + self.discriminator = None + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(EventIdBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, EventIdBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/eventid_delta.py b/vendor/elabapi-python/elabapi_python/models/eventid_delta.py new file mode 100644 index 0000000..28107e2 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/eventid_delta.py @@ -0,0 +1,188 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class EventidDelta(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'days': 'int', + 'milliseconds': 'int', + 'months': 'int', + 'years': 'int' + } + + attribute_map = { + 'days': 'days', + 'milliseconds': 'milliseconds', + 'months': 'months', + 'years': 'years' + } + + def __init__(self, days=None, milliseconds=None, months=None, years=None): # noqa: E501 + """EventidDelta - a model defined in Swagger""" # noqa: E501 + self._days = None + self._milliseconds = None + self._months = None + self._years = None + self.discriminator = None + if days is not None: + self.days = days + if milliseconds is not None: + self.milliseconds = milliseconds + if months is not None: + self.months = months + if years is not None: + self.years = years + + @property + def days(self): + """Gets the days of this EventidDelta. # noqa: E501 + + + :return: The days of this EventidDelta. # noqa: E501 + :rtype: int + """ + return self._days + + @days.setter + def days(self, days): + """Sets the days of this EventidDelta. + + + :param days: The days of this EventidDelta. # noqa: E501 + :type: int + """ + + self._days = days + + @property + def milliseconds(self): + """Gets the milliseconds of this EventidDelta. # noqa: E501 + + + :return: The milliseconds of this EventidDelta. # noqa: E501 + :rtype: int + """ + return self._milliseconds + + @milliseconds.setter + def milliseconds(self, milliseconds): + """Sets the milliseconds of this EventidDelta. + + + :param milliseconds: The milliseconds of this EventidDelta. # noqa: E501 + :type: int + """ + + self._milliseconds = milliseconds + + @property + def months(self): + """Gets the months of this EventidDelta. # noqa: E501 + + + :return: The months of this EventidDelta. # noqa: E501 + :rtype: int + """ + return self._months + + @months.setter + def months(self, months): + """Sets the months of this EventidDelta. + + + :param months: The months of this EventidDelta. # noqa: E501 + :type: int + """ + + self._months = months + + @property + def years(self): + """Gets the years of this EventidDelta. # noqa: E501 + + + :return: The years of this EventidDelta. # noqa: E501 + :rtype: int + """ + return self._years + + @years.setter + def years(self, years): + """Sets the years of this EventidDelta. + + + :param years: The years of this EventidDelta. # noqa: E501 + :type: int + """ + + self._years = years + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(EventidDelta, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, EventidDelta): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/events_id_body.py b/vendor/elabapi-python/elabapi_python/models/events_id_body.py new file mode 100644 index 0000000..8b34b0e --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/events_id_body.py @@ -0,0 +1,168 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class EventsIdBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'title': 'str', + 'start': 'datetime', + 'end': 'datetime' + } + + attribute_map = { + 'title': 'title', + 'start': 'start', + 'end': 'end' + } + + def __init__(self, title='Untitled', start=None, end=None): # noqa: E501 + """EventsIdBody - a model defined in Swagger""" # noqa: E501 + self._title = None + self._start = None + self._end = None + self.discriminator = None + if title is not None: + self.title = title + if start is not None: + self.start = start + if end is not None: + self.end = end + + @property + def title(self): + """Gets the title of this EventsIdBody. # noqa: E501 + + A name for this booking slot. # noqa: E501 + + :return: The title of this EventsIdBody. # noqa: E501 + :rtype: str + """ + return self._title + + @title.setter + def title(self, title): + """Sets the title of this EventsIdBody. + + A name for this booking slot. # noqa: E501 + + :param title: The title of this EventsIdBody. # noqa: E501 + :type: str + """ + + self._title = title + + @property + def start(self): + """Gets the start of this EventsIdBody. # noqa: E501 + + ISO 8601 date-time with timezone offset. # noqa: E501 + + :return: The start of this EventsIdBody. # noqa: E501 + :rtype: datetime + """ + return self._start + + @start.setter + def start(self, start): + """Sets the start of this EventsIdBody. + + ISO 8601 date-time with timezone offset. # noqa: E501 + + :param start: The start of this EventsIdBody. # noqa: E501 + :type: datetime + """ + + self._start = start + + @property + def end(self): + """Gets the end of this EventsIdBody. # noqa: E501 + + ISO 8601 date-time with timezone offset. # noqa: E501 + + :return: The end of this EventsIdBody. # noqa: E501 + :rtype: datetime + """ + return self._end + + @end.setter + def end(self, end): + """Sets the end of this EventsIdBody. + + ISO 8601 date-time with timezone offset. # noqa: E501 + + :param end: The end of this EventsIdBody. # noqa: E501 + :type: datetime + """ + + self._end = end + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(EventsIdBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, EventsIdBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/exclusive_edit_mode.py b/vendor/elabapi-python/elabapi_python/models/exclusive_edit_mode.py new file mode 100644 index 0000000..0bbacf7 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/exclusive_edit_mode.py @@ -0,0 +1,196 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class ExclusiveEditMode(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'locked_by': 'int', + 'locked_by_human': 'str', + 'locked_at': 'str', + 'is_stale': 'int' + } + + attribute_map = { + 'locked_by': 'locked_by', + 'locked_by_human': 'locked_by_human', + 'locked_at': 'locked_at', + 'is_stale': 'is_stale' + } + + def __init__(self, locked_by=None, locked_by_human=None, locked_at=None, is_stale=None): # noqa: E501 + """ExclusiveEditMode - a model defined in Swagger""" # noqa: E501 + self._locked_by = None + self._locked_by_human = None + self._locked_at = None + self._is_stale = None + self.discriminator = None + if locked_by is not None: + self.locked_by = locked_by + if locked_by_human is not None: + self.locked_by_human = locked_by_human + if locked_at is not None: + self.locked_at = locked_at + if is_stale is not None: + self.is_stale = is_stale + + @property + def locked_by(self): + """Gets the locked_by of this ExclusiveEditMode. # noqa: E501 + + Userid of the user having exclusive edition rights # noqa: E501 + + :return: The locked_by of this ExclusiveEditMode. # noqa: E501 + :rtype: int + """ + return self._locked_by + + @locked_by.setter + def locked_by(self, locked_by): + """Sets the locked_by of this ExclusiveEditMode. + + Userid of the user having exclusive edition rights # noqa: E501 + + :param locked_by: The locked_by of this ExclusiveEditMode. # noqa: E501 + :type: int + """ + + self._locked_by = locked_by + + @property + def locked_by_human(self): + """Gets the locked_by_human of this ExclusiveEditMode. # noqa: E501 + + Full name of the user having exclusive edition rights # noqa: E501 + + :return: The locked_by_human of this ExclusiveEditMode. # noqa: E501 + :rtype: str + """ + return self._locked_by_human + + @locked_by_human.setter + def locked_by_human(self, locked_by_human): + """Sets the locked_by_human of this ExclusiveEditMode. + + Full name of the user having exclusive edition rights # noqa: E501 + + :param locked_by_human: The locked_by_human of this ExclusiveEditMode. # noqa: E501 + :type: str + """ + + self._locked_by_human = locked_by_human + + @property + def locked_at(self): + """Gets the locked_at of this ExclusiveEditMode. # noqa: E501 + + Time when the exclusive edit mode was created # noqa: E501 + + :return: The locked_at of this ExclusiveEditMode. # noqa: E501 + :rtype: str + """ + return self._locked_at + + @locked_at.setter + def locked_at(self, locked_at): + """Sets the locked_at of this ExclusiveEditMode. + + Time when the exclusive edit mode was created # noqa: E501 + + :param locked_at: The locked_at of this ExclusiveEditMode. # noqa: E501 + :type: str + """ + + self._locked_at = locked_at + + @property + def is_stale(self): + """Gets the is_stale of this ExclusiveEditMode. # noqa: E501 + + Is 1 when the exclusive edit lock is longer than ExclusiveEditMode::EXPIRATION_MINUTES # noqa: E501 + + :return: The is_stale of this ExclusiveEditMode. # noqa: E501 + :rtype: int + """ + return self._is_stale + + @is_stale.setter + def is_stale(self, is_stale): + """Sets the is_stale of this ExclusiveEditMode. + + Is 1 when the exclusive edit lock is longer than ExclusiveEditMode::EXPIRATION_MINUTES # noqa: E501 + + :param is_stale: The is_stale of this ExclusiveEditMode. # noqa: E501 + :type: int + """ + + self._is_stale = is_stale + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(ExclusiveEditMode, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, ExclusiveEditMode): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/experiment.py b/vendor/elabapi-python/elabapi_python/models/experiment.py new file mode 100644 index 0000000..a3e5a22 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/experiment.py @@ -0,0 +1,90 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six +from elabapi_python.models.entity import Entity # noqa: F401,E501 + +class Experiment(Entity): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + } + if hasattr(Entity, "swagger_types"): + swagger_types.update(Entity.swagger_types) + + attribute_map = { + } + if hasattr(Entity, "attribute_map"): + attribute_map.update(Entity.attribute_map) + + def __init__(self, *args, **kwargs): # noqa: E501 + """Experiment - a model defined in Swagger""" # noqa: E501 + self.discriminator = None + Entity.__init__(self, *args, **kwargs) + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Experiment, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Experiment): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/experiments_links_subid_body.py b/vendor/elabapi-python/elabapi_python/models/experiments_links_subid_body.py new file mode 100644 index 0000000..003b9c0 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/experiments_links_subid_body.py @@ -0,0 +1,118 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class ExperimentsLinksSubidBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'action': 'str' + } + + attribute_map = { + 'action': 'action' + } + + def __init__(self, action=None): # noqa: E501 + """ExperimentsLinksSubidBody - a model defined in Swagger""" # noqa: E501 + self._action = None + self.discriminator = None + if action is not None: + self.action = action + + @property + def action(self): + """Gets the action of this ExperimentsLinksSubidBody. # noqa: E501 + + The `duplicate` action will import the links of that link (inception). # noqa: E501 + + :return: The action of this ExperimentsLinksSubidBody. # noqa: E501 + :rtype: str + """ + return self._action + + @action.setter + def action(self, action): + """Sets the action of this ExperimentsLinksSubidBody. + + The `duplicate` action will import the links of that link (inception). # noqa: E501 + + :param action: The action of this ExperimentsLinksSubidBody. # noqa: E501 + :type: str + """ + allowed_values = ["create", "duplicate"] # noqa: E501 + if action not in allowed_values: + raise ValueError( + "Invalid value for `action` ({0}), must be one of {1}" # noqa: E501 + .format(action, allowed_values) + ) + + self._action = action + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(ExperimentsLinksSubidBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, ExperimentsLinksSubidBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/experiments_templates_id_body.py b/vendor/elabapi-python/elabapi_python/models/experiments_templates_id_body.py new file mode 100644 index 0000000..065891a --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/experiments_templates_id_body.py @@ -0,0 +1,84 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class ExperimentsTemplatesIdBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + } + + attribute_map = { + } + + def __init__(self): # noqa: E501 + """ExperimentsTemplatesIdBody - a model defined in Swagger""" # noqa: E501 + self.discriminator = None + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(ExperimentsTemplatesIdBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, ExperimentsTemplatesIdBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/export.py b/vendor/elabapi-python/elabapi_python/models/export.py new file mode 100644 index 0000000..0cca48b --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/export.py @@ -0,0 +1,578 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Export(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'created_at': 'str', + 'requester_userid': 'int', + 'state': 'int', + 'long_name': 'str', + 'filesize': 'int', + 'modified_at': 'str', + 'real_name': 'str', + 'team': 'int', + 'changelog': 'int', + 'pdfa': 'int', + 'json': 'int', + 'hash': 'str', + 'hash_algo': 'str', + 'experiments': 'int', + 'items': 'int', + 'experiments_templates': 'int', + 'items_types': 'int', + 'format': 'str' + } + + attribute_map = { + 'id': 'id', + 'created_at': 'created_at', + 'requester_userid': 'requester_userid', + 'state': 'state', + 'long_name': 'long_name', + 'filesize': 'filesize', + 'modified_at': 'modified_at', + 'real_name': 'real_name', + 'team': 'team', + 'changelog': 'changelog', + 'pdfa': 'pdfa', + 'json': 'json', + 'hash': 'hash', + 'hash_algo': 'hash_algo', + 'experiments': 'experiments', + 'items': 'items', + 'experiments_templates': 'experiments_templates', + 'items_types': 'items_types', + 'format': 'format' + } + + def __init__(self, id=None, created_at=None, requester_userid=None, state=None, long_name=None, filesize=None, modified_at=None, real_name=None, team=None, changelog=None, pdfa=None, json=None, hash=None, hash_algo=None, experiments=None, items=None, experiments_templates=None, items_types=None, format=None): # noqa: E501 + """Export - a model defined in Swagger""" # noqa: E501 + self._id = None + self._created_at = None + self._requester_userid = None + self._state = None + self._long_name = None + self._filesize = None + self._modified_at = None + self._real_name = None + self._team = None + self._changelog = None + self._pdfa = None + self._json = None + self._hash = None + self._hash_algo = None + self._experiments = None + self._items = None + self._experiments_templates = None + self._items_types = None + self._format = None + self.discriminator = None + if id is not None: + self.id = id + if created_at is not None: + self.created_at = created_at + if requester_userid is not None: + self.requester_userid = requester_userid + if state is not None: + self.state = state + if long_name is not None: + self.long_name = long_name + if filesize is not None: + self.filesize = filesize + if modified_at is not None: + self.modified_at = modified_at + if real_name is not None: + self.real_name = real_name + if team is not None: + self.team = team + if changelog is not None: + self.changelog = changelog + if pdfa is not None: + self.pdfa = pdfa + if json is not None: + self.json = json + if hash is not None: + self.hash = hash + if hash_algo is not None: + self.hash_algo = hash_algo + if experiments is not None: + self.experiments = experiments + if items is not None: + self.items = items + if experiments_templates is not None: + self.experiments_templates = experiments_templates + if items_types is not None: + self.items_types = items_types + if format is not None: + self.format = format + + @property + def id(self): + """Gets the id of this Export. # noqa: E501 + + + :return: The id of this Export. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this Export. + + + :param id: The id of this Export. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def created_at(self): + """Gets the created_at of this Export. # noqa: E501 + + + :return: The created_at of this Export. # noqa: E501 + :rtype: str + """ + return self._created_at + + @created_at.setter + def created_at(self, created_at): + """Sets the created_at of this Export. + + + :param created_at: The created_at of this Export. # noqa: E501 + :type: str + """ + + self._created_at = created_at + + @property + def requester_userid(self): + """Gets the requester_userid of this Export. # noqa: E501 + + + :return: The requester_userid of this Export. # noqa: E501 + :rtype: int + """ + return self._requester_userid + + @requester_userid.setter + def requester_userid(self, requester_userid): + """Sets the requester_userid of this Export. + + + :param requester_userid: The requester_userid of this Export. # noqa: E501 + :type: int + """ + + self._requester_userid = requester_userid + + @property + def state(self): + """Gets the state of this Export. # noqa: E501 + + + :return: The state of this Export. # noqa: E501 + :rtype: int + """ + return self._state + + @state.setter + def state(self, state): + """Sets the state of this Export. + + + :param state: The state of this Export. # noqa: E501 + :type: int + """ + + self._state = state + + @property + def long_name(self): + """Gets the long_name of this Export. # noqa: E501 + + + :return: The long_name of this Export. # noqa: E501 + :rtype: str + """ + return self._long_name + + @long_name.setter + def long_name(self, long_name): + """Sets the long_name of this Export. + + + :param long_name: The long_name of this Export. # noqa: E501 + :type: str + """ + + self._long_name = long_name + + @property + def filesize(self): + """Gets the filesize of this Export. # noqa: E501 + + + :return: The filesize of this Export. # noqa: E501 + :rtype: int + """ + return self._filesize + + @filesize.setter + def filesize(self, filesize): + """Sets the filesize of this Export. + + + :param filesize: The filesize of this Export. # noqa: E501 + :type: int + """ + + self._filesize = filesize + + @property + def modified_at(self): + """Gets the modified_at of this Export. # noqa: E501 + + + :return: The modified_at of this Export. # noqa: E501 + :rtype: str + """ + return self._modified_at + + @modified_at.setter + def modified_at(self, modified_at): + """Sets the modified_at of this Export. + + + :param modified_at: The modified_at of this Export. # noqa: E501 + :type: str + """ + + self._modified_at = modified_at + + @property + def real_name(self): + """Gets the real_name of this Export. # noqa: E501 + + + :return: The real_name of this Export. # noqa: E501 + :rtype: str + """ + return self._real_name + + @real_name.setter + def real_name(self, real_name): + """Sets the real_name of this Export. + + + :param real_name: The real_name of this Export. # noqa: E501 + :type: str + """ + + self._real_name = real_name + + @property + def team(self): + """Gets the team of this Export. # noqa: E501 + + + :return: The team of this Export. # noqa: E501 + :rtype: int + """ + return self._team + + @team.setter + def team(self, team): + """Sets the team of this Export. + + + :param team: The team of this Export. # noqa: E501 + :type: int + """ + + self._team = team + + @property + def changelog(self): + """Gets the changelog of this Export. # noqa: E501 + + + :return: The changelog of this Export. # noqa: E501 + :rtype: int + """ + return self._changelog + + @changelog.setter + def changelog(self, changelog): + """Sets the changelog of this Export. + + + :param changelog: The changelog of this Export. # noqa: E501 + :type: int + """ + + self._changelog = changelog + + @property + def pdfa(self): + """Gets the pdfa of this Export. # noqa: E501 + + + :return: The pdfa of this Export. # noqa: E501 + :rtype: int + """ + return self._pdfa + + @pdfa.setter + def pdfa(self, pdfa): + """Sets the pdfa of this Export. + + + :param pdfa: The pdfa of this Export. # noqa: E501 + :type: int + """ + + self._pdfa = pdfa + + @property + def json(self): + """Gets the json of this Export. # noqa: E501 + + + :return: The json of this Export. # noqa: E501 + :rtype: int + """ + return self._json + + @json.setter + def json(self, json): + """Sets the json of this Export. + + + :param json: The json of this Export. # noqa: E501 + :type: int + """ + + self._json = json + + @property + def hash(self): + """Gets the hash of this Export. # noqa: E501 + + + :return: The hash of this Export. # noqa: E501 + :rtype: str + """ + return self._hash + + @hash.setter + def hash(self, hash): + """Sets the hash of this Export. + + + :param hash: The hash of this Export. # noqa: E501 + :type: str + """ + + self._hash = hash + + @property + def hash_algo(self): + """Gets the hash_algo of this Export. # noqa: E501 + + + :return: The hash_algo of this Export. # noqa: E501 + :rtype: str + """ + return self._hash_algo + + @hash_algo.setter + def hash_algo(self, hash_algo): + """Sets the hash_algo of this Export. + + + :param hash_algo: The hash_algo of this Export. # noqa: E501 + :type: str + """ + + self._hash_algo = hash_algo + + @property + def experiments(self): + """Gets the experiments of this Export. # noqa: E501 + + + :return: The experiments of this Export. # noqa: E501 + :rtype: int + """ + return self._experiments + + @experiments.setter + def experiments(self, experiments): + """Sets the experiments of this Export. + + + :param experiments: The experiments of this Export. # noqa: E501 + :type: int + """ + + self._experiments = experiments + + @property + def items(self): + """Gets the items of this Export. # noqa: E501 + + + :return: The items of this Export. # noqa: E501 + :rtype: int + """ + return self._items + + @items.setter + def items(self, items): + """Sets the items of this Export. + + + :param items: The items of this Export. # noqa: E501 + :type: int + """ + + self._items = items + + @property + def experiments_templates(self): + """Gets the experiments_templates of this Export. # noqa: E501 + + + :return: The experiments_templates of this Export. # noqa: E501 + :rtype: int + """ + return self._experiments_templates + + @experiments_templates.setter + def experiments_templates(self, experiments_templates): + """Sets the experiments_templates of this Export. + + + :param experiments_templates: The experiments_templates of this Export. # noqa: E501 + :type: int + """ + + self._experiments_templates = experiments_templates + + @property + def items_types(self): + """Gets the items_types of this Export. # noqa: E501 + + + :return: The items_types of this Export. # noqa: E501 + :rtype: int + """ + return self._items_types + + @items_types.setter + def items_types(self, items_types): + """Sets the items_types of this Export. + + + :param items_types: The items_types of this Export. # noqa: E501 + :type: int + """ + + self._items_types = items_types + + @property + def format(self): + """Gets the format of this Export. # noqa: E501 + + + :return: The format of this Export. # noqa: E501 + :rtype: str + """ + return self._format + + @format.setter + def format(self, format): + """Sets the format of this Export. + + + :param format: The format of this Export. # noqa: E501 + :type: str + """ + + self._format = format + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Export, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Export): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/exports_body.py b/vendor/elabapi-python/elabapi_python/models/exports_body.py new file mode 100644 index 0000000..92e87d0 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/exports_body.py @@ -0,0 +1,315 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class ExportsBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'format': 'str', + 'experiments': 'str', + 'items': 'str', + 'experiments_templates': 'str', + 'items_types': 'str', + 'changelog': 'str', + 'json': 'str', + 'pdfa': 'str' + } + + attribute_map = { + 'format': 'format', + 'experiments': 'experiments', + 'items': 'items', + 'experiments_templates': 'experiments_templates', + 'items_types': 'items_types', + 'changelog': 'changelog', + 'json': 'json', + 'pdfa': 'pdfa' + } + + def __init__(self, format=None, experiments=None, items=None, experiments_templates=None, items_types=None, changelog=None, json=None, pdfa=None): # noqa: E501 + """ExportsBody - a model defined in Swagger""" # noqa: E501 + self._format = None + self._experiments = None + self._items = None + self._experiments_templates = None + self._items_types = None + self._changelog = None + self._json = None + self._pdfa = None + self.discriminator = None + self.format = format + if experiments is not None: + self.experiments = experiments + if items is not None: + self.items = items + if experiments_templates is not None: + self.experiments_templates = experiments_templates + if items_types is not None: + self.items_types = items_types + if changelog is not None: + self.changelog = changelog + if json is not None: + self.json = json + if pdfa is not None: + self.pdfa = pdfa + + @property + def format(self): + """Gets the format of this ExportsBody. # noqa: E501 + + File format for the export # noqa: E501 + + :return: The format of this ExportsBody. # noqa: E501 + :rtype: str + """ + return self._format + + @format.setter + def format(self, format): + """Sets the format of this ExportsBody. + + File format for the export # noqa: E501 + + :param format: The format of this ExportsBody. # noqa: E501 + :type: str + """ + if format is None: + raise ValueError("Invalid value for `format`, must not be `None`") # noqa: E501 + allowed_values = ["csv", "eln", "json", "pdf", "zip"] # noqa: E501 + if format not in allowed_values: + raise ValueError( + "Invalid value for `format` ({0}), must be one of {1}" # noqa: E501 + .format(format, allowed_values) + ) + + self._format = format + + @property + def experiments(self): + """Gets the experiments of this ExportsBody. # noqa: E501 + + Set to \"on\" to include experiments in the export # noqa: E501 + + :return: The experiments of this ExportsBody. # noqa: E501 + :rtype: str + """ + return self._experiments + + @experiments.setter + def experiments(self, experiments): + """Sets the experiments of this ExportsBody. + + Set to \"on\" to include experiments in the export # noqa: E501 + + :param experiments: The experiments of this ExportsBody. # noqa: E501 + :type: str + """ + + self._experiments = experiments + + @property + def items(self): + """Gets the items of this ExportsBody. # noqa: E501 + + Set to \"on\" to include resources in the export # noqa: E501 + + :return: The items of this ExportsBody. # noqa: E501 + :rtype: str + """ + return self._items + + @items.setter + def items(self, items): + """Sets the items of this ExportsBody. + + Set to \"on\" to include resources in the export # noqa: E501 + + :param items: The items of this ExportsBody. # noqa: E501 + :type: str + """ + + self._items = items + + @property + def experiments_templates(self): + """Gets the experiments_templates of this ExportsBody. # noqa: E501 + + Set to \"on\" to include experiments templates in the export # noqa: E501 + + :return: The experiments_templates of this ExportsBody. # noqa: E501 + :rtype: str + """ + return self._experiments_templates + + @experiments_templates.setter + def experiments_templates(self, experiments_templates): + """Sets the experiments_templates of this ExportsBody. + + Set to \"on\" to include experiments templates in the export # noqa: E501 + + :param experiments_templates: The experiments_templates of this ExportsBody. # noqa: E501 + :type: str + """ + + self._experiments_templates = experiments_templates + + @property + def items_types(self): + """Gets the items_types of this ExportsBody. # noqa: E501 + + Set to \"on\" to include resources categories in the export # noqa: E501 + + :return: The items_types of this ExportsBody. # noqa: E501 + :rtype: str + """ + return self._items_types + + @items_types.setter + def items_types(self, items_types): + """Sets the items_types of this ExportsBody. + + Set to \"on\" to include resources categories in the export # noqa: E501 + + :param items_types: The items_types of this ExportsBody. # noqa: E501 + :type: str + """ + + self._items_types = items_types + + @property + def changelog(self): + """Gets the changelog of this ExportsBody. # noqa: E501 + + Set to \"on\" to include the changelog in PDF files # noqa: E501 + + :return: The changelog of this ExportsBody. # noqa: E501 + :rtype: str + """ + return self._changelog + + @changelog.setter + def changelog(self, changelog): + """Sets the changelog of this ExportsBody. + + Set to \"on\" to include the changelog in PDF files # noqa: E501 + + :param changelog: The changelog of this ExportsBody. # noqa: E501 + :type: str + """ + + self._changelog = changelog + + @property + def json(self): + """Gets the json of this ExportsBody. # noqa: E501 + + Set to \"on\" to include a full JSON export in the ZIP archives # noqa: E501 + + :return: The json of this ExportsBody. # noqa: E501 + :rtype: str + """ + return self._json + + @json.setter + def json(self, json): + """Sets the json of this ExportsBody. + + Set to \"on\" to include a full JSON export in the ZIP archives # noqa: E501 + + :param json: The json of this ExportsBody. # noqa: E501 + :type: str + """ + + self._json = json + + @property + def pdfa(self): + """Gets the pdfa of this ExportsBody. # noqa: E501 + + Set to \"on\" to create PDF files with the PDF/A specification # noqa: E501 + + :return: The pdfa of this ExportsBody. # noqa: E501 + :rtype: str + """ + return self._pdfa + + @pdfa.setter + def pdfa(self, pdfa): + """Sets the pdfa of this ExportsBody. + + Set to \"on\" to create PDF files with the PDF/A specification # noqa: E501 + + :param pdfa: The pdfa of this ExportsBody. # noqa: E501 + :type: str + """ + + self._pdfa = pdfa + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(ExportsBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, ExportsBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/extra_fields_keys.py b/vendor/elabapi-python/elabapi_python/models/extra_fields_keys.py new file mode 100644 index 0000000..2593167 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/extra_fields_keys.py @@ -0,0 +1,136 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class ExtraFieldsKeys(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'extra_fields_key': 'str', + 'frequency': 'int' + } + + attribute_map = { + 'extra_fields_key': 'extra_fields_key', + 'frequency': 'frequency' + } + + def __init__(self, extra_fields_key=None, frequency=None): # noqa: E501 + """ExtraFieldsKeys - a model defined in Swagger""" # noqa: E501 + self._extra_fields_key = None + self._frequency = None + self.discriminator = None + if extra_fields_key is not None: + self.extra_fields_key = extra_fields_key + if frequency is not None: + self.frequency = frequency + + @property + def extra_fields_key(self): + """Gets the extra_fields_key of this ExtraFieldsKeys. # noqa: E501 + + + :return: The extra_fields_key of this ExtraFieldsKeys. # noqa: E501 + :rtype: str + """ + return self._extra_fields_key + + @extra_fields_key.setter + def extra_fields_key(self, extra_fields_key): + """Sets the extra_fields_key of this ExtraFieldsKeys. + + + :param extra_fields_key: The extra_fields_key of this ExtraFieldsKeys. # noqa: E501 + :type: str + """ + + self._extra_fields_key = extra_fields_key + + @property + def frequency(self): + """Gets the frequency of this ExtraFieldsKeys. # noqa: E501 + + + :return: The frequency of this ExtraFieldsKeys. # noqa: E501 + :rtype: int + """ + return self._frequency + + @frequency.setter + def frequency(self, frequency): + """Sets the frequency of this ExtraFieldsKeys. + + + :param frequency: The frequency of this ExtraFieldsKeys. # noqa: E501 + :type: int + """ + + self._frequency = frequency + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(ExtraFieldsKeys, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, ExtraFieldsKeys): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/favtags_body.py b/vendor/elabapi-python/elabapi_python/models/favtags_body.py new file mode 100644 index 0000000..cbfc2a4 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/favtags_body.py @@ -0,0 +1,112 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class FavtagsBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'tag': 'str' + } + + attribute_map = { + 'tag': 'tag' + } + + def __init__(self, tag=None): # noqa: E501 + """FavtagsBody - a model defined in Swagger""" # noqa: E501 + self._tag = None + self.discriminator = None + if tag is not None: + self.tag = tag + + @property + def tag(self): + """Gets the tag of this FavtagsBody. # noqa: E501 + + An existing tag # noqa: E501 + + :return: The tag of this FavtagsBody. # noqa: E501 + :rtype: str + """ + return self._tag + + @tag.setter + def tag(self, tag): + """Sets the tag of this FavtagsBody. + + An existing tag # noqa: E501 + + :param tag: The tag of this FavtagsBody. # noqa: E501 + :type: str + """ + + self._tag = tag + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(FavtagsBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, FavtagsBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/id.py b/vendor/elabapi-python/elabapi_python/models/id.py new file mode 100644 index 0000000..472643d --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/id.py @@ -0,0 +1,84 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Id(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + } + + attribute_map = { + } + + def __init__(self): # noqa: E501 + """Id - a model defined in Swagger""" # noqa: E501 + self.discriminator = None + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Id, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Id): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/id1.py b/vendor/elabapi-python/elabapi_python/models/id1.py new file mode 100644 index 0000000..4cbc564 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/id1.py @@ -0,0 +1,84 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Id1(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + } + + attribute_map = { + } + + def __init__(self): # noqa: E501 + """Id1 - a model defined in Swagger""" # noqa: E501 + self.discriminator = None + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Id1, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Id1): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/id2.py b/vendor/elabapi-python/elabapi_python/models/id2.py new file mode 100644 index 0000000..8646dea --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/id2.py @@ -0,0 +1,84 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Id2(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + } + + attribute_map = { + } + + def __init__(self): # noqa: E501 + """Id2 - a model defined in Swagger""" # noqa: E501 + self.discriminator = None + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Id2, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Id2): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/id3.py b/vendor/elabapi-python/elabapi_python/models/id3.py new file mode 100644 index 0000000..527c86e --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/id3.py @@ -0,0 +1,84 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Id3(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + } + + attribute_map = { + } + + def __init__(self): # noqa: E501 + """Id3 - a model defined in Swagger""" # noqa: E501 + self.discriminator = None + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Id3, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Id3): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/id4.py b/vendor/elabapi-python/elabapi_python/models/id4.py new file mode 100644 index 0000000..8b465b2 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/id4.py @@ -0,0 +1,84 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Id4(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + } + + attribute_map = { + } + + def __init__(self): # noqa: E501 + """Id4 - a model defined in Swagger""" # noqa: E501 + self.discriminator = None + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Id4, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Id4): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/id_certs_body.py b/vendor/elabapi-python/elabapi_python/models/id_certs_body.py new file mode 100644 index 0000000..cfe92b1 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/id_certs_body.py @@ -0,0 +1,147 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class IdCertsBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'x509': 'str', + 'purpose': 'int' + } + + attribute_map = { + 'x509': 'x509', + 'purpose': 'purpose' + } + + def __init__(self, x509=None, purpose=None): # noqa: E501 + """IdCertsBody - a model defined in Swagger""" # noqa: E501 + self._x509 = None + self._purpose = None + self.discriminator = None + self.x509 = x509 + if purpose is not None: + self.purpose = purpose + + @property + def x509(self): + """Gets the x509 of this IdCertsBody. # noqa: E501 + + PEM representation of the certificate # noqa: E501 + + :return: The x509 of this IdCertsBody. # noqa: E501 + :rtype: str + """ + return self._x509 + + @x509.setter + def x509(self, x509): + """Sets the x509 of this IdCertsBody. + + PEM representation of the certificate # noqa: E501 + + :param x509: The x509 of this IdCertsBody. # noqa: E501 + :type: str + """ + if x509 is None: + raise ValueError("Invalid value for `x509`, must not be `None`") # noqa: E501 + + self._x509 = x509 + + @property + def purpose(self): + """Gets the purpose of this IdCertsBody. # noqa: E501 + + Purpose for this cert: `0` for Signing, `1` for Encryption. # noqa: E501 + + :return: The purpose of this IdCertsBody. # noqa: E501 + :rtype: int + """ + return self._purpose + + @purpose.setter + def purpose(self, purpose): + """Sets the purpose of this IdCertsBody. + + Purpose for this cert: `0` for Signing, `1` for Encryption. # noqa: E501 + + :param purpose: The purpose of this IdCertsBody. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if purpose not in allowed_values: + raise ValueError( + "Invalid value for `purpose` ({0}), must be one of {1}" # noqa: E501 + .format(purpose, allowed_values) + ) + + self._purpose = purpose + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(IdCertsBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, IdCertsBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/id_comments_body.py b/vendor/elabapi-python/elabapi_python/models/id_comments_body.py new file mode 100644 index 0000000..750b52f --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/id_comments_body.py @@ -0,0 +1,111 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class IdCommentsBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'comment': 'str' + } + + attribute_map = { + 'comment': 'comment' + } + + def __init__(self, comment=None): # noqa: E501 + """IdCommentsBody - a model defined in Swagger""" # noqa: E501 + self._comment = None + self.discriminator = None + self.comment = comment + + @property + def comment(self): + """Gets the comment of this IdCommentsBody. # noqa: E501 + + + :return: The comment of this IdCommentsBody. # noqa: E501 + :rtype: str + """ + return self._comment + + @comment.setter + def comment(self, comment): + """Sets the comment of this IdCommentsBody. + + + :param comment: The comment of this IdCommentsBody. # noqa: E501 + :type: str + """ + if comment is None: + raise ValueError("Invalid value for `comment`, must not be `None`") # noqa: E501 + + self._comment = comment + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(IdCommentsBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, IdCommentsBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/id_endpoints_body.py b/vendor/elabapi-python/elabapi_python/models/id_endpoints_body.py new file mode 100644 index 0000000..7a7e077 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/id_endpoints_body.py @@ -0,0 +1,175 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class IdEndpointsBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'location': 'str', + 'binding': 'str', + 'is_slo': 'int' + } + + attribute_map = { + 'location': 'location', + 'binding': 'binding', + 'is_slo': 'is_slo' + } + + def __init__(self, location=None, binding=None, is_slo=None): # noqa: E501 + """IdEndpointsBody - a model defined in Swagger""" # noqa: E501 + self._location = None + self._binding = None + self._is_slo = None + self.discriminator = None + self.location = location + if binding is not None: + self.binding = binding + if is_slo is not None: + self.is_slo = is_slo + + @property + def location(self): + """Gets the location of this IdEndpointsBody. # noqa: E501 + + + :return: The location of this IdEndpointsBody. # noqa: E501 + :rtype: str + """ + return self._location + + @location.setter + def location(self, location): + """Sets the location of this IdEndpointsBody. + + + :param location: The location of this IdEndpointsBody. # noqa: E501 + :type: str + """ + if location is None: + raise ValueError("Invalid value for `location`, must not be `None`") # noqa: E501 + + self._location = location + + @property + def binding(self): + """Gets the binding of this IdEndpointsBody. # noqa: E501 + + + :return: The binding of this IdEndpointsBody. # noqa: E501 + :rtype: str + """ + return self._binding + + @binding.setter + def binding(self, binding): + """Sets the binding of this IdEndpointsBody. + + + :param binding: The binding of this IdEndpointsBody. # noqa: E501 + :type: str + """ + allowed_values = ["urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST", "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-Redirect"] # noqa: E501 + if binding not in allowed_values: + raise ValueError( + "Invalid value for `binding` ({0}), must be one of {1}" # noqa: E501 + .format(binding, allowed_values) + ) + + self._binding = binding + + @property + def is_slo(self): + """Gets the is_slo of this IdEndpointsBody. # noqa: E501 + + + :return: The is_slo of this IdEndpointsBody. # noqa: E501 + :rtype: int + """ + return self._is_slo + + @is_slo.setter + def is_slo(self, is_slo): + """Sets the is_slo of this IdEndpointsBody. + + + :param is_slo: The is_slo of this IdEndpointsBody. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_slo not in allowed_values: + raise ValueError( + "Invalid value for `is_slo` ({0}), must be one of {1}" # noqa: E501 + .format(is_slo, allowed_values) + ) + + self._is_slo = is_slo + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(IdEndpointsBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, IdEndpointsBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/id_experiments_categories_body.py b/vendor/elabapi-python/elabapi_python/models/id_experiments_categories_body.py new file mode 100644 index 0000000..1ce13ee --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/id_experiments_categories_body.py @@ -0,0 +1,140 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class IdExperimentsCategoriesBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'name': 'str', + 'color': 'str' + } + + attribute_map = { + 'name': 'name', + 'color': 'color' + } + + def __init__(self, name=None, color=None): # noqa: E501 + """IdExperimentsCategoriesBody - a model defined in Swagger""" # noqa: E501 + self._name = None + self._color = None + self.discriminator = None + if name is not None: + self.name = name + if color is not None: + self.color = color + + @property + def name(self): + """Gets the name of this IdExperimentsCategoriesBody. # noqa: E501 + + Category name # noqa: E501 + + :return: The name of this IdExperimentsCategoriesBody. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this IdExperimentsCategoriesBody. + + Category name # noqa: E501 + + :param name: The name of this IdExperimentsCategoriesBody. # noqa: E501 + :type: str + """ + + self._name = name + + @property + def color(self): + """Gets the color of this IdExperimentsCategoriesBody. # noqa: E501 + + Hex color without leading \\#. # noqa: E501 + + :return: The color of this IdExperimentsCategoriesBody. # noqa: E501 + :rtype: str + """ + return self._color + + @color.setter + def color(self, color): + """Sets the color of this IdExperimentsCategoriesBody. + + Hex color without leading \\#. # noqa: E501 + + :param color: The color of this IdExperimentsCategoriesBody. # noqa: E501 + :type: str + """ + + self._color = color + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(IdExperimentsCategoriesBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, IdExperimentsCategoriesBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/id_experiments_status_body.py b/vendor/elabapi-python/elabapi_python/models/id_experiments_status_body.py new file mode 100644 index 0000000..cba5f39 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/id_experiments_status_body.py @@ -0,0 +1,140 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class IdExperimentsStatusBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'name': 'str', + 'color': 'str' + } + + attribute_map = { + 'name': 'name', + 'color': 'color' + } + + def __init__(self, name=None, color=None): # noqa: E501 + """IdExperimentsStatusBody - a model defined in Swagger""" # noqa: E501 + self._name = None + self._color = None + self.discriminator = None + if name is not None: + self.name = name + if color is not None: + self.color = color + + @property + def name(self): + """Gets the name of this IdExperimentsStatusBody. # noqa: E501 + + Status name # noqa: E501 + + :return: The name of this IdExperimentsStatusBody. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this IdExperimentsStatusBody. + + Status name # noqa: E501 + + :param name: The name of this IdExperimentsStatusBody. # noqa: E501 + :type: str + """ + + self._name = name + + @property + def color(self): + """Gets the color of this IdExperimentsStatusBody. # noqa: E501 + + Hex color without leading \\#. # noqa: E501 + + :return: The color of this IdExperimentsStatusBody. # noqa: E501 + :rtype: str + """ + return self._color + + @color.setter + def color(self, color): + """Sets the color of this IdExperimentsStatusBody. + + Hex color without leading \\#. # noqa: E501 + + :param color: The color of this IdExperimentsStatusBody. # noqa: E501 + :type: str + """ + + self._color = color + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(IdExperimentsStatusBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, IdExperimentsStatusBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/id_items_status_body.py b/vendor/elabapi-python/elabapi_python/models/id_items_status_body.py new file mode 100644 index 0000000..11744f0 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/id_items_status_body.py @@ -0,0 +1,140 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class IdItemsStatusBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'name': 'str', + 'color': 'str' + } + + attribute_map = { + 'name': 'name', + 'color': 'color' + } + + def __init__(self, name=None, color=None): # noqa: E501 + """IdItemsStatusBody - a model defined in Swagger""" # noqa: E501 + self._name = None + self._color = None + self.discriminator = None + if name is not None: + self.name = name + if color is not None: + self.color = color + + @property + def name(self): + """Gets the name of this IdItemsStatusBody. # noqa: E501 + + Status name # noqa: E501 + + :return: The name of this IdItemsStatusBody. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this IdItemsStatusBody. + + Status name # noqa: E501 + + :param name: The name of this IdItemsStatusBody. # noqa: E501 + :type: str + """ + + self._name = name + + @property + def color(self): + """Gets the color of this IdItemsStatusBody. # noqa: E501 + + Hex color without leading \\#. # noqa: E501 + + :return: The color of this IdItemsStatusBody. # noqa: E501 + :rtype: str + """ + return self._color + + @color.setter + def color(self, color): + """Sets the color of this IdItemsStatusBody. + + Hex color without leading \\#. # noqa: E501 + + :param color: The color of this IdItemsStatusBody. # noqa: E501 + :type: str + """ + + self._color = color + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(IdItemsStatusBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, IdItemsStatusBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/id_resources_categories_body.py b/vendor/elabapi-python/elabapi_python/models/id_resources_categories_body.py new file mode 100644 index 0000000..3153f71 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/id_resources_categories_body.py @@ -0,0 +1,140 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class IdResourcesCategoriesBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'name': 'str', + 'color': 'str' + } + + attribute_map = { + 'name': 'name', + 'color': 'color' + } + + def __init__(self, name=None, color=None): # noqa: E501 + """IdResourcesCategoriesBody - a model defined in Swagger""" # noqa: E501 + self._name = None + self._color = None + self.discriminator = None + if name is not None: + self.name = name + if color is not None: + self.color = color + + @property + def name(self): + """Gets the name of this IdResourcesCategoriesBody. # noqa: E501 + + Category name # noqa: E501 + + :return: The name of this IdResourcesCategoriesBody. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this IdResourcesCategoriesBody. + + Category name # noqa: E501 + + :param name: The name of this IdResourcesCategoriesBody. # noqa: E501 + :type: str + """ + + self._name = name + + @property + def color(self): + """Gets the color of this IdResourcesCategoriesBody. # noqa: E501 + + Hex color without leading \\#. # noqa: E501 + + :return: The color of this IdResourcesCategoriesBody. # noqa: E501 + :rtype: str + """ + return self._color + + @color.setter + def color(self, color): + """Sets the color of this IdResourcesCategoriesBody. + + Hex color without leading \\#. # noqa: E501 + + :param color: The color of this IdResourcesCategoriesBody. # noqa: E501 + :type: str + """ + + self._color = color + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(IdResourcesCategoriesBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, IdResourcesCategoriesBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/id_steps_body.py b/vendor/elabapi-python/elabapi_python/models/id_steps_body.py new file mode 100644 index 0000000..8d3d8f7 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/id_steps_body.py @@ -0,0 +1,112 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class IdStepsBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'body': 'str' + } + + attribute_map = { + 'body': 'body' + } + + def __init__(self, body=None): # noqa: E501 + """IdStepsBody - a model defined in Swagger""" # noqa: E501 + self._body = None + self.discriminator = None + if body is not None: + self.body = body + + @property + def body(self): + """Gets the body of this IdStepsBody. # noqa: E501 + + The text content of the step. # noqa: E501 + + :return: The body of this IdStepsBody. # noqa: E501 + :rtype: str + """ + return self._body + + @body.setter + def body(self, body): + """Sets the body of this IdStepsBody. + + The text content of the step. # noqa: E501 + + :param body: The body of this IdStepsBody. # noqa: E501 + :type: str + """ + + self._body = body + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(IdStepsBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, IdStepsBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/id_tags_body.py b/vendor/elabapi-python/elabapi_python/models/id_tags_body.py new file mode 100644 index 0000000..cfce8e8 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/id_tags_body.py @@ -0,0 +1,112 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class IdTagsBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'tag': 'str' + } + + attribute_map = { + 'tag': 'tag' + } + + def __init__(self, tag=None): # noqa: E501 + """IdTagsBody - a model defined in Swagger""" # noqa: E501 + self._tag = None + self.discriminator = None + if tag is not None: + self.tag = tag + + @property + def tag(self): + """Gets the tag of this IdTagsBody. # noqa: E501 + + Tag to add # noqa: E501 + + :return: The tag of this IdTagsBody. # noqa: E501 + :rtype: str + """ + return self._tag + + @tag.setter + def tag(self, tag): + """Sets the tag of this IdTagsBody. + + Tag to add # noqa: E501 + + :param tag: The tag of this IdTagsBody. # noqa: E501 + :type: str + """ + + self._tag = tag + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(IdTagsBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, IdTagsBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/id_tags_body1.py b/vendor/elabapi-python/elabapi_python/models/id_tags_body1.py new file mode 100644 index 0000000..4515560 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/id_tags_body1.py @@ -0,0 +1,84 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class IdTagsBody1(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + } + + attribute_map = { + } + + def __init__(self): # noqa: E501 + """IdTagsBody1 - a model defined in Swagger""" # noqa: E501 + self.discriminator = None + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(IdTagsBody1, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, IdTagsBody1): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/id_teamgroups_body.py b/vendor/elabapi-python/elabapi_python/models/id_teamgroups_body.py new file mode 100644 index 0000000..6d2805d --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/id_teamgroups_body.py @@ -0,0 +1,112 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class IdTeamgroupsBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'name': 'str' + } + + attribute_map = { + 'name': 'name' + } + + def __init__(self, name=None): # noqa: E501 + """IdTeamgroupsBody - a model defined in Swagger""" # noqa: E501 + self._name = None + self.discriminator = None + if name is not None: + self.name = name + + @property + def name(self): + """Gets the name of this IdTeamgroupsBody. # noqa: E501 + + Teamgroup name # noqa: E501 + + :return: The name of this IdTeamgroupsBody. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this IdTeamgroupsBody. + + Teamgroup name # noqa: E501 + + :param name: The name of this IdTeamgroupsBody. # noqa: E501 + :type: str + """ + + self._name = name + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(IdTeamgroupsBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, IdTeamgroupsBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/id_uploads_body.py b/vendor/elabapi-python/elabapi_python/models/id_uploads_body.py new file mode 100644 index 0000000..0cd9989 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/id_uploads_body.py @@ -0,0 +1,141 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class IdUploadsBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'file': 'str', + 'comment': 'str' + } + + attribute_map = { + 'file': 'file', + 'comment': 'comment' + } + + def __init__(self, file=None, comment=None): # noqa: E501 + """IdUploadsBody - a model defined in Swagger""" # noqa: E501 + self._file = None + self._comment = None + self.discriminator = None + self.file = file + if comment is not None: + self.comment = comment + + @property + def file(self): + """Gets the file of this IdUploadsBody. # noqa: E501 + + The file to upload. # noqa: E501 + + :return: The file of this IdUploadsBody. # noqa: E501 + :rtype: str + """ + return self._file + + @file.setter + def file(self, file): + """Sets the file of this IdUploadsBody. + + The file to upload. # noqa: E501 + + :param file: The file of this IdUploadsBody. # noqa: E501 + :type: str + """ + if file is None: + raise ValueError("Invalid value for `file`, must not be `None`") # noqa: E501 + + self._file = file + + @property + def comment(self): + """Gets the comment of this IdUploadsBody. # noqa: E501 + + Optional file comment. # noqa: E501 + + :return: The comment of this IdUploadsBody. # noqa: E501 + :rtype: str + """ + return self._comment + + @comment.setter + def comment(self, comment): + """Sets the comment of this IdUploadsBody. + + Optional file comment. # noqa: E501 + + :param comment: The comment of this IdUploadsBody. # noqa: E501 + :type: str + """ + + self._comment = comment + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(IdUploadsBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, IdUploadsBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/idp.py b/vendor/elabapi-python/elabapi_python/models/idp.py new file mode 100644 index 0000000..50b26a4 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/idp.py @@ -0,0 +1,426 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Idp(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'name': 'str', + 'entityid': 'str', + 'enabled': 'int', + 'email_attr': 'str', + 'fname_attr': 'str', + 'lname_attr': 'str', + 'team_attr': 'str', + 'orgid_attr': 'str', + 'orcid_attr': 'str', + 'source': 'ModelInt', + 'certs': 'list[IdpCert]', + 'endpoints': 'list[IdpEndpoint]' + } + + attribute_map = { + 'id': 'id', + 'name': 'name', + 'entityid': 'entityid', + 'enabled': 'enabled', + 'email_attr': 'email_attr', + 'fname_attr': 'fname_attr', + 'lname_attr': 'lname_attr', + 'team_attr': 'team_attr', + 'orgid_attr': 'orgid_attr', + 'orcid_attr': 'orcid_attr', + 'source': 'source', + 'certs': 'certs', + 'endpoints': 'endpoints' + } + + def __init__(self, id=None, name=None, entityid=None, enabled=None, email_attr=None, fname_attr=None, lname_attr=None, team_attr=None, orgid_attr=None, orcid_attr=None, source=None, certs=None, endpoints=None): # noqa: E501 + """Idp - a model defined in Swagger""" # noqa: E501 + self._id = None + self._name = None + self._entityid = None + self._enabled = None + self._email_attr = None + self._fname_attr = None + self._lname_attr = None + self._team_attr = None + self._orgid_attr = None + self._orcid_attr = None + self._source = None + self._certs = None + self._endpoints = None + self.discriminator = None + if id is not None: + self.id = id + if name is not None: + self.name = name + if entityid is not None: + self.entityid = entityid + if enabled is not None: + self.enabled = enabled + if email_attr is not None: + self.email_attr = email_attr + if fname_attr is not None: + self.fname_attr = fname_attr + if lname_attr is not None: + self.lname_attr = lname_attr + if team_attr is not None: + self.team_attr = team_attr + if orgid_attr is not None: + self.orgid_attr = orgid_attr + if orcid_attr is not None: + self.orcid_attr = orcid_attr + if source is not None: + self.source = source + if certs is not None: + self.certs = certs + if endpoints is not None: + self.endpoints = endpoints + + @property + def id(self): + """Gets the id of this Idp. # noqa: E501 + + + :return: The id of this Idp. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this Idp. + + + :param id: The id of this Idp. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def name(self): + """Gets the name of this Idp. # noqa: E501 + + + :return: The name of this Idp. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this Idp. + + + :param name: The name of this Idp. # noqa: E501 + :type: str + """ + + self._name = name + + @property + def entityid(self): + """Gets the entityid of this Idp. # noqa: E501 + + + :return: The entityid of this Idp. # noqa: E501 + :rtype: str + """ + return self._entityid + + @entityid.setter + def entityid(self, entityid): + """Sets the entityid of this Idp. + + + :param entityid: The entityid of this Idp. # noqa: E501 + :type: str + """ + + self._entityid = entityid + + @property + def enabled(self): + """Gets the enabled of this Idp. # noqa: E501 + + + :return: The enabled of this Idp. # noqa: E501 + :rtype: int + """ + return self._enabled + + @enabled.setter + def enabled(self, enabled): + """Sets the enabled of this Idp. + + + :param enabled: The enabled of this Idp. # noqa: E501 + :type: int + """ + + self._enabled = enabled + + @property + def email_attr(self): + """Gets the email_attr of this Idp. # noqa: E501 + + + :return: The email_attr of this Idp. # noqa: E501 + :rtype: str + """ + return self._email_attr + + @email_attr.setter + def email_attr(self, email_attr): + """Sets the email_attr of this Idp. + + + :param email_attr: The email_attr of this Idp. # noqa: E501 + :type: str + """ + + self._email_attr = email_attr + + @property + def fname_attr(self): + """Gets the fname_attr of this Idp. # noqa: E501 + + + :return: The fname_attr of this Idp. # noqa: E501 + :rtype: str + """ + return self._fname_attr + + @fname_attr.setter + def fname_attr(self, fname_attr): + """Sets the fname_attr of this Idp. + + + :param fname_attr: The fname_attr of this Idp. # noqa: E501 + :type: str + """ + + self._fname_attr = fname_attr + + @property + def lname_attr(self): + """Gets the lname_attr of this Idp. # noqa: E501 + + + :return: The lname_attr of this Idp. # noqa: E501 + :rtype: str + """ + return self._lname_attr + + @lname_attr.setter + def lname_attr(self, lname_attr): + """Sets the lname_attr of this Idp. + + + :param lname_attr: The lname_attr of this Idp. # noqa: E501 + :type: str + """ + + self._lname_attr = lname_attr + + @property + def team_attr(self): + """Gets the team_attr of this Idp. # noqa: E501 + + + :return: The team_attr of this Idp. # noqa: E501 + :rtype: str + """ + return self._team_attr + + @team_attr.setter + def team_attr(self, team_attr): + """Sets the team_attr of this Idp. + + + :param team_attr: The team_attr of this Idp. # noqa: E501 + :type: str + """ + + self._team_attr = team_attr + + @property + def orgid_attr(self): + """Gets the orgid_attr of this Idp. # noqa: E501 + + + :return: The orgid_attr of this Idp. # noqa: E501 + :rtype: str + """ + return self._orgid_attr + + @orgid_attr.setter + def orgid_attr(self, orgid_attr): + """Sets the orgid_attr of this Idp. + + + :param orgid_attr: The orgid_attr of this Idp. # noqa: E501 + :type: str + """ + + self._orgid_attr = orgid_attr + + @property + def orcid_attr(self): + """Gets the orcid_attr of this Idp. # noqa: E501 + + + :return: The orcid_attr of this Idp. # noqa: E501 + :rtype: str + """ + return self._orcid_attr + + @orcid_attr.setter + def orcid_attr(self, orcid_attr): + """Sets the orcid_attr of this Idp. + + + :param orcid_attr: The orcid_attr of this Idp. # noqa: E501 + :type: str + """ + + self._orcid_attr = orcid_attr + + @property + def source(self): + """Gets the source of this Idp. # noqa: E501 + + + :return: The source of this Idp. # noqa: E501 + :rtype: ModelInt + """ + return self._source + + @source.setter + def source(self, source): + """Sets the source of this Idp. + + + :param source: The source of this Idp. # noqa: E501 + :type: ModelInt + """ + + self._source = source + + @property + def certs(self): + """Gets the certs of this Idp. # noqa: E501 + + Certificates associated with this IdP. # noqa: E501 + + :return: The certs of this Idp. # noqa: E501 + :rtype: list[IdpCert] + """ + return self._certs + + @certs.setter + def certs(self, certs): + """Sets the certs of this Idp. + + Certificates associated with this IdP. # noqa: E501 + + :param certs: The certs of this Idp. # noqa: E501 + :type: list[IdpCert] + """ + + self._certs = certs + + @property + def endpoints(self): + """Gets the endpoints of this Idp. # noqa: E501 + + Endpoints associated with this IdP. # noqa: E501 + + :return: The endpoints of this Idp. # noqa: E501 + :rtype: list[IdpEndpoint] + """ + return self._endpoints + + @endpoints.setter + def endpoints(self, endpoints): + """Sets the endpoints of this Idp. + + Endpoints associated with this IdP. # noqa: E501 + + :param endpoints: The endpoints of this Idp. # noqa: E501 + :type: list[IdpEndpoint] + """ + + self._endpoints = endpoints + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Idp, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Idp): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/idp_cert.py b/vendor/elabapi-python/elabapi_python/models/idp_cert.py new file mode 100644 index 0000000..5567fa0 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/idp_cert.py @@ -0,0 +1,312 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class IdpCert(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'x509': 'str', + 'sha256': 'str', + 'purpose': 'int', + 'not_before': 'str', + 'not_after': 'str', + 'created_at': 'str', + 'modified_at': 'str' + } + + attribute_map = { + 'id': 'id', + 'x509': 'x509', + 'sha256': 'sha256', + 'purpose': 'purpose', + 'not_before': 'not_before', + 'not_after': 'not_after', + 'created_at': 'created_at', + 'modified_at': 'modified_at' + } + + def __init__(self, id=None, x509=None, sha256=None, purpose=None, not_before=None, not_after=None, created_at=None, modified_at=None): # noqa: E501 + """IdpCert - a model defined in Swagger""" # noqa: E501 + self._id = None + self._x509 = None + self._sha256 = None + self._purpose = None + self._not_before = None + self._not_after = None + self._created_at = None + self._modified_at = None + self.discriminator = None + self.id = id + self.x509 = x509 + self.sha256 = sha256 + self.purpose = purpose + if not_before is not None: + self.not_before = not_before + if not_after is not None: + self.not_after = not_after + self.created_at = created_at + self.modified_at = modified_at + + @property + def id(self): + """Gets the id of this IdpCert. # noqa: E501 + + + :return: The id of this IdpCert. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this IdpCert. + + + :param id: The id of this IdpCert. # noqa: E501 + :type: int + """ + if id is None: + raise ValueError("Invalid value for `id`, must not be `None`") # noqa: E501 + + self._id = id + + @property + def x509(self): + """Gets the x509 of this IdpCert. # noqa: E501 + + Base64 encoded DER representation of the X.509 certificate (as stored in the database). # noqa: E501 + + :return: The x509 of this IdpCert. # noqa: E501 + :rtype: str + """ + return self._x509 + + @x509.setter + def x509(self, x509): + """Sets the x509 of this IdpCert. + + Base64 encoded DER representation of the X.509 certificate (as stored in the database). # noqa: E501 + + :param x509: The x509 of this IdpCert. # noqa: E501 + :type: str + """ + if x509 is None: + raise ValueError("Invalid value for `x509`, must not be `None`") # noqa: E501 + + self._x509 = x509 + + @property + def sha256(self): + """Gets the sha256 of this IdpCert. # noqa: E501 + + Hex encoded SHA 256 fingerprint of the certificate. # noqa: E501 + + :return: The sha256 of this IdpCert. # noqa: E501 + :rtype: str + """ + return self._sha256 + + @sha256.setter + def sha256(self, sha256): + """Sets the sha256 of this IdpCert. + + Hex encoded SHA 256 fingerprint of the certificate. # noqa: E501 + + :param sha256: The sha256 of this IdpCert. # noqa: E501 + :type: str + """ + if sha256 is None: + raise ValueError("Invalid value for `sha256`, must not be `None`") # noqa: E501 + + self._sha256 = sha256 + + @property + def purpose(self): + """Gets the purpose of this IdpCert. # noqa: E501 + + Usage of the certificate. 0 for signing, 1 for encryption. # noqa: E501 + + :return: The purpose of this IdpCert. # noqa: E501 + :rtype: int + """ + return self._purpose + + @purpose.setter + def purpose(self, purpose): + """Sets the purpose of this IdpCert. + + Usage of the certificate. 0 for signing, 1 for encryption. # noqa: E501 + + :param purpose: The purpose of this IdpCert. # noqa: E501 + :type: int + """ + if purpose is None: + raise ValueError("Invalid value for `purpose`, must not be `None`") # noqa: E501 + + self._purpose = purpose + + @property + def not_before(self): + """Gets the not_before of this IdpCert. # noqa: E501 + + Validity starting date for certificate # noqa: E501 + + :return: The not_before of this IdpCert. # noqa: E501 + :rtype: str + """ + return self._not_before + + @not_before.setter + def not_before(self, not_before): + """Sets the not_before of this IdpCert. + + Validity starting date for certificate # noqa: E501 + + :param not_before: The not_before of this IdpCert. # noqa: E501 + :type: str + """ + + self._not_before = not_before + + @property + def not_after(self): + """Gets the not_after of this IdpCert. # noqa: E501 + + Validity end date for certificate # noqa: E501 + + :return: The not_after of this IdpCert. # noqa: E501 + :rtype: str + """ + return self._not_after + + @not_after.setter + def not_after(self, not_after): + """Sets the not_after of this IdpCert. + + Validity end date for certificate # noqa: E501 + + :param not_after: The not_after of this IdpCert. # noqa: E501 + :type: str + """ + + self._not_after = not_after + + @property + def created_at(self): + """Gets the created_at of this IdpCert. # noqa: E501 + + Timestamp when the certificate was created. # noqa: E501 + + :return: The created_at of this IdpCert. # noqa: E501 + :rtype: str + """ + return self._created_at + + @created_at.setter + def created_at(self, created_at): + """Sets the created_at of this IdpCert. + + Timestamp when the certificate was created. # noqa: E501 + + :param created_at: The created_at of this IdpCert. # noqa: E501 + :type: str + """ + if created_at is None: + raise ValueError("Invalid value for `created_at`, must not be `None`") # noqa: E501 + + self._created_at = created_at + + @property + def modified_at(self): + """Gets the modified_at of this IdpCert. # noqa: E501 + + Timestamp when the certificate was last modified. # noqa: E501 + + :return: The modified_at of this IdpCert. # noqa: E501 + :rtype: str + """ + return self._modified_at + + @modified_at.setter + def modified_at(self, modified_at): + """Sets the modified_at of this IdpCert. + + Timestamp when the certificate was last modified. # noqa: E501 + + :param modified_at: The modified_at of this IdpCert. # noqa: E501 + :type: str + """ + if modified_at is None: + raise ValueError("Invalid value for `modified_at`, must not be `None`") # noqa: E501 + + self._modified_at = modified_at + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(IdpCert, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, IdpCert): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/idp_endpoint.py b/vendor/elabapi-python/elabapi_python/models/idp_endpoint.py new file mode 100644 index 0000000..242ef0c --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/idp_endpoint.py @@ -0,0 +1,290 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class IdpEndpoint(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'is_slo': 'int', + 'binding': 'int', + 'location': 'str', + 'binding_urn': 'str', + 'created_at': 'str', + 'modified_at': 'str' + } + + attribute_map = { + 'id': 'id', + 'is_slo': 'is_slo', + 'binding': 'binding', + 'location': 'location', + 'binding_urn': 'binding_urn', + 'created_at': 'created_at', + 'modified_at': 'modified_at' + } + + def __init__(self, id=None, is_slo=None, binding=None, location=None, binding_urn=None, created_at=None, modified_at=None): # noqa: E501 + """IdpEndpoint - a model defined in Swagger""" # noqa: E501 + self._id = None + self._is_slo = None + self._binding = None + self._location = None + self._binding_urn = None + self._created_at = None + self._modified_at = None + self.discriminator = None + if id is not None: + self.id = id + if is_slo is not None: + self.is_slo = is_slo + if binding is not None: + self.binding = binding + if location is not None: + self.location = location + if binding_urn is not None: + self.binding_urn = binding_urn + if created_at is not None: + self.created_at = created_at + if modified_at is not None: + self.modified_at = modified_at + + @property + def id(self): + """Gets the id of this IdpEndpoint. # noqa: E501 + + + :return: The id of this IdpEndpoint. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this IdpEndpoint. + + + :param id: The id of this IdpEndpoint. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def is_slo(self): + """Gets the is_slo of this IdpEndpoint. # noqa: E501 + + Will be 1 if the endpoint is for SLO (otherwise it means it's SSO) # noqa: E501 + + :return: The is_slo of this IdpEndpoint. # noqa: E501 + :rtype: int + """ + return self._is_slo + + @is_slo.setter + def is_slo(self, is_slo): + """Sets the is_slo of this IdpEndpoint. + + Will be 1 if the endpoint is for SLO (otherwise it means it's SSO) # noqa: E501 + + :param is_slo: The is_slo of this IdpEndpoint. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_slo not in allowed_values: + raise ValueError( + "Invalid value for `is_slo` ({0}), must be one of {1}" # noqa: E501 + .format(is_slo, allowed_values) + ) + + self._is_slo = is_slo + + @property + def binding(self): + """Gets the binding of this IdpEndpoint. # noqa: E501 + + The type of binding: POST or redirect(see SamlBinding enum) # noqa: E501 + + :return: The binding of this IdpEndpoint. # noqa: E501 + :rtype: int + """ + return self._binding + + @binding.setter + def binding(self, binding): + """Sets the binding of this IdpEndpoint. + + The type of binding: POST or redirect(see SamlBinding enum) # noqa: E501 + + :param binding: The binding of this IdpEndpoint. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if binding not in allowed_values: + raise ValueError( + "Invalid value for `binding` ({0}), must be one of {1}" # noqa: E501 + .format(binding, allowed_values) + ) + + self._binding = binding + + @property + def location(self): + """Gets the location of this IdpEndpoint. # noqa: E501 + + Actual URL # noqa: E501 + + :return: The location of this IdpEndpoint. # noqa: E501 + :rtype: str + """ + return self._location + + @location.setter + def location(self, location): + """Sets the location of this IdpEndpoint. + + Actual URL # noqa: E501 + + :param location: The location of this IdpEndpoint. # noqa: E501 + :type: str + """ + + self._location = location + + @property + def binding_urn(self): + """Gets the binding_urn of this IdpEndpoint. # noqa: E501 + + URN corresponding to the `binding` field # noqa: E501 + + :return: The binding_urn of this IdpEndpoint. # noqa: E501 + :rtype: str + """ + return self._binding_urn + + @binding_urn.setter + def binding_urn(self, binding_urn): + """Sets the binding_urn of this IdpEndpoint. + + URN corresponding to the `binding` field # noqa: E501 + + :param binding_urn: The binding_urn of this IdpEndpoint. # noqa: E501 + :type: str + """ + + self._binding_urn = binding_urn + + @property + def created_at(self): + """Gets the created_at of this IdpEndpoint. # noqa: E501 + + Timestamp when the endpoint was created. # noqa: E501 + + :return: The created_at of this IdpEndpoint. # noqa: E501 + :rtype: str + """ + return self._created_at + + @created_at.setter + def created_at(self, created_at): + """Sets the created_at of this IdpEndpoint. + + Timestamp when the endpoint was created. # noqa: E501 + + :param created_at: The created_at of this IdpEndpoint. # noqa: E501 + :type: str + """ + + self._created_at = created_at + + @property + def modified_at(self): + """Gets the modified_at of this IdpEndpoint. # noqa: E501 + + Timestamp when the endpoint was last modified. # noqa: E501 + + :return: The modified_at of this IdpEndpoint. # noqa: E501 + :rtype: str + """ + return self._modified_at + + @modified_at.setter + def modified_at(self, modified_at): + """Sets the modified_at of this IdpEndpoint. + + Timestamp when the endpoint was last modified. # noqa: E501 + + :param modified_at: The modified_at of this IdpEndpoint. # noqa: E501 + :type: str + """ + + self._modified_at = modified_at + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(IdpEndpoint, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, IdpEndpoint): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/idp_source.py b/vendor/elabapi-python/elabapi_python/models/idp_source.py new file mode 100644 index 0000000..777f0fd --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/idp_source.py @@ -0,0 +1,240 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class IdpSource(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'url': 'str', + 'auto_refresh': 'int', + 'last_fetched_at': 'datetime', + 'idps_count': 'int', + 'idps_count_enabled': 'int' + } + + attribute_map = { + 'id': 'id', + 'url': 'url', + 'auto_refresh': 'auto_refresh', + 'last_fetched_at': 'last_fetched_at', + 'idps_count': 'idps_count', + 'idps_count_enabled': 'idps_count_enabled' + } + + def __init__(self, id=None, url=None, auto_refresh=None, last_fetched_at=None, idps_count=None, idps_count_enabled=None): # noqa: E501 + """IdpSource - a model defined in Swagger""" # noqa: E501 + self._id = None + self._url = None + self._auto_refresh = None + self._last_fetched_at = None + self._idps_count = None + self._idps_count_enabled = None + self.discriminator = None + if id is not None: + self.id = id + if url is not None: + self.url = url + if auto_refresh is not None: + self.auto_refresh = auto_refresh + if last_fetched_at is not None: + self.last_fetched_at = last_fetched_at + if idps_count is not None: + self.idps_count = idps_count + if idps_count_enabled is not None: + self.idps_count_enabled = idps_count_enabled + + @property + def id(self): + """Gets the id of this IdpSource. # noqa: E501 + + + :return: The id of this IdpSource. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this IdpSource. + + + :param id: The id of this IdpSource. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def url(self): + """Gets the url of this IdpSource. # noqa: E501 + + + :return: The url of this IdpSource. # noqa: E501 + :rtype: str + """ + return self._url + + @url.setter + def url(self, url): + """Sets the url of this IdpSource. + + + :param url: The url of this IdpSource. # noqa: E501 + :type: str + """ + + self._url = url + + @property + def auto_refresh(self): + """Gets the auto_refresh of this IdpSource. # noqa: E501 + + + :return: The auto_refresh of this IdpSource. # noqa: E501 + :rtype: int + """ + return self._auto_refresh + + @auto_refresh.setter + def auto_refresh(self, auto_refresh): + """Sets the auto_refresh of this IdpSource. + + + :param auto_refresh: The auto_refresh of this IdpSource. # noqa: E501 + :type: int + """ + + self._auto_refresh = auto_refresh + + @property + def last_fetched_at(self): + """Gets the last_fetched_at of this IdpSource. # noqa: E501 + + + :return: The last_fetched_at of this IdpSource. # noqa: E501 + :rtype: datetime + """ + return self._last_fetched_at + + @last_fetched_at.setter + def last_fetched_at(self, last_fetched_at): + """Sets the last_fetched_at of this IdpSource. + + + :param last_fetched_at: The last_fetched_at of this IdpSource. # noqa: E501 + :type: datetime + """ + + self._last_fetched_at = last_fetched_at + + @property + def idps_count(self): + """Gets the idps_count of this IdpSource. # noqa: E501 + + + :return: The idps_count of this IdpSource. # noqa: E501 + :rtype: int + """ + return self._idps_count + + @idps_count.setter + def idps_count(self, idps_count): + """Sets the idps_count of this IdpSource. + + + :param idps_count: The idps_count of this IdpSource. # noqa: E501 + :type: int + """ + + self._idps_count = idps_count + + @property + def idps_count_enabled(self): + """Gets the idps_count_enabled of this IdpSource. # noqa: E501 + + + :return: The idps_count_enabled of this IdpSource. # noqa: E501 + :rtype: int + """ + return self._idps_count_enabled + + @idps_count_enabled.setter + def idps_count_enabled(self, idps_count_enabled): + """Sets the idps_count_enabled of this IdpSource. + + + :param idps_count_enabled: The idps_count_enabled of this IdpSource. # noqa: E501 + :type: int + """ + + self._idps_count_enabled = idps_count_enabled + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(IdpSource, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, IdpSource): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/idps_body.py b/vendor/elabapi-python/elabapi_python/models/idps_body.py new file mode 100644 index 0000000..063c3cf --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/idps_body.py @@ -0,0 +1,311 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class IdpsBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'name': 'str', + 'entityid': 'str', + 'email_attr': 'str', + 'fname_attr': 'str', + 'lname_attr': 'str', + 'team_attr': 'str', + 'orgid_attr': 'str', + 'orcid_attr': 'str' + } + + attribute_map = { + 'name': 'name', + 'entityid': 'entityid', + 'email_attr': 'email_attr', + 'fname_attr': 'fname_attr', + 'lname_attr': 'lname_attr', + 'team_attr': 'team_attr', + 'orgid_attr': 'orgid_attr', + 'orcid_attr': 'orcid_attr' + } + + def __init__(self, name=None, entityid=None, email_attr=None, fname_attr=None, lname_attr=None, team_attr=None, orgid_attr=None, orcid_attr=None): # noqa: E501 + """IdpsBody - a model defined in Swagger""" # noqa: E501 + self._name = None + self._entityid = None + self._email_attr = None + self._fname_attr = None + self._lname_attr = None + self._team_attr = None + self._orgid_attr = None + self._orcid_attr = None + self.discriminator = None + self.name = name + self.entityid = entityid + self.email_attr = email_attr + if fname_attr is not None: + self.fname_attr = fname_attr + if lname_attr is not None: + self.lname_attr = lname_attr + if team_attr is not None: + self.team_attr = team_attr + if orgid_attr is not None: + self.orgid_attr = orgid_attr + if orcid_attr is not None: + self.orcid_attr = orcid_attr + + @property + def name(self): + """Gets the name of this IdpsBody. # noqa: E501 + + A name for the IDP. # noqa: E501 + + :return: The name of this IdpsBody. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this IdpsBody. + + A name for the IDP. # noqa: E501 + + :param name: The name of this IdpsBody. # noqa: E501 + :type: str + """ + if name is None: + raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501 + + self._name = name + + @property + def entityid(self): + """Gets the entityid of this IdpsBody. # noqa: E501 + + Entityid. # noqa: E501 + + :return: The entityid of this IdpsBody. # noqa: E501 + :rtype: str + """ + return self._entityid + + @entityid.setter + def entityid(self, entityid): + """Sets the entityid of this IdpsBody. + + Entityid. # noqa: E501 + + :param entityid: The entityid of this IdpsBody. # noqa: E501 + :type: str + """ + if entityid is None: + raise ValueError("Invalid value for `entityid`, must not be `None`") # noqa: E501 + + self._entityid = entityid + + @property + def email_attr(self): + """Gets the email_attr of this IdpsBody. # noqa: E501 + + What attribute to look for the email. # noqa: E501 + + :return: The email_attr of this IdpsBody. # noqa: E501 + :rtype: str + """ + return self._email_attr + + @email_attr.setter + def email_attr(self, email_attr): + """Sets the email_attr of this IdpsBody. + + What attribute to look for the email. # noqa: E501 + + :param email_attr: The email_attr of this IdpsBody. # noqa: E501 + :type: str + """ + if email_attr is None: + raise ValueError("Invalid value for `email_attr`, must not be `None`") # noqa: E501 + + self._email_attr = email_attr + + @property + def fname_attr(self): + """Gets the fname_attr of this IdpsBody. # noqa: E501 + + What attribute to look for the firstname. # noqa: E501 + + :return: The fname_attr of this IdpsBody. # noqa: E501 + :rtype: str + """ + return self._fname_attr + + @fname_attr.setter + def fname_attr(self, fname_attr): + """Sets the fname_attr of this IdpsBody. + + What attribute to look for the firstname. # noqa: E501 + + :param fname_attr: The fname_attr of this IdpsBody. # noqa: E501 + :type: str + """ + + self._fname_attr = fname_attr + + @property + def lname_attr(self): + """Gets the lname_attr of this IdpsBody. # noqa: E501 + + What attribute to look for the lastname. # noqa: E501 + + :return: The lname_attr of this IdpsBody. # noqa: E501 + :rtype: str + """ + return self._lname_attr + + @lname_attr.setter + def lname_attr(self, lname_attr): + """Sets the lname_attr of this IdpsBody. + + What attribute to look for the lastname. # noqa: E501 + + :param lname_attr: The lname_attr of this IdpsBody. # noqa: E501 + :type: str + """ + + self._lname_attr = lname_attr + + @property + def team_attr(self): + """Gets the team_attr of this IdpsBody. # noqa: E501 + + What attribute to look for the team. # noqa: E501 + + :return: The team_attr of this IdpsBody. # noqa: E501 + :rtype: str + """ + return self._team_attr + + @team_attr.setter + def team_attr(self, team_attr): + """Sets the team_attr of this IdpsBody. + + What attribute to look for the team. # noqa: E501 + + :param team_attr: The team_attr of this IdpsBody. # noqa: E501 + :type: str + """ + + self._team_attr = team_attr + + @property + def orgid_attr(self): + """Gets the orgid_attr of this IdpsBody. # noqa: E501 + + What attribute to look for the internal id. # noqa: E501 + + :return: The orgid_attr of this IdpsBody. # noqa: E501 + :rtype: str + """ + return self._orgid_attr + + @orgid_attr.setter + def orgid_attr(self, orgid_attr): + """Sets the orgid_attr of this IdpsBody. + + What attribute to look for the internal id. # noqa: E501 + + :param orgid_attr: The orgid_attr of this IdpsBody. # noqa: E501 + :type: str + """ + + self._orgid_attr = orgid_attr + + @property + def orcid_attr(self): + """Gets the orcid_attr of this IdpsBody. # noqa: E501 + + What attribute to look for the ORCID. # noqa: E501 + + :return: The orcid_attr of this IdpsBody. # noqa: E501 + :rtype: str + """ + return self._orcid_attr + + @orcid_attr.setter + def orcid_attr(self, orcid_attr): + """Sets the orcid_attr of this IdpsBody. + + What attribute to look for the ORCID. # noqa: E501 + + :param orcid_attr: The orcid_attr of this IdpsBody. # noqa: E501 + :type: str + """ + + self._orcid_attr = orcid_attr + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(IdpsBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, IdpsBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/idps_id_body.py b/vendor/elabapi-python/elabapi_python/models/idps_id_body.py new file mode 100644 index 0000000..01af50b --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/idps_id_body.py @@ -0,0 +1,117 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class IdpsIdBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'action': 'str' + } + + attribute_map = { + 'action': 'action' + } + + def __init__(self, action=None): # noqa: E501 + """IdpsIdBody - a model defined in Swagger""" # noqa: E501 + self._action = None + self.discriminator = None + self.action = action + + @property + def action(self): + """Gets the action of this IdpsIdBody. # noqa: E501 + + + :return: The action of this IdpsIdBody. # noqa: E501 + :rtype: str + """ + return self._action + + @action.setter + def action(self, action): + """Sets the action of this IdpsIdBody. + + + :param action: The action of this IdpsIdBody. # noqa: E501 + :type: str + """ + if action is None: + raise ValueError("Invalid value for `action`, must not be `None`") # noqa: E501 + allowed_values = ["update"] # noqa: E501 + if action not in allowed_values: + raise ValueError( + "Invalid value for `action` ({0}), must be one of {1}" # noqa: E501 + .format(action, allowed_values) + ) + + self._action = action + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(IdpsIdBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, IdpsIdBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/idps_sources_body.py b/vendor/elabapi-python/elabapi_python/models/idps_sources_body.py new file mode 100644 index 0000000..d7f3540 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/idps_sources_body.py @@ -0,0 +1,113 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class IdpsSourcesBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'url': 'str' + } + + attribute_map = { + 'url': 'url' + } + + def __init__(self, url=None): # noqa: E501 + """IdpsSourcesBody - a model defined in Swagger""" # noqa: E501 + self._url = None + self.discriminator = None + self.url = url + + @property + def url(self): + """Gets the url of this IdpsSourcesBody. # noqa: E501 + + URL to the public XML metadata file # noqa: E501 + + :return: The url of this IdpsSourcesBody. # noqa: E501 + :rtype: str + """ + return self._url + + @url.setter + def url(self, url): + """Sets the url of this IdpsSourcesBody. + + URL to the public XML metadata file # noqa: E501 + + :param url: The url of this IdpsSourcesBody. # noqa: E501 + :type: str + """ + if url is None: + raise ValueError("Invalid value for `url`, must not be `None`") # noqa: E501 + + self._url = url + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(IdpsSourcesBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, IdpsSourcesBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/idps_sources_id_body.py b/vendor/elabapi-python/elabapi_python/models/idps_sources_id_body.py new file mode 100644 index 0000000..52599ab --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/idps_sources_id_body.py @@ -0,0 +1,119 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class IdpsSourcesIdBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'action': 'str' + } + + attribute_map = { + 'action': 'action' + } + + def __init__(self, action=None): # noqa: E501 + """IdpsSourcesIdBody - a model defined in Swagger""" # noqa: E501 + self._action = None + self.discriminator = None + self.action = action + + @property + def action(self): + """Gets the action of this IdpsSourcesIdBody. # noqa: E501 + + Use `update` to toggle autorefresh, `replace` to load IdPs, `validate` to enable all associated IdPs, `finish` to invalidate all associated IdPs. # noqa: E501 + + :return: The action of this IdpsSourcesIdBody. # noqa: E501 + :rtype: str + """ + return self._action + + @action.setter + def action(self, action): + """Sets the action of this IdpsSourcesIdBody. + + Use `update` to toggle autorefresh, `replace` to load IdPs, `validate` to enable all associated IdPs, `finish` to invalidate all associated IdPs. # noqa: E501 + + :param action: The action of this IdpsSourcesIdBody. # noqa: E501 + :type: str + """ + if action is None: + raise ValueError("Invalid value for `action`, must not be `None`") # noqa: E501 + allowed_values = ["update", "replace", "validate", "finish"] # noqa: E501 + if action not in allowed_values: + raise ValueError( + "Invalid value for `action` ({0}), must be one of {1}" # noqa: E501 + .format(action, allowed_values) + ) + + self._action = action + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(IdpsSourcesIdBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, IdpsSourcesIdBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/import_body.py b/vendor/elabapi-python/elabapi_python/models/import_body.py new file mode 100644 index 0000000..7017909 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/import_body.py @@ -0,0 +1,272 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class ImportBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'file': 'str', + 'entity_type': 'str', + 'category': 'int', + 'canread_base': 'float', + 'canwrite_base': 'float', + 'owner': 'int' + } + + attribute_map = { + 'file': 'file', + 'entity_type': 'entity_type', + 'category': 'category', + 'canread_base': 'canread_base', + 'canwrite_base': 'canwrite_base', + 'owner': 'owner' + } + + def __init__(self, file=None, entity_type=None, category=None, canread_base=None, canwrite_base=None, owner=None): # noqa: E501 + """ImportBody - a model defined in Swagger""" # noqa: E501 + self._file = None + self._entity_type = None + self._category = None + self._canread_base = None + self._canwrite_base = None + self._owner = None + self.discriminator = None + self.file = file + self.entity_type = entity_type + if category is not None: + self.category = category + if canread_base is not None: + self.canread_base = canread_base + if canwrite_base is not None: + self.canwrite_base = canwrite_base + if owner is not None: + self.owner = owner + + @property + def file(self): + """Gets the file of this ImportBody. # noqa: E501 + + The file to upload. # noqa: E501 + + :return: The file of this ImportBody. # noqa: E501 + :rtype: str + """ + return self._file + + @file.setter + def file(self, file): + """Sets the file of this ImportBody. + + The file to upload. # noqa: E501 + + :param file: The file of this ImportBody. # noqa: E501 + :type: str + """ + if file is None: + raise ValueError("Invalid value for `file`, must not be `None`") # noqa: E501 + + self._file = file + + @property + def entity_type(self): + """Gets the entity_type of this ImportBody. # noqa: E501 + + The target entity type # noqa: E501 + + :return: The entity_type of this ImportBody. # noqa: E501 + :rtype: str + """ + return self._entity_type + + @entity_type.setter + def entity_type(self, entity_type): + """Sets the entity_type of this ImportBody. + + The target entity type # noqa: E501 + + :param entity_type: The entity_type of this ImportBody. # noqa: E501 + :type: str + """ + if entity_type is None: + raise ValueError("Invalid value for `entity_type`, must not be `None`") # noqa: E501 + allowed_values = ["experiments", "items", "experiments_templates", "items_types"] # noqa: E501 + if entity_type not in allowed_values: + raise ValueError( + "Invalid value for `entity_type` ({0}), must be one of {1}" # noqa: E501 + .format(entity_type, allowed_values) + ) + + self._entity_type = entity_type + + @property + def category(self): + """Gets the category of this ImportBody. # noqa: E501 + + The default category ID if no category is defined for a given entry # noqa: E501 + + :return: The category of this ImportBody. # noqa: E501 + :rtype: int + """ + return self._category + + @category.setter + def category(self, category): + """Sets the category of this ImportBody. + + The default category ID if no category is defined for a given entry # noqa: E501 + + :param category: The category of this ImportBody. # noqa: E501 + :type: int + """ + + self._category = category + + @property + def canread_base(self): + """Gets the canread_base of this ImportBody. # noqa: E501 + + Base permission for read access: - 10: Owner only - 20: Owner + Admins - 30: Team members - 40: Everyone with an account - 50: Everyone including anonymous users # noqa: E501 + + :return: The canread_base of this ImportBody. # noqa: E501 + :rtype: float + """ + return self._canread_base + + @canread_base.setter + def canread_base(self, canread_base): + """Sets the canread_base of this ImportBody. + + Base permission for read access: - 10: Owner only - 20: Owner + Admins - 30: Team members - 40: Everyone with an account - 50: Everyone including anonymous users # noqa: E501 + + :param canread_base: The canread_base of this ImportBody. # noqa: E501 + :type: float + """ + allowed_values = [10, 20, 30, 40, 50] # noqa: E501 + if canread_base not in allowed_values: + raise ValueError( + "Invalid value for `canread_base` ({0}), must be one of {1}" # noqa: E501 + .format(canread_base, allowed_values) + ) + + self._canread_base = canread_base + + @property + def canwrite_base(self): + """Gets the canwrite_base of this ImportBody. # noqa: E501 + + Base permission for write access: - 10: Owner only - 20: Owner + Admins - 30: Team members - 40: Everyone with an account - 50: Everyone including anonymous users # noqa: E501 + + :return: The canwrite_base of this ImportBody. # noqa: E501 + :rtype: float + """ + return self._canwrite_base + + @canwrite_base.setter + def canwrite_base(self, canwrite_base): + """Sets the canwrite_base of this ImportBody. + + Base permission for write access: - 10: Owner only - 20: Owner + Admins - 30: Team members - 40: Everyone with an account - 50: Everyone including anonymous users # noqa: E501 + + :param canwrite_base: The canwrite_base of this ImportBody. # noqa: E501 + :type: float + """ + allowed_values = [10, 20, 30, 40, 50] # noqa: E501 + if canwrite_base not in allowed_values: + raise ValueError( + "Invalid value for `canwrite_base` ({0}), must be one of {1}" # noqa: E501 + .format(canwrite_base, allowed_values) + ) + + self._canwrite_base = canwrite_base + + @property + def owner(self): + """Gets the owner of this ImportBody. # noqa: E501 + + Userid of future owner of imported data # noqa: E501 + + :return: The owner of this ImportBody. # noqa: E501 + :rtype: int + """ + return self._owner + + @owner.setter + def owner(self, owner): + """Sets the owner of this ImportBody. + + Userid of future owner of imported data # noqa: E501 + + :param owner: The owner of this ImportBody. # noqa: E501 + :type: int + """ + + self._owner = owner + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(ImportBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, ImportBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/inline_response200.py b/vendor/elabapi-python/elabapi_python/models/inline_response200.py new file mode 100644 index 0000000..05e6b9d --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/inline_response200.py @@ -0,0 +1,84 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class InlineResponse200(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + } + + attribute_map = { + } + + def __init__(self): # noqa: E501 + """InlineResponse200 - a model defined in Swagger""" # noqa: E501 + self.discriminator = None + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(InlineResponse200, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse200): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/inline_response2001.py b/vendor/elabapi-python/elabapi_python/models/inline_response2001.py new file mode 100644 index 0000000..3ba7c34 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/inline_response2001.py @@ -0,0 +1,84 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class InlineResponse2001(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + } + + attribute_map = { + } + + def __init__(self): # noqa: E501 + """InlineResponse2001 - a model defined in Swagger""" # noqa: E501 + self.discriminator = None + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(InlineResponse2001, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2001): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/inline_response20010.py b/vendor/elabapi-python/elabapi_python/models/inline_response20010.py new file mode 100644 index 0000000..c64b81f --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/inline_response20010.py @@ -0,0 +1,162 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class InlineResponse20010(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'uuid': 'str', + 'public_url': 'str' + } + + attribute_map = { + 'id': 'id', + 'uuid': 'uuid', + 'public_url': 'publicUrl' + } + + def __init__(self, id=None, uuid=None, public_url=None): # noqa: E501 + """InlineResponse20010 - a model defined in Swagger""" # noqa: E501 + self._id = None + self._uuid = None + self._public_url = None + self.discriminator = None + if id is not None: + self.id = id + if uuid is not None: + self.uuid = uuid + if public_url is not None: + self.public_url = public_url + + @property + def id(self): + """Gets the id of this InlineResponse20010. # noqa: E501 + + + :return: The id of this InlineResponse20010. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this InlineResponse20010. + + + :param id: The id of this InlineResponse20010. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def uuid(self): + """Gets the uuid of this InlineResponse20010. # noqa: E501 + + + :return: The uuid of this InlineResponse20010. # noqa: E501 + :rtype: str + """ + return self._uuid + + @uuid.setter + def uuid(self, uuid): + """Sets the uuid of this InlineResponse20010. + + + :param uuid: The uuid of this InlineResponse20010. # noqa: E501 + :type: str + """ + + self._uuid = uuid + + @property + def public_url(self): + """Gets the public_url of this InlineResponse20010. # noqa: E501 + + + :return: The public_url of this InlineResponse20010. # noqa: E501 + :rtype: str + """ + return self._public_url + + @public_url.setter + def public_url(self, public_url): + """Sets the public_url of this InlineResponse20010. + + + :param public_url: The public_url of this InlineResponse20010. # noqa: E501 + :type: str + """ + + self._public_url = public_url + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(InlineResponse20010, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse20010): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/inline_response2001_experiments.py b/vendor/elabapi-python/elabapi_python/models/inline_response2001_experiments.py new file mode 100644 index 0000000..5a5bae4 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/inline_response2001_experiments.py @@ -0,0 +1,136 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class InlineResponse2001Experiments(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'bucket_start': 'date', + 'total': 'int' + } + + attribute_map = { + 'bucket_start': 'bucket_start', + 'total': 'total' + } + + def __init__(self, bucket_start=None, total=None): # noqa: E501 + """InlineResponse2001Experiments - a model defined in Swagger""" # noqa: E501 + self._bucket_start = None + self._total = None + self.discriminator = None + if bucket_start is not None: + self.bucket_start = bucket_start + if total is not None: + self.total = total + + @property + def bucket_start(self): + """Gets the bucket_start of this InlineResponse2001Experiments. # noqa: E501 + + + :return: The bucket_start of this InlineResponse2001Experiments. # noqa: E501 + :rtype: date + """ + return self._bucket_start + + @bucket_start.setter + def bucket_start(self, bucket_start): + """Sets the bucket_start of this InlineResponse2001Experiments. + + + :param bucket_start: The bucket_start of this InlineResponse2001Experiments. # noqa: E501 + :type: date + """ + + self._bucket_start = bucket_start + + @property + def total(self): + """Gets the total of this InlineResponse2001Experiments. # noqa: E501 + + + :return: The total of this InlineResponse2001Experiments. # noqa: E501 + :rtype: int + """ + return self._total + + @total.setter + def total(self, total): + """Sets the total of this InlineResponse2001Experiments. + + + :param total: The total of this InlineResponse2001Experiments. # noqa: E501 + :type: int + """ + + self._total = total + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(InlineResponse2001Experiments, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2001Experiments): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/inline_response2001_items.py b/vendor/elabapi-python/elabapi_python/models/inline_response2001_items.py new file mode 100644 index 0000000..9a71afe --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/inline_response2001_items.py @@ -0,0 +1,136 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class InlineResponse2001Items(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'bucket_start': 'date', + 'total': 'int' + } + + attribute_map = { + 'bucket_start': 'bucket_start', + 'total': 'total' + } + + def __init__(self, bucket_start=None, total=None): # noqa: E501 + """InlineResponse2001Items - a model defined in Swagger""" # noqa: E501 + self._bucket_start = None + self._total = None + self.discriminator = None + if bucket_start is not None: + self.bucket_start = bucket_start + if total is not None: + self.total = total + + @property + def bucket_start(self): + """Gets the bucket_start of this InlineResponse2001Items. # noqa: E501 + + + :return: The bucket_start of this InlineResponse2001Items. # noqa: E501 + :rtype: date + """ + return self._bucket_start + + @bucket_start.setter + def bucket_start(self, bucket_start): + """Sets the bucket_start of this InlineResponse2001Items. + + + :param bucket_start: The bucket_start of this InlineResponse2001Items. # noqa: E501 + :type: date + """ + + self._bucket_start = bucket_start + + @property + def total(self): + """Gets the total of this InlineResponse2001Items. # noqa: E501 + + + :return: The total of this InlineResponse2001Items. # noqa: E501 + :rtype: int + """ + return self._total + + @total.setter + def total(self, total): + """Sets the total of this InlineResponse2001Items. + + + :param total: The total of this InlineResponse2001Items. # noqa: E501 + :type: int + """ + + self._total = total + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(InlineResponse2001Items, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2001Items): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/inline_response2001_users.py b/vendor/elabapi-python/elabapi_python/models/inline_response2001_users.py new file mode 100644 index 0000000..957b7bf --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/inline_response2001_users.py @@ -0,0 +1,136 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class InlineResponse2001Users(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'bucket_start': 'date', + 'total': 'int' + } + + attribute_map = { + 'bucket_start': 'bucket_start', + 'total': 'total' + } + + def __init__(self, bucket_start=None, total=None): # noqa: E501 + """InlineResponse2001Users - a model defined in Swagger""" # noqa: E501 + self._bucket_start = None + self._total = None + self.discriminator = None + if bucket_start is not None: + self.bucket_start = bucket_start + if total is not None: + self.total = total + + @property + def bucket_start(self): + """Gets the bucket_start of this InlineResponse2001Users. # noqa: E501 + + + :return: The bucket_start of this InlineResponse2001Users. # noqa: E501 + :rtype: date + """ + return self._bucket_start + + @bucket_start.setter + def bucket_start(self, bucket_start): + """Sets the bucket_start of this InlineResponse2001Users. + + + :param bucket_start: The bucket_start of this InlineResponse2001Users. # noqa: E501 + :type: date + """ + + self._bucket_start = bucket_start + + @property + def total(self): + """Gets the total of this InlineResponse2001Users. # noqa: E501 + + + :return: The total of this InlineResponse2001Users. # noqa: E501 + :rtype: int + """ + return self._total + + @total.setter + def total(self, total): + """Sets the total of this InlineResponse2001Users. + + + :param total: The total of this InlineResponse2001Users. # noqa: E501 + :type: int + """ + + self._total = total + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(InlineResponse2001Users, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2001Users): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/inline_response2002.py b/vendor/elabapi-python/elabapi_python/models/inline_response2002.py new file mode 100644 index 0000000..8bd03e9 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/inline_response2002.py @@ -0,0 +1,196 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class InlineResponse2002(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'allowed_extensions': 'list[str]', + 'max_filesize': 'int', + 'max_upload_size': 'str', + 'max_upload_time': 'int' + } + + attribute_map = { + 'allowed_extensions': 'allowed_extensions', + 'max_filesize': 'max_filesize', + 'max_upload_size': 'max_upload_size', + 'max_upload_time': 'max_upload_time' + } + + def __init__(self, allowed_extensions=None, max_filesize=None, max_upload_size=None, max_upload_time=None): # noqa: E501 + """InlineResponse2002 - a model defined in Swagger""" # noqa: E501 + self._allowed_extensions = None + self._max_filesize = None + self._max_upload_size = None + self._max_upload_time = None + self.discriminator = None + if allowed_extensions is not None: + self.allowed_extensions = allowed_extensions + if max_filesize is not None: + self.max_filesize = max_filesize + if max_upload_size is not None: + self.max_upload_size = max_upload_size + if max_upload_time is not None: + self.max_upload_time = max_upload_time + + @property + def allowed_extensions(self): + """Gets the allowed_extensions of this InlineResponse2002. # noqa: E501 + + allowlist of file extensions accepted for import # noqa: E501 + + :return: The allowed_extensions of this InlineResponse2002. # noqa: E501 + :rtype: list[str] + """ + return self._allowed_extensions + + @allowed_extensions.setter + def allowed_extensions(self, allowed_extensions): + """Sets the allowed_extensions of this InlineResponse2002. + + allowlist of file extensions accepted for import # noqa: E501 + + :param allowed_extensions: The allowed_extensions of this InlineResponse2002. # noqa: E501 + :type: list[str] + """ + + self._allowed_extensions = allowed_extensions + + @property + def max_filesize(self): + """Gets the max_filesize of this InlineResponse2002. # noqa: E501 + + maximum size of an uploaded file in bytes # noqa: E501 + + :return: The max_filesize of this InlineResponse2002. # noqa: E501 + :rtype: int + """ + return self._max_filesize + + @max_filesize.setter + def max_filesize(self, max_filesize): + """Sets the max_filesize of this InlineResponse2002. + + maximum size of an uploaded file in bytes # noqa: E501 + + :param max_filesize: The max_filesize of this InlineResponse2002. # noqa: E501 + :type: int + """ + + self._max_filesize = max_filesize + + @property + def max_upload_size(self): + """Gets the max_upload_size of this InlineResponse2002. # noqa: E501 + + value of MAX_UPLOAD_SIZE env parameter # noqa: E501 + + :return: The max_upload_size of this InlineResponse2002. # noqa: E501 + :rtype: str + """ + return self._max_upload_size + + @max_upload_size.setter + def max_upload_size(self, max_upload_size): + """Sets the max_upload_size of this InlineResponse2002. + + value of MAX_UPLOAD_SIZE env parameter # noqa: E501 + + :param max_upload_size: The max_upload_size of this InlineResponse2002. # noqa: E501 + :type: str + """ + + self._max_upload_size = max_upload_size + + @property + def max_upload_time(self): + """Gets the max_upload_time of this InlineResponse2002. # noqa: E501 + + value of MAX_UPLOAD_TIME env parameter # noqa: E501 + + :return: The max_upload_time of this InlineResponse2002. # noqa: E501 + :rtype: int + """ + return self._max_upload_time + + @max_upload_time.setter + def max_upload_time(self, max_upload_time): + """Sets the max_upload_time of this InlineResponse2002. + + value of MAX_UPLOAD_TIME env parameter # noqa: E501 + + :param max_upload_time: The max_upload_time of this InlineResponse2002. # noqa: E501 + :type: int + """ + + self._max_upload_time = max_upload_time + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(InlineResponse2002, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2002): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/inline_response2003.py b/vendor/elabapi-python/elabapi_python/models/inline_response2003.py new file mode 100644 index 0000000..0d79c2e --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/inline_response2003.py @@ -0,0 +1,162 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class InlineResponse2003(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'users_id': 'int', + 'tags_id': 'int', + 'tag': 'str' + } + + attribute_map = { + 'users_id': 'users_id', + 'tags_id': 'tags_id', + 'tag': 'tag' + } + + def __init__(self, users_id=None, tags_id=None, tag=None): # noqa: E501 + """InlineResponse2003 - a model defined in Swagger""" # noqa: E501 + self._users_id = None + self._tags_id = None + self._tag = None + self.discriminator = None + if users_id is not None: + self.users_id = users_id + if tags_id is not None: + self.tags_id = tags_id + if tag is not None: + self.tag = tag + + @property + def users_id(self): + """Gets the users_id of this InlineResponse2003. # noqa: E501 + + + :return: The users_id of this InlineResponse2003. # noqa: E501 + :rtype: int + """ + return self._users_id + + @users_id.setter + def users_id(self, users_id): + """Sets the users_id of this InlineResponse2003. + + + :param users_id: The users_id of this InlineResponse2003. # noqa: E501 + :type: int + """ + + self._users_id = users_id + + @property + def tags_id(self): + """Gets the tags_id of this InlineResponse2003. # noqa: E501 + + + :return: The tags_id of this InlineResponse2003. # noqa: E501 + :rtype: int + """ + return self._tags_id + + @tags_id.setter + def tags_id(self, tags_id): + """Sets the tags_id of this InlineResponse2003. + + + :param tags_id: The tags_id of this InlineResponse2003. # noqa: E501 + :type: int + """ + + self._tags_id = tags_id + + @property + def tag(self): + """Gets the tag of this InlineResponse2003. # noqa: E501 + + + :return: The tag of this InlineResponse2003. # noqa: E501 + :rtype: str + """ + return self._tag + + @tag.setter + def tag(self, tag): + """Sets the tag of this InlineResponse2003. + + + :param tag: The tag of this InlineResponse2003. # noqa: E501 + :type: str + """ + + self._tag = tag + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(InlineResponse2003, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2003): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/inline_response2004.py b/vendor/elabapi-python/elabapi_python/models/inline_response2004.py new file mode 100644 index 0000000..7440f33 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/inline_response2004.py @@ -0,0 +1,110 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class InlineResponse2004(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'query_parameters': 'InlineResponse2004QueryParameters' + } + + attribute_map = { + 'query_parameters': 'query_parameters' + } + + def __init__(self, query_parameters=None): # noqa: E501 + """InlineResponse2004 - a model defined in Swagger""" # noqa: E501 + self._query_parameters = None + self.discriminator = None + if query_parameters is not None: + self.query_parameters = query_parameters + + @property + def query_parameters(self): + """Gets the query_parameters of this InlineResponse2004. # noqa: E501 + + + :return: The query_parameters of this InlineResponse2004. # noqa: E501 + :rtype: InlineResponse2004QueryParameters + """ + return self._query_parameters + + @query_parameters.setter + def query_parameters(self, query_parameters): + """Sets the query_parameters of this InlineResponse2004. + + + :param query_parameters: The query_parameters of this InlineResponse2004. # noqa: E501 + :type: InlineResponse2004QueryParameters + """ + + self._query_parameters = query_parameters + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(InlineResponse2004, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2004): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/inline_response2004_query_parameters.py b/vendor/elabapi-python/elabapi_python/models/inline_response2004_query_parameters.py new file mode 100644 index 0000000..f33fcee --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/inline_response2004_query_parameters.py @@ -0,0 +1,136 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class InlineResponse2004QueryParameters(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'format': 'list[str]', + 'scope': 'list[str]' + } + + attribute_map = { + 'format': 'format', + 'scope': 'scope' + } + + def __init__(self, format=None, scope=None): # noqa: E501 + """InlineResponse2004QueryParameters - a model defined in Swagger""" # noqa: E501 + self._format = None + self._scope = None + self.discriminator = None + if format is not None: + self.format = format + if scope is not None: + self.scope = scope + + @property + def format(self): + """Gets the format of this InlineResponse2004QueryParameters. # noqa: E501 + + + :return: The format of this InlineResponse2004QueryParameters. # noqa: E501 + :rtype: list[str] + """ + return self._format + + @format.setter + def format(self, format): + """Sets the format of this InlineResponse2004QueryParameters. + + + :param format: The format of this InlineResponse2004QueryParameters. # noqa: E501 + :type: list[str] + """ + + self._format = format + + @property + def scope(self): + """Gets the scope of this InlineResponse2004QueryParameters. # noqa: E501 + + + :return: The scope of this InlineResponse2004QueryParameters. # noqa: E501 + :rtype: list[str] + """ + return self._scope + + @scope.setter + def scope(self, scope): + """Sets the scope of this InlineResponse2004QueryParameters. + + + :param scope: The scope of this InlineResponse2004QueryParameters. # noqa: E501 + :type: list[str] + """ + + self._scope = scope + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(InlineResponse2004QueryParameters, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2004QueryParameters): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/inline_response2005.py b/vendor/elabapi-python/elabapi_python/models/inline_response2005.py new file mode 100644 index 0000000..150fb58 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/inline_response2005.py @@ -0,0 +1,162 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class InlineResponse2005(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'name': 'str', + 'team': 'int' + } + + attribute_map = { + 'id': 'id', + 'name': 'name', + 'team': 'team' + } + + def __init__(self, id=None, name=None, team=None): # noqa: E501 + """InlineResponse2005 - a model defined in Swagger""" # noqa: E501 + self._id = None + self._name = None + self._team = None + self.discriminator = None + if id is not None: + self.id = id + if name is not None: + self.name = name + if team is not None: + self.team = team + + @property + def id(self): + """Gets the id of this InlineResponse2005. # noqa: E501 + + + :return: The id of this InlineResponse2005. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this InlineResponse2005. + + + :param id: The id of this InlineResponse2005. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def name(self): + """Gets the name of this InlineResponse2005. # noqa: E501 + + + :return: The name of this InlineResponse2005. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this InlineResponse2005. + + + :param name: The name of this InlineResponse2005. # noqa: E501 + :type: str + """ + + self._name = name + + @property + def team(self): + """Gets the team of this InlineResponse2005. # noqa: E501 + + + :return: The team of this InlineResponse2005. # noqa: E501 + :rtype: int + """ + return self._team + + @team.setter + def team(self, team): + """Sets the team of this InlineResponse2005. + + + :param team: The team of this InlineResponse2005. # noqa: E501 + :type: int + """ + + self._team = team + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(InlineResponse2005, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2005): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/inline_response2006.py b/vendor/elabapi-python/elabapi_python/models/inline_response2006.py new file mode 100644 index 0000000..014fcee --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/inline_response2006.py @@ -0,0 +1,344 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class InlineResponse2006(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'real_name': 'str', + 'long_name': 'str', + 'created_at': 'datetime', + 'filesize': 'int', + 'type': 'str', + 'comment': 'str', + 'entity_id': 'int', + 'entity_title': 'str', + 'page': 'str' + } + + attribute_map = { + 'id': 'id', + 'real_name': 'real_name', + 'long_name': 'long_name', + 'created_at': 'created_at', + 'filesize': 'filesize', + 'type': 'type', + 'comment': 'comment', + 'entity_id': 'entity_id', + 'entity_title': 'entity_title', + 'page': 'page' + } + + def __init__(self, id=None, real_name=None, long_name=None, created_at=None, filesize=None, type=None, comment=None, entity_id=None, entity_title=None, page=None): # noqa: E501 + """InlineResponse2006 - a model defined in Swagger""" # noqa: E501 + self._id = None + self._real_name = None + self._long_name = None + self._created_at = None + self._filesize = None + self._type = None + self._comment = None + self._entity_id = None + self._entity_title = None + self._page = None + self.discriminator = None + if id is not None: + self.id = id + if real_name is not None: + self.real_name = real_name + if long_name is not None: + self.long_name = long_name + if created_at is not None: + self.created_at = created_at + if filesize is not None: + self.filesize = filesize + if type is not None: + self.type = type + if comment is not None: + self.comment = comment + if entity_id is not None: + self.entity_id = entity_id + if entity_title is not None: + self.entity_title = entity_title + if page is not None: + self.page = page + + @property + def id(self): + """Gets the id of this InlineResponse2006. # noqa: E501 + + + :return: The id of this InlineResponse2006. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this InlineResponse2006. + + + :param id: The id of this InlineResponse2006. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def real_name(self): + """Gets the real_name of this InlineResponse2006. # noqa: E501 + + + :return: The real_name of this InlineResponse2006. # noqa: E501 + :rtype: str + """ + return self._real_name + + @real_name.setter + def real_name(self, real_name): + """Sets the real_name of this InlineResponse2006. + + + :param real_name: The real_name of this InlineResponse2006. # noqa: E501 + :type: str + """ + + self._real_name = real_name + + @property + def long_name(self): + """Gets the long_name of this InlineResponse2006. # noqa: E501 + + + :return: The long_name of this InlineResponse2006. # noqa: E501 + :rtype: str + """ + return self._long_name + + @long_name.setter + def long_name(self, long_name): + """Sets the long_name of this InlineResponse2006. + + + :param long_name: The long_name of this InlineResponse2006. # noqa: E501 + :type: str + """ + + self._long_name = long_name + + @property + def created_at(self): + """Gets the created_at of this InlineResponse2006. # noqa: E501 + + + :return: The created_at of this InlineResponse2006. # noqa: E501 + :rtype: datetime + """ + return self._created_at + + @created_at.setter + def created_at(self, created_at): + """Sets the created_at of this InlineResponse2006. + + + :param created_at: The created_at of this InlineResponse2006. # noqa: E501 + :type: datetime + """ + + self._created_at = created_at + + @property + def filesize(self): + """Gets the filesize of this InlineResponse2006. # noqa: E501 + + + :return: The filesize of this InlineResponse2006. # noqa: E501 + :rtype: int + """ + return self._filesize + + @filesize.setter + def filesize(self, filesize): + """Sets the filesize of this InlineResponse2006. + + + :param filesize: The filesize of this InlineResponse2006. # noqa: E501 + :type: int + """ + + self._filesize = filesize + + @property + def type(self): + """Gets the type of this InlineResponse2006. # noqa: E501 + + + :return: The type of this InlineResponse2006. # noqa: E501 + :rtype: str + """ + return self._type + + @type.setter + def type(self, type): + """Sets the type of this InlineResponse2006. + + + :param type: The type of this InlineResponse2006. # noqa: E501 + :type: str + """ + + self._type = type + + @property + def comment(self): + """Gets the comment of this InlineResponse2006. # noqa: E501 + + + :return: The comment of this InlineResponse2006. # noqa: E501 + :rtype: str + """ + return self._comment + + @comment.setter + def comment(self, comment): + """Sets the comment of this InlineResponse2006. + + + :param comment: The comment of this InlineResponse2006. # noqa: E501 + :type: str + """ + + self._comment = comment + + @property + def entity_id(self): + """Gets the entity_id of this InlineResponse2006. # noqa: E501 + + + :return: The entity_id of this InlineResponse2006. # noqa: E501 + :rtype: int + """ + return self._entity_id + + @entity_id.setter + def entity_id(self, entity_id): + """Sets the entity_id of this InlineResponse2006. + + + :param entity_id: The entity_id of this InlineResponse2006. # noqa: E501 + :type: int + """ + + self._entity_id = entity_id + + @property + def entity_title(self): + """Gets the entity_title of this InlineResponse2006. # noqa: E501 + + + :return: The entity_title of this InlineResponse2006. # noqa: E501 + :rtype: str + """ + return self._entity_title + + @entity_title.setter + def entity_title(self, entity_title): + """Sets the entity_title of this InlineResponse2006. + + + :param entity_title: The entity_title of this InlineResponse2006. # noqa: E501 + :type: str + """ + + self._entity_title = entity_title + + @property + def page(self): + """Gets the page of this InlineResponse2006. # noqa: E501 + + + :return: The page of this InlineResponse2006. # noqa: E501 + :rtype: str + """ + return self._page + + @page.setter + def page(self, page): + """Sets the page of this InlineResponse2006. + + + :param page: The page of this InlineResponse2006. # noqa: E501 + :type: str + """ + + self._page = page + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(InlineResponse2006, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2006): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/inline_response2007.py b/vendor/elabapi-python/elabapi_python/models/inline_response2007.py new file mode 100644 index 0000000..ed61c51 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/inline_response2007.py @@ -0,0 +1,240 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class InlineResponse2007(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'category': 'int', + 'body': 'object', + 'is_ack': 'int', + 'created_at': 'str', + 'userid': 'int' + } + + attribute_map = { + 'id': 'id', + 'category': 'category', + 'body': 'body', + 'is_ack': 'is_ack', + 'created_at': 'created_at', + 'userid': 'userid' + } + + def __init__(self, id=None, category=None, body=None, is_ack=None, created_at=None, userid=None): # noqa: E501 + """InlineResponse2007 - a model defined in Swagger""" # noqa: E501 + self._id = None + self._category = None + self._body = None + self._is_ack = None + self._created_at = None + self._userid = None + self.discriminator = None + if id is not None: + self.id = id + if category is not None: + self.category = category + if body is not None: + self.body = body + if is_ack is not None: + self.is_ack = is_ack + if created_at is not None: + self.created_at = created_at + if userid is not None: + self.userid = userid + + @property + def id(self): + """Gets the id of this InlineResponse2007. # noqa: E501 + + + :return: The id of this InlineResponse2007. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this InlineResponse2007. + + + :param id: The id of this InlineResponse2007. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def category(self): + """Gets the category of this InlineResponse2007. # noqa: E501 + + + :return: The category of this InlineResponse2007. # noqa: E501 + :rtype: int + """ + return self._category + + @category.setter + def category(self, category): + """Sets the category of this InlineResponse2007. + + + :param category: The category of this InlineResponse2007. # noqa: E501 + :type: int + """ + + self._category = category + + @property + def body(self): + """Gets the body of this InlineResponse2007. # noqa: E501 + + + :return: The body of this InlineResponse2007. # noqa: E501 + :rtype: object + """ + return self._body + + @body.setter + def body(self, body): + """Sets the body of this InlineResponse2007. + + + :param body: The body of this InlineResponse2007. # noqa: E501 + :type: object + """ + + self._body = body + + @property + def is_ack(self): + """Gets the is_ack of this InlineResponse2007. # noqa: E501 + + + :return: The is_ack of this InlineResponse2007. # noqa: E501 + :rtype: int + """ + return self._is_ack + + @is_ack.setter + def is_ack(self, is_ack): + """Sets the is_ack of this InlineResponse2007. + + + :param is_ack: The is_ack of this InlineResponse2007. # noqa: E501 + :type: int + """ + + self._is_ack = is_ack + + @property + def created_at(self): + """Gets the created_at of this InlineResponse2007. # noqa: E501 + + + :return: The created_at of this InlineResponse2007. # noqa: E501 + :rtype: str + """ + return self._created_at + + @created_at.setter + def created_at(self, created_at): + """Sets the created_at of this InlineResponse2007. + + + :param created_at: The created_at of this InlineResponse2007. # noqa: E501 + :type: str + """ + + self._created_at = created_at + + @property + def userid(self): + """Gets the userid of this InlineResponse2007. # noqa: E501 + + + :return: The userid of this InlineResponse2007. # noqa: E501 + :rtype: int + """ + return self._userid + + @userid.setter + def userid(self, userid): + """Sets the userid of this InlineResponse2007. + + + :param userid: The userid of this InlineResponse2007. # noqa: E501 + :type: int + """ + + self._userid = userid + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(InlineResponse2007, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2007): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/inline_response2008.py b/vendor/elabapi-python/elabapi_python/models/inline_response2008.py new file mode 100644 index 0000000..aa8828d --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/inline_response2008.py @@ -0,0 +1,188 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class InlineResponse2008(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'content_type': 'int', + 'created_at': 'str', + 'fullname': 'str' + } + + attribute_map = { + 'id': 'id', + 'content_type': 'content_type', + 'created_at': 'created_at', + 'fullname': 'fullname' + } + + def __init__(self, id=None, content_type=None, created_at=None, fullname=None): # noqa: E501 + """InlineResponse2008 - a model defined in Swagger""" # noqa: E501 + self._id = None + self._content_type = None + self._created_at = None + self._fullname = None + self.discriminator = None + if id is not None: + self.id = id + if content_type is not None: + self.content_type = content_type + if created_at is not None: + self.created_at = created_at + if fullname is not None: + self.fullname = fullname + + @property + def id(self): + """Gets the id of this InlineResponse2008. # noqa: E501 + + + :return: The id of this InlineResponse2008. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this InlineResponse2008. + + + :param id: The id of this InlineResponse2008. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def content_type(self): + """Gets the content_type of this InlineResponse2008. # noqa: E501 + + + :return: The content_type of this InlineResponse2008. # noqa: E501 + :rtype: int + """ + return self._content_type + + @content_type.setter + def content_type(self, content_type): + """Sets the content_type of this InlineResponse2008. + + + :param content_type: The content_type of this InlineResponse2008. # noqa: E501 + :type: int + """ + + self._content_type = content_type + + @property + def created_at(self): + """Gets the created_at of this InlineResponse2008. # noqa: E501 + + + :return: The created_at of this InlineResponse2008. # noqa: E501 + :rtype: str + """ + return self._created_at + + @created_at.setter + def created_at(self, created_at): + """Sets the created_at of this InlineResponse2008. + + + :param created_at: The created_at of this InlineResponse2008. # noqa: E501 + :type: str + """ + + self._created_at = created_at + + @property + def fullname(self): + """Gets the fullname of this InlineResponse2008. # noqa: E501 + + + :return: The fullname of this InlineResponse2008. # noqa: E501 + :rtype: str + """ + return self._fullname + + @fullname.setter + def fullname(self, fullname): + """Sets the fullname of this InlineResponse2008. + + + :param fullname: The fullname of this InlineResponse2008. # noqa: E501 + :type: str + """ + + self._fullname = fullname + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(InlineResponse2008, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2008): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/inline_response2009.py b/vendor/elabapi-python/elabapi_python/models/inline_response2009.py new file mode 100644 index 0000000..7bb2543 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/inline_response2009.py @@ -0,0 +1,84 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class InlineResponse2009(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + } + + attribute_map = { + } + + def __init__(self): # noqa: E501 + """InlineResponse2009 - a model defined in Swagger""" # noqa: E501 + self.discriminator = None + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(InlineResponse2009, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2009): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/inline_response2009_embedded.py b/vendor/elabapi-python/elabapi_python/models/inline_response2009_embedded.py new file mode 100644 index 0000000..aa1ff44 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/inline_response2009_embedded.py @@ -0,0 +1,110 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class InlineResponse2009Embedded(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'entries': 'list[InlineResponse2009EmbeddedEntries]' + } + + attribute_map = { + 'entries': 'entries' + } + + def __init__(self, entries=None): # noqa: E501 + """InlineResponse2009Embedded - a model defined in Swagger""" # noqa: E501 + self._entries = None + self.discriminator = None + if entries is not None: + self.entries = entries + + @property + def entries(self): + """Gets the entries of this InlineResponse2009Embedded. # noqa: E501 + + + :return: The entries of this InlineResponse2009Embedded. # noqa: E501 + :rtype: list[InlineResponse2009EmbeddedEntries] + """ + return self._entries + + @entries.setter + def entries(self, entries): + """Sets the entries of this InlineResponse2009Embedded. + + + :param entries: The entries of this InlineResponse2009Embedded. # noqa: E501 + :type: list[InlineResponse2009EmbeddedEntries] + """ + + self._entries = entries + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(InlineResponse2009Embedded, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2009Embedded): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/inline_response2009_embedded_entries.py b/vendor/elabapi-python/elabapi_python/models/inline_response2009_embedded_entries.py new file mode 100644 index 0000000..3ba6f1d --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/inline_response2009_embedded_entries.py @@ -0,0 +1,169 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class InlineResponse2009EmbeddedEntries(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'value': 'str', + 'display': 'str', + 'type': 'str' + } + + attribute_map = { + 'value': 'value', + 'display': 'display', + 'type': 'type' + } + + def __init__(self, value=None, display=None, type=None): # noqa: E501 + """InlineResponse2009EmbeddedEntries - a model defined in Swagger""" # noqa: E501 + self._value = None + self._display = None + self._type = None + self.discriminator = None + self.value = value + self.display = display + self.type = type + + @property + def value(self): + """Gets the value of this InlineResponse2009EmbeddedEntries. # noqa: E501 + + Internal type value. # noqa: E501 + + :return: The value of this InlineResponse2009EmbeddedEntries. # noqa: E501 + :rtype: str + """ + return self._value + + @value.setter + def value(self, value): + """Sets the value of this InlineResponse2009EmbeddedEntries. + + Internal type value. # noqa: E501 + + :param value: The value of this InlineResponse2009EmbeddedEntries. # noqa: E501 + :type: str + """ + if value is None: + raise ValueError("Invalid value for `value`, must not be `None`") # noqa: E501 + + self._value = value + + @property + def display(self): + """Gets the display of this InlineResponse2009EmbeddedEntries. # noqa: E501 + + Human-readable label. # noqa: E501 + + :return: The display of this InlineResponse2009EmbeddedEntries. # noqa: E501 + :rtype: str + """ + return self._display + + @display.setter + def display(self, display): + """Sets the display of this InlineResponse2009EmbeddedEntries. + + Human-readable label. # noqa: E501 + + :param display: The display of this InlineResponse2009EmbeddedEntries. # noqa: E501 + :type: str + """ + if display is None: + raise ValueError("Invalid value for `display`, must not be `None`") # noqa: E501 + + self._display = display + + @property + def type(self): + """Gets the type of this InlineResponse2009EmbeddedEntries. # noqa: E501 + + + :return: The type of this InlineResponse2009EmbeddedEntries. # noqa: E501 + :rtype: str + """ + return self._type + + @type.setter + def type(self, type): + """Sets the type of this InlineResponse2009EmbeddedEntries. + + + :param type: The type of this InlineResponse2009EmbeddedEntries. # noqa: E501 + :type: str + """ + if type is None: + raise ValueError("Invalid value for `type`, must not be `None`") # noqa: E501 + + self._type = type + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(InlineResponse2009EmbeddedEntries, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2009EmbeddedEntries): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/instance_body.py b/vendor/elabapi-python/elabapi_python/models/instance_body.py new file mode 100644 index 0000000..cc35494 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/instance_body.py @@ -0,0 +1,84 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class InstanceBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + } + + attribute_map = { + } + + def __init__(self): # noqa: E501 + """InstanceBody - a model defined in Swagger""" # noqa: E501 + self.discriminator = None + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(InstanceBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InstanceBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/item.py b/vendor/elabapi-python/elabapi_python/models/item.py new file mode 100644 index 0000000..da108b2 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/item.py @@ -0,0 +1,450 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six +from elabapi_python.models.entity import Entity # noqa: F401,E501 + +class Item(Entity): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'is_bookable': 'int', + 'canbook_base': 'float', + 'canbook': 'str', + 'book_max_minutes': 'int', + 'book_max_slots': 'int', + 'book_can_overlap': 'int', + 'book_users_can_in_past': 'int', + 'book_is_cancellable': 'int', + 'book_cancel_minutes': 'int', + 'booking_window_days': 'int', + 'booking_hourly_rate_notax': 'float', + 'booking_hourly_rate_tax': 'float', + 'booking_hourly_rate_currency': 'int' + } + if hasattr(Entity, "swagger_types"): + swagger_types.update(Entity.swagger_types) + + attribute_map = { + 'is_bookable': 'is_bookable', + 'canbook_base': 'canbook_base', + 'canbook': 'canbook', + 'book_max_minutes': 'book_max_minutes', + 'book_max_slots': 'book_max_slots', + 'book_can_overlap': 'book_can_overlap', + 'book_users_can_in_past': 'book_users_can_in_past', + 'book_is_cancellable': 'book_is_cancellable', + 'book_cancel_minutes': 'book_cancel_minutes', + 'booking_window_days': 'booking_window_days', + 'booking_hourly_rate_notax': 'booking_hourly_rate_notax', + 'booking_hourly_rate_tax': 'booking_hourly_rate_tax', + 'booking_hourly_rate_currency': 'booking_hourly_rate_currency' + } + if hasattr(Entity, "attribute_map"): + attribute_map.update(Entity.attribute_map) + + def __init__(self, is_bookable=None, canbook_base=None, canbook=None, book_max_minutes=None, book_max_slots=None, book_can_overlap=None, book_users_can_in_past=None, book_is_cancellable=None, book_cancel_minutes=None, booking_window_days=None, booking_hourly_rate_notax=None, booking_hourly_rate_tax=None, booking_hourly_rate_currency=None, *args, **kwargs): # noqa: E501 + """Item - a model defined in Swagger""" # noqa: E501 + self._is_bookable = None + self._canbook_base = None + self._canbook = None + self._book_max_minutes = None + self._book_max_slots = None + self._book_can_overlap = None + self._book_users_can_in_past = None + self._book_is_cancellable = None + self._book_cancel_minutes = None + self._booking_window_days = None + self._booking_hourly_rate_notax = None + self._booking_hourly_rate_tax = None + self._booking_hourly_rate_currency = None + self.discriminator = None + if is_bookable is not None: + self.is_bookable = is_bookable + if canbook_base is not None: + self.canbook_base = canbook_base + if canbook is not None: + self.canbook = canbook + if book_max_minutes is not None: + self.book_max_minutes = book_max_minutes + if book_max_slots is not None: + self.book_max_slots = book_max_slots + if book_can_overlap is not None: + self.book_can_overlap = book_can_overlap + if book_users_can_in_past is not None: + self.book_users_can_in_past = book_users_can_in_past + if book_is_cancellable is not None: + self.book_is_cancellable = book_is_cancellable + if book_cancel_minutes is not None: + self.book_cancel_minutes = book_cancel_minutes + if booking_window_days is not None: + self.booking_window_days = booking_window_days + if booking_hourly_rate_notax is not None: + self.booking_hourly_rate_notax = booking_hourly_rate_notax + if booking_hourly_rate_tax is not None: + self.booking_hourly_rate_tax = booking_hourly_rate_tax + if booking_hourly_rate_currency is not None: + self.booking_hourly_rate_currency = booking_hourly_rate_currency + Entity.__init__(self, *args, **kwargs) + + @property + def is_bookable(self): + """Gets the is_bookable of this Item. # noqa: E501 + + + :return: The is_bookable of this Item. # noqa: E501 + :rtype: int + """ + return self._is_bookable + + @is_bookable.setter + def is_bookable(self, is_bookable): + """Sets the is_bookable of this Item. + + + :param is_bookable: The is_bookable of this Item. # noqa: E501 + :type: int + """ + + self._is_bookable = is_bookable + + @property + def canbook_base(self): + """Gets the canbook_base of this Item. # noqa: E501 + + Base permission for booking access: - 10: Owner only - 20: Owner + Admins - 30: Team members - 40: Everyone with an account - 50: Everyone including anonymous users # noqa: E501 + + :return: The canbook_base of this Item. # noqa: E501 + :rtype: float + """ + return self._canbook_base + + @canbook_base.setter + def canbook_base(self, canbook_base): + """Sets the canbook_base of this Item. + + Base permission for booking access: - 10: Owner only - 20: Owner + Admins - 30: Team members - 40: Everyone with an account - 50: Everyone including anonymous users # noqa: E501 + + :param canbook_base: The canbook_base of this Item. # noqa: E501 + :type: float + """ + allowed_values = [10, 20, 30, 40, 50] # noqa: E501 + if canbook_base not in allowed_values: + raise ValueError( + "Invalid value for `canbook_base` ({0}), must be one of {1}" # noqa: E501 + .format(canbook_base, allowed_values) + ) + + self._canbook_base = canbook_base + + @property + def canbook(self): + """Gets the canbook of this Item. # noqa: E501 + + + :return: The canbook of this Item. # noqa: E501 + :rtype: str + """ + return self._canbook + + @canbook.setter + def canbook(self, canbook): + """Sets the canbook of this Item. + + + :param canbook: The canbook of this Item. # noqa: E501 + :type: str + """ + + self._canbook = canbook + + @property + def book_max_minutes(self): + """Gets the book_max_minutes of this Item. # noqa: E501 + + + :return: The book_max_minutes of this Item. # noqa: E501 + :rtype: int + """ + return self._book_max_minutes + + @book_max_minutes.setter + def book_max_minutes(self, book_max_minutes): + """Sets the book_max_minutes of this Item. + + + :param book_max_minutes: The book_max_minutes of this Item. # noqa: E501 + :type: int + """ + + self._book_max_minutes = book_max_minutes + + @property + def book_max_slots(self): + """Gets the book_max_slots of this Item. # noqa: E501 + + + :return: The book_max_slots of this Item. # noqa: E501 + :rtype: int + """ + return self._book_max_slots + + @book_max_slots.setter + def book_max_slots(self, book_max_slots): + """Sets the book_max_slots of this Item. + + + :param book_max_slots: The book_max_slots of this Item. # noqa: E501 + :type: int + """ + + self._book_max_slots = book_max_slots + + @property + def book_can_overlap(self): + """Gets the book_can_overlap of this Item. # noqa: E501 + + + :return: The book_can_overlap of this Item. # noqa: E501 + :rtype: int + """ + return self._book_can_overlap + + @book_can_overlap.setter + def book_can_overlap(self, book_can_overlap): + """Sets the book_can_overlap of this Item. + + + :param book_can_overlap: The book_can_overlap of this Item. # noqa: E501 + :type: int + """ + + self._book_can_overlap = book_can_overlap + + @property + def book_users_can_in_past(self): + """Gets the book_users_can_in_past of this Item. # noqa: E501 + + + :return: The book_users_can_in_past of this Item. # noqa: E501 + :rtype: int + """ + return self._book_users_can_in_past + + @book_users_can_in_past.setter + def book_users_can_in_past(self, book_users_can_in_past): + """Sets the book_users_can_in_past of this Item. + + + :param book_users_can_in_past: The book_users_can_in_past of this Item. # noqa: E501 + :type: int + """ + + self._book_users_can_in_past = book_users_can_in_past + + @property + def book_is_cancellable(self): + """Gets the book_is_cancellable of this Item. # noqa: E501 + + + :return: The book_is_cancellable of this Item. # noqa: E501 + :rtype: int + """ + return self._book_is_cancellable + + @book_is_cancellable.setter + def book_is_cancellable(self, book_is_cancellable): + """Sets the book_is_cancellable of this Item. + + + :param book_is_cancellable: The book_is_cancellable of this Item. # noqa: E501 + :type: int + """ + + self._book_is_cancellable = book_is_cancellable + + @property + def book_cancel_minutes(self): + """Gets the book_cancel_minutes of this Item. # noqa: E501 + + + :return: The book_cancel_minutes of this Item. # noqa: E501 + :rtype: int + """ + return self._book_cancel_minutes + + @book_cancel_minutes.setter + def book_cancel_minutes(self, book_cancel_minutes): + """Sets the book_cancel_minutes of this Item. + + + :param book_cancel_minutes: The book_cancel_minutes of this Item. # noqa: E501 + :type: int + """ + + self._book_cancel_minutes = book_cancel_minutes + + @property + def booking_window_days(self): + """Gets the booking_window_days of this Item. # noqa: E501 + + How many days in advance users can book an item. 0 means no limit. # noqa: E501 + + :return: The booking_window_days of this Item. # noqa: E501 + :rtype: int + """ + return self._booking_window_days + + @booking_window_days.setter + def booking_window_days(self, booking_window_days): + """Sets the booking_window_days of this Item. + + How many days in advance users can book an item. 0 means no limit. # noqa: E501 + + :param booking_window_days: The booking_window_days of this Item. # noqa: E501 + :type: int + """ + + self._booking_window_days = booking_window_days + + @property + def booking_hourly_rate_notax(self): + """Gets the booking_hourly_rate_notax of this Item. # noqa: E501 + + The hourly rate of booked resource, without taxes. # noqa: E501 + + :return: The booking_hourly_rate_notax of this Item. # noqa: E501 + :rtype: float + """ + return self._booking_hourly_rate_notax + + @booking_hourly_rate_notax.setter + def booking_hourly_rate_notax(self, booking_hourly_rate_notax): + """Sets the booking_hourly_rate_notax of this Item. + + The hourly rate of booked resource, without taxes. # noqa: E501 + + :param booking_hourly_rate_notax: The booking_hourly_rate_notax of this Item. # noqa: E501 + :type: float + """ + + self._booking_hourly_rate_notax = booking_hourly_rate_notax + + @property + def booking_hourly_rate_tax(self): + """Gets the booking_hourly_rate_tax of this Item. # noqa: E501 + + The hourly rate of booked resource, with taxes. # noqa: E501 + + :return: The booking_hourly_rate_tax of this Item. # noqa: E501 + :rtype: float + """ + return self._booking_hourly_rate_tax + + @booking_hourly_rate_tax.setter + def booking_hourly_rate_tax(self, booking_hourly_rate_tax): + """Sets the booking_hourly_rate_tax of this Item. + + The hourly rate of booked resource, with taxes. # noqa: E501 + + :param booking_hourly_rate_tax: The booking_hourly_rate_tax of this Item. # noqa: E501 + :type: float + """ + + self._booking_hourly_rate_tax = booking_hourly_rate_tax + + @property + def booking_hourly_rate_currency(self): + """Gets the booking_hourly_rate_currency of this Item. # noqa: E501 + + The currency of the hourly rate: - 0: CAD - 1: CHF - 2: CNY - 3: DKK - 4: EUR - 5: GBP - 6: JPY - 7: USD - 8: SEK - 9: NOK # noqa: E501 + + :return: The booking_hourly_rate_currency of this Item. # noqa: E501 + :rtype: int + """ + return self._booking_hourly_rate_currency + + @booking_hourly_rate_currency.setter + def booking_hourly_rate_currency(self, booking_hourly_rate_currency): + """Sets the booking_hourly_rate_currency of this Item. + + The currency of the hourly rate: - 0: CAD - 1: CHF - 2: CNY - 3: DKK - 4: EUR - 5: GBP - 6: JPY - 7: USD - 8: SEK - 9: NOK # noqa: E501 + + :param booking_hourly_rate_currency: The booking_hourly_rate_currency of this Item. # noqa: E501 + :type: int + """ + allowed_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # noqa: E501 + if booking_hourly_rate_currency not in allowed_values: + raise ValueError( + "Invalid value for `booking_hourly_rate_currency` ({0}), must be one of {1}" # noqa: E501 + .format(booking_hourly_rate_currency, allowed_values) + ) + + self._booking_hourly_rate_currency = booking_hourly_rate_currency + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Item, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Item): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/item_editable.py b/vendor/elabapi-python/elabapi_python/models/item_editable.py new file mode 100644 index 0000000..9e66c79 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/item_editable.py @@ -0,0 +1,444 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class ItemEditable(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'is_bookable': 'int', + 'canbook_base': 'float', + 'canbook': 'str', + 'book_max_minutes': 'int', + 'book_max_slots': 'int', + 'book_can_overlap': 'int', + 'book_users_can_in_past': 'int', + 'book_is_cancellable': 'int', + 'book_cancel_minutes': 'int', + 'booking_window_days': 'int', + 'booking_hourly_rate_notax': 'float', + 'booking_hourly_rate_tax': 'float', + 'booking_hourly_rate_currency': 'int' + } + + attribute_map = { + 'is_bookable': 'is_bookable', + 'canbook_base': 'canbook_base', + 'canbook': 'canbook', + 'book_max_minutes': 'book_max_minutes', + 'book_max_slots': 'book_max_slots', + 'book_can_overlap': 'book_can_overlap', + 'book_users_can_in_past': 'book_users_can_in_past', + 'book_is_cancellable': 'book_is_cancellable', + 'book_cancel_minutes': 'book_cancel_minutes', + 'booking_window_days': 'booking_window_days', + 'booking_hourly_rate_notax': 'booking_hourly_rate_notax', + 'booking_hourly_rate_tax': 'booking_hourly_rate_tax', + 'booking_hourly_rate_currency': 'booking_hourly_rate_currency' + } + + def __init__(self, is_bookable=None, canbook_base=None, canbook=None, book_max_minutes=None, book_max_slots=None, book_can_overlap=None, book_users_can_in_past=None, book_is_cancellable=None, book_cancel_minutes=None, booking_window_days=None, booking_hourly_rate_notax=None, booking_hourly_rate_tax=None, booking_hourly_rate_currency=None): # noqa: E501 + """ItemEditable - a model defined in Swagger""" # noqa: E501 + self._is_bookable = None + self._canbook_base = None + self._canbook = None + self._book_max_minutes = None + self._book_max_slots = None + self._book_can_overlap = None + self._book_users_can_in_past = None + self._book_is_cancellable = None + self._book_cancel_minutes = None + self._booking_window_days = None + self._booking_hourly_rate_notax = None + self._booking_hourly_rate_tax = None + self._booking_hourly_rate_currency = None + self.discriminator = None + if is_bookable is not None: + self.is_bookable = is_bookable + if canbook_base is not None: + self.canbook_base = canbook_base + if canbook is not None: + self.canbook = canbook + if book_max_minutes is not None: + self.book_max_minutes = book_max_minutes + if book_max_slots is not None: + self.book_max_slots = book_max_slots + if book_can_overlap is not None: + self.book_can_overlap = book_can_overlap + if book_users_can_in_past is not None: + self.book_users_can_in_past = book_users_can_in_past + if book_is_cancellable is not None: + self.book_is_cancellable = book_is_cancellable + if book_cancel_minutes is not None: + self.book_cancel_minutes = book_cancel_minutes + if booking_window_days is not None: + self.booking_window_days = booking_window_days + if booking_hourly_rate_notax is not None: + self.booking_hourly_rate_notax = booking_hourly_rate_notax + if booking_hourly_rate_tax is not None: + self.booking_hourly_rate_tax = booking_hourly_rate_tax + if booking_hourly_rate_currency is not None: + self.booking_hourly_rate_currency = booking_hourly_rate_currency + + @property + def is_bookable(self): + """Gets the is_bookable of this ItemEditable. # noqa: E501 + + + :return: The is_bookable of this ItemEditable. # noqa: E501 + :rtype: int + """ + return self._is_bookable + + @is_bookable.setter + def is_bookable(self, is_bookable): + """Sets the is_bookable of this ItemEditable. + + + :param is_bookable: The is_bookable of this ItemEditable. # noqa: E501 + :type: int + """ + + self._is_bookable = is_bookable + + @property + def canbook_base(self): + """Gets the canbook_base of this ItemEditable. # noqa: E501 + + Base permission for booking access: - 10: Owner only - 20: Owner + Admins - 30: Team members - 40: Everyone with an account - 50: Everyone including anonymous users # noqa: E501 + + :return: The canbook_base of this ItemEditable. # noqa: E501 + :rtype: float + """ + return self._canbook_base + + @canbook_base.setter + def canbook_base(self, canbook_base): + """Sets the canbook_base of this ItemEditable. + + Base permission for booking access: - 10: Owner only - 20: Owner + Admins - 30: Team members - 40: Everyone with an account - 50: Everyone including anonymous users # noqa: E501 + + :param canbook_base: The canbook_base of this ItemEditable. # noqa: E501 + :type: float + """ + allowed_values = [10, 20, 30, 40, 50] # noqa: E501 + if canbook_base not in allowed_values: + raise ValueError( + "Invalid value for `canbook_base` ({0}), must be one of {1}" # noqa: E501 + .format(canbook_base, allowed_values) + ) + + self._canbook_base = canbook_base + + @property + def canbook(self): + """Gets the canbook of this ItemEditable. # noqa: E501 + + + :return: The canbook of this ItemEditable. # noqa: E501 + :rtype: str + """ + return self._canbook + + @canbook.setter + def canbook(self, canbook): + """Sets the canbook of this ItemEditable. + + + :param canbook: The canbook of this ItemEditable. # noqa: E501 + :type: str + """ + + self._canbook = canbook + + @property + def book_max_minutes(self): + """Gets the book_max_minutes of this ItemEditable. # noqa: E501 + + + :return: The book_max_minutes of this ItemEditable. # noqa: E501 + :rtype: int + """ + return self._book_max_minutes + + @book_max_minutes.setter + def book_max_minutes(self, book_max_minutes): + """Sets the book_max_minutes of this ItemEditable. + + + :param book_max_minutes: The book_max_minutes of this ItemEditable. # noqa: E501 + :type: int + """ + + self._book_max_minutes = book_max_minutes + + @property + def book_max_slots(self): + """Gets the book_max_slots of this ItemEditable. # noqa: E501 + + + :return: The book_max_slots of this ItemEditable. # noqa: E501 + :rtype: int + """ + return self._book_max_slots + + @book_max_slots.setter + def book_max_slots(self, book_max_slots): + """Sets the book_max_slots of this ItemEditable. + + + :param book_max_slots: The book_max_slots of this ItemEditable. # noqa: E501 + :type: int + """ + + self._book_max_slots = book_max_slots + + @property + def book_can_overlap(self): + """Gets the book_can_overlap of this ItemEditable. # noqa: E501 + + + :return: The book_can_overlap of this ItemEditable. # noqa: E501 + :rtype: int + """ + return self._book_can_overlap + + @book_can_overlap.setter + def book_can_overlap(self, book_can_overlap): + """Sets the book_can_overlap of this ItemEditable. + + + :param book_can_overlap: The book_can_overlap of this ItemEditable. # noqa: E501 + :type: int + """ + + self._book_can_overlap = book_can_overlap + + @property + def book_users_can_in_past(self): + """Gets the book_users_can_in_past of this ItemEditable. # noqa: E501 + + + :return: The book_users_can_in_past of this ItemEditable. # noqa: E501 + :rtype: int + """ + return self._book_users_can_in_past + + @book_users_can_in_past.setter + def book_users_can_in_past(self, book_users_can_in_past): + """Sets the book_users_can_in_past of this ItemEditable. + + + :param book_users_can_in_past: The book_users_can_in_past of this ItemEditable. # noqa: E501 + :type: int + """ + + self._book_users_can_in_past = book_users_can_in_past + + @property + def book_is_cancellable(self): + """Gets the book_is_cancellable of this ItemEditable. # noqa: E501 + + + :return: The book_is_cancellable of this ItemEditable. # noqa: E501 + :rtype: int + """ + return self._book_is_cancellable + + @book_is_cancellable.setter + def book_is_cancellable(self, book_is_cancellable): + """Sets the book_is_cancellable of this ItemEditable. + + + :param book_is_cancellable: The book_is_cancellable of this ItemEditable. # noqa: E501 + :type: int + """ + + self._book_is_cancellable = book_is_cancellable + + @property + def book_cancel_minutes(self): + """Gets the book_cancel_minutes of this ItemEditable. # noqa: E501 + + + :return: The book_cancel_minutes of this ItemEditable. # noqa: E501 + :rtype: int + """ + return self._book_cancel_minutes + + @book_cancel_minutes.setter + def book_cancel_minutes(self, book_cancel_minutes): + """Sets the book_cancel_minutes of this ItemEditable. + + + :param book_cancel_minutes: The book_cancel_minutes of this ItemEditable. # noqa: E501 + :type: int + """ + + self._book_cancel_minutes = book_cancel_minutes + + @property + def booking_window_days(self): + """Gets the booking_window_days of this ItemEditable. # noqa: E501 + + How many days in advance users can book an item. 0 means no limit. # noqa: E501 + + :return: The booking_window_days of this ItemEditable. # noqa: E501 + :rtype: int + """ + return self._booking_window_days + + @booking_window_days.setter + def booking_window_days(self, booking_window_days): + """Sets the booking_window_days of this ItemEditable. + + How many days in advance users can book an item. 0 means no limit. # noqa: E501 + + :param booking_window_days: The booking_window_days of this ItemEditable. # noqa: E501 + :type: int + """ + + self._booking_window_days = booking_window_days + + @property + def booking_hourly_rate_notax(self): + """Gets the booking_hourly_rate_notax of this ItemEditable. # noqa: E501 + + The hourly rate of booked resource, without taxes. # noqa: E501 + + :return: The booking_hourly_rate_notax of this ItemEditable. # noqa: E501 + :rtype: float + """ + return self._booking_hourly_rate_notax + + @booking_hourly_rate_notax.setter + def booking_hourly_rate_notax(self, booking_hourly_rate_notax): + """Sets the booking_hourly_rate_notax of this ItemEditable. + + The hourly rate of booked resource, without taxes. # noqa: E501 + + :param booking_hourly_rate_notax: The booking_hourly_rate_notax of this ItemEditable. # noqa: E501 + :type: float + """ + + self._booking_hourly_rate_notax = booking_hourly_rate_notax + + @property + def booking_hourly_rate_tax(self): + """Gets the booking_hourly_rate_tax of this ItemEditable. # noqa: E501 + + The hourly rate of booked resource, with taxes. # noqa: E501 + + :return: The booking_hourly_rate_tax of this ItemEditable. # noqa: E501 + :rtype: float + """ + return self._booking_hourly_rate_tax + + @booking_hourly_rate_tax.setter + def booking_hourly_rate_tax(self, booking_hourly_rate_tax): + """Sets the booking_hourly_rate_tax of this ItemEditable. + + The hourly rate of booked resource, with taxes. # noqa: E501 + + :param booking_hourly_rate_tax: The booking_hourly_rate_tax of this ItemEditable. # noqa: E501 + :type: float + """ + + self._booking_hourly_rate_tax = booking_hourly_rate_tax + + @property + def booking_hourly_rate_currency(self): + """Gets the booking_hourly_rate_currency of this ItemEditable. # noqa: E501 + + The currency of the hourly rate: - 0: CAD - 1: CHF - 2: CNY - 3: DKK - 4: EUR - 5: GBP - 6: JPY - 7: USD - 8: SEK - 9: NOK # noqa: E501 + + :return: The booking_hourly_rate_currency of this ItemEditable. # noqa: E501 + :rtype: int + """ + return self._booking_hourly_rate_currency + + @booking_hourly_rate_currency.setter + def booking_hourly_rate_currency(self, booking_hourly_rate_currency): + """Sets the booking_hourly_rate_currency of this ItemEditable. + + The currency of the hourly rate: - 0: CAD - 1: CHF - 2: CNY - 3: DKK - 4: EUR - 5: GBP - 6: JPY - 7: USD - 8: SEK - 9: NOK # noqa: E501 + + :param booking_hourly_rate_currency: The booking_hourly_rate_currency of this ItemEditable. # noqa: E501 + :type: int + """ + allowed_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # noqa: E501 + if booking_hourly_rate_currency not in allowed_values: + raise ValueError( + "Invalid value for `booking_hourly_rate_currency` ({0}), must be one of {1}" # noqa: E501 + .format(booking_hourly_rate_currency, allowed_values) + ) + + self._booking_hourly_rate_currency = booking_hourly_rate_currency + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(ItemEditable, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, ItemEditable): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/items_links_subid_body.py b/vendor/elabapi-python/elabapi_python/models/items_links_subid_body.py new file mode 100644 index 0000000..43adceb --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/items_links_subid_body.py @@ -0,0 +1,118 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class ItemsLinksSubidBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'action': 'str' + } + + attribute_map = { + 'action': 'action' + } + + def __init__(self, action=None): # noqa: E501 + """ItemsLinksSubidBody - a model defined in Swagger""" # noqa: E501 + self._action = None + self.discriminator = None + if action is not None: + self.action = action + + @property + def action(self): + """Gets the action of this ItemsLinksSubidBody. # noqa: E501 + + The `duplicate` action will import the links of that link (inception). # noqa: E501 + + :return: The action of this ItemsLinksSubidBody. # noqa: E501 + :rtype: str + """ + return self._action + + @action.setter + def action(self, action): + """Sets the action of this ItemsLinksSubidBody. + + The `duplicate` action will import the links of that link (inception). # noqa: E501 + + :param action: The action of this ItemsLinksSubidBody. # noqa: E501 + :type: str + """ + allowed_values = ["create", "duplicate"] # noqa: E501 + if action not in allowed_values: + raise ValueError( + "Invalid value for `action` ({0}), must be one of {1}" # noqa: E501 + .format(action, allowed_values) + ) + + self._action = action + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(ItemsLinksSubidBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, ItemsLinksSubidBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/items_types_id_body.py b/vendor/elabapi-python/elabapi_python/models/items_types_id_body.py new file mode 100644 index 0000000..6dee50e --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/items_types_id_body.py @@ -0,0 +1,84 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class ItemsTypesIdBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + } + + attribute_map = { + } + + def __init__(self): # noqa: E501 + """ItemsTypesIdBody - a model defined in Swagger""" # noqa: E501 + self.discriminator = None + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(ItemsTypesIdBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, ItemsTypesIdBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/link.py b/vendor/elabapi-python/elabapi_python/models/link.py new file mode 100644 index 0000000..944c117 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/link.py @@ -0,0 +1,422 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Link(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'entityid': 'int', + 'title': 'str', + 'is_bookable': 'int', + 'link_state': 'int', + 'category_id': 'int', + 'category_color': 'str', + 'category_title': 'str', + 'status_id': 'int', + 'status_color': 'str', + 'status_title': 'str', + 'custom_id': 'int', + 'page': 'str', + 'type': 'str' + } + + attribute_map = { + 'entityid': 'entityid', + 'title': 'title', + 'is_bookable': 'is_bookable', + 'link_state': 'link_state', + 'category_id': 'category_id', + 'category_color': 'category_color', + 'category_title': 'category_title', + 'status_id': 'status_id', + 'status_color': 'status_color', + 'status_title': 'status_title', + 'custom_id': 'custom_id', + 'page': 'page', + 'type': 'type' + } + + def __init__(self, entityid=None, title=None, is_bookable=None, link_state=None, category_id=None, category_color=None, category_title=None, status_id=None, status_color=None, status_title=None, custom_id=None, page=None, type=None): # noqa: E501 + """Link - a model defined in Swagger""" # noqa: E501 + self._entityid = None + self._title = None + self._is_bookable = None + self._link_state = None + self._category_id = None + self._category_color = None + self._category_title = None + self._status_id = None + self._status_color = None + self._status_title = None + self._custom_id = None + self._page = None + self._type = None + self.discriminator = None + if entityid is not None: + self.entityid = entityid + if title is not None: + self.title = title + if is_bookable is not None: + self.is_bookable = is_bookable + if link_state is not None: + self.link_state = link_state + if category_id is not None: + self.category_id = category_id + if category_color is not None: + self.category_color = category_color + if category_title is not None: + self.category_title = category_title + if status_id is not None: + self.status_id = status_id + if status_color is not None: + self.status_color = status_color + if status_title is not None: + self.status_title = status_title + if custom_id is not None: + self.custom_id = custom_id + if page is not None: + self.page = page + if type is not None: + self.type = type + + @property + def entityid(self): + """Gets the entityid of this Link. # noqa: E501 + + + :return: The entityid of this Link. # noqa: E501 + :rtype: int + """ + return self._entityid + + @entityid.setter + def entityid(self, entityid): + """Sets the entityid of this Link. + + + :param entityid: The entityid of this Link. # noqa: E501 + :type: int + """ + + self._entityid = entityid + + @property + def title(self): + """Gets the title of this Link. # noqa: E501 + + + :return: The title of this Link. # noqa: E501 + :rtype: str + """ + return self._title + + @title.setter + def title(self, title): + """Sets the title of this Link. + + + :param title: The title of this Link. # noqa: E501 + :type: str + """ + + self._title = title + + @property + def is_bookable(self): + """Gets the is_bookable of this Link. # noqa: E501 + + + :return: The is_bookable of this Link. # noqa: E501 + :rtype: int + """ + return self._is_bookable + + @is_bookable.setter + def is_bookable(self, is_bookable): + """Sets the is_bookable of this Link. + + + :param is_bookable: The is_bookable of this Link. # noqa: E501 + :type: int + """ + + self._is_bookable = is_bookable + + @property + def link_state(self): + """Gets the link_state of this Link. # noqa: E501 + + + :return: The link_state of this Link. # noqa: E501 + :rtype: int + """ + return self._link_state + + @link_state.setter + def link_state(self, link_state): + """Sets the link_state of this Link. + + + :param link_state: The link_state of this Link. # noqa: E501 + :type: int + """ + + self._link_state = link_state + + @property + def category_id(self): + """Gets the category_id of this Link. # noqa: E501 + + + :return: The category_id of this Link. # noqa: E501 + :rtype: int + """ + return self._category_id + + @category_id.setter + def category_id(self, category_id): + """Sets the category_id of this Link. + + + :param category_id: The category_id of this Link. # noqa: E501 + :type: int + """ + + self._category_id = category_id + + @property + def category_color(self): + """Gets the category_color of this Link. # noqa: E501 + + + :return: The category_color of this Link. # noqa: E501 + :rtype: str + """ + return self._category_color + + @category_color.setter + def category_color(self, category_color): + """Sets the category_color of this Link. + + + :param category_color: The category_color of this Link. # noqa: E501 + :type: str + """ + + self._category_color = category_color + + @property + def category_title(self): + """Gets the category_title of this Link. # noqa: E501 + + + :return: The category_title of this Link. # noqa: E501 + :rtype: str + """ + return self._category_title + + @category_title.setter + def category_title(self, category_title): + """Sets the category_title of this Link. + + + :param category_title: The category_title of this Link. # noqa: E501 + :type: str + """ + + self._category_title = category_title + + @property + def status_id(self): + """Gets the status_id of this Link. # noqa: E501 + + + :return: The status_id of this Link. # noqa: E501 + :rtype: int + """ + return self._status_id + + @status_id.setter + def status_id(self, status_id): + """Sets the status_id of this Link. + + + :param status_id: The status_id of this Link. # noqa: E501 + :type: int + """ + + self._status_id = status_id + + @property + def status_color(self): + """Gets the status_color of this Link. # noqa: E501 + + + :return: The status_color of this Link. # noqa: E501 + :rtype: str + """ + return self._status_color + + @status_color.setter + def status_color(self, status_color): + """Sets the status_color of this Link. + + + :param status_color: The status_color of this Link. # noqa: E501 + :type: str + """ + + self._status_color = status_color + + @property + def status_title(self): + """Gets the status_title of this Link. # noqa: E501 + + + :return: The status_title of this Link. # noqa: E501 + :rtype: str + """ + return self._status_title + + @status_title.setter + def status_title(self, status_title): + """Sets the status_title of this Link. + + + :param status_title: The status_title of this Link. # noqa: E501 + :type: str + """ + + self._status_title = status_title + + @property + def custom_id(self): + """Gets the custom_id of this Link. # noqa: E501 + + + :return: The custom_id of this Link. # noqa: E501 + :rtype: int + """ + return self._custom_id + + @custom_id.setter + def custom_id(self, custom_id): + """Sets the custom_id of this Link. + + + :param custom_id: The custom_id of this Link. # noqa: E501 + :type: int + """ + + self._custom_id = custom_id + + @property + def page(self): + """Gets the page of this Link. # noqa: E501 + + + :return: The page of this Link. # noqa: E501 + :rtype: str + """ + return self._page + + @page.setter + def page(self, page): + """Sets the page of this Link. + + + :param page: The page of this Link. # noqa: E501 + :type: str + """ + + self._page = page + + @property + def type(self): + """Gets the type of this Link. # noqa: E501 + + + :return: The type of this Link. # noqa: E501 + :rtype: str + """ + return self._type + + @type.setter + def type(self, type): + """Sets the type of this Link. + + + :param type: The type of this Link. # noqa: E501 + :type: str + """ + + self._type = type + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Link, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Link): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/metadata.py b/vendor/elabapi-python/elabapi_python/models/metadata.py new file mode 100644 index 0000000..d4587c2 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/metadata.py @@ -0,0 +1,138 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Metadata(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'elabftw': 'MetadataElabftw', + 'extra_fields': 'dict(str, MetadataExtraFields)' + } + + attribute_map = { + 'elabftw': 'elabftw', + 'extra_fields': 'extra_fields' + } + + def __init__(self, elabftw=None, extra_fields=None): # noqa: E501 + """Metadata - a model defined in Swagger""" # noqa: E501 + self._elabftw = None + self._extra_fields = None + self.discriminator = None + if elabftw is not None: + self.elabftw = elabftw + if extra_fields is not None: + self.extra_fields = extra_fields + + @property + def elabftw(self): + """Gets the elabftw of this Metadata. # noqa: E501 + + + :return: The elabftw of this Metadata. # noqa: E501 + :rtype: MetadataElabftw + """ + return self._elabftw + + @elabftw.setter + def elabftw(self, elabftw): + """Sets the elabftw of this Metadata. + + + :param elabftw: The elabftw of this Metadata. # noqa: E501 + :type: MetadataElabftw + """ + + self._elabftw = elabftw + + @property + def extra_fields(self): + """Gets the extra_fields of this Metadata. # noqa: E501 + + See https://doc.elabftw.net/docs/usage/metadata#extra-fields-objects # noqa: E501 + + :return: The extra_fields of this Metadata. # noqa: E501 + :rtype: dict(str, MetadataExtraFields) + """ + return self._extra_fields + + @extra_fields.setter + def extra_fields(self, extra_fields): + """Sets the extra_fields of this Metadata. + + See https://doc.elabftw.net/docs/usage/metadata#extra-fields-objects # noqa: E501 + + :param extra_fields: The extra_fields of this Metadata. # noqa: E501 + :type: dict(str, MetadataExtraFields) + """ + + self._extra_fields = extra_fields + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Metadata, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Metadata): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/metadata_elabftw.py b/vendor/elabapi-python/elabapi_python/models/metadata_elabftw.py new file mode 100644 index 0000000..31cc855 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/metadata_elabftw.py @@ -0,0 +1,112 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class MetadataElabftw(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'extra_fields_groups': 'list[MetadataElabftwExtraFieldsGroups]' + } + + attribute_map = { + 'extra_fields_groups': 'extra_fields_groups' + } + + def __init__(self, extra_fields_groups=None): # noqa: E501 + """MetadataElabftw - a model defined in Swagger""" # noqa: E501 + self._extra_fields_groups = None + self.discriminator = None + if extra_fields_groups is not None: + self.extra_fields_groups = extra_fields_groups + + @property + def extra_fields_groups(self): + """Gets the extra_fields_groups of this MetadataElabftw. # noqa: E501 + + This array stores the custom fields groups # noqa: E501 + + :return: The extra_fields_groups of this MetadataElabftw. # noqa: E501 + :rtype: list[MetadataElabftwExtraFieldsGroups] + """ + return self._extra_fields_groups + + @extra_fields_groups.setter + def extra_fields_groups(self, extra_fields_groups): + """Sets the extra_fields_groups of this MetadataElabftw. + + This array stores the custom fields groups # noqa: E501 + + :param extra_fields_groups: The extra_fields_groups of this MetadataElabftw. # noqa: E501 + :type: list[MetadataElabftwExtraFieldsGroups] + """ + + self._extra_fields_groups = extra_fields_groups + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(MetadataElabftw, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, MetadataElabftw): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/metadata_elabftw_extra_fields_groups.py b/vendor/elabapi-python/elabapi_python/models/metadata_elabftw_extra_fields_groups.py new file mode 100644 index 0000000..d5650a2 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/metadata_elabftw_extra_fields_groups.py @@ -0,0 +1,136 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class MetadataElabftwExtraFieldsGroups(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'name': 'str' + } + + attribute_map = { + 'id': 'id', + 'name': 'name' + } + + def __init__(self, id=None, name=None): # noqa: E501 + """MetadataElabftwExtraFieldsGroups - a model defined in Swagger""" # noqa: E501 + self._id = None + self._name = None + self.discriminator = None + if id is not None: + self.id = id + if name is not None: + self.name = name + + @property + def id(self): + """Gets the id of this MetadataElabftwExtraFieldsGroups. # noqa: E501 + + + :return: The id of this MetadataElabftwExtraFieldsGroups. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this MetadataElabftwExtraFieldsGroups. + + + :param id: The id of this MetadataElabftwExtraFieldsGroups. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def name(self): + """Gets the name of this MetadataElabftwExtraFieldsGroups. # noqa: E501 + + + :return: The name of this MetadataElabftwExtraFieldsGroups. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this MetadataElabftwExtraFieldsGroups. + + + :param name: The name of this MetadataElabftwExtraFieldsGroups. # noqa: E501 + :type: str + """ + + self._name = name + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(MetadataElabftwExtraFieldsGroups, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, MetadataElabftwExtraFieldsGroups): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/metadata_extra_fields.py b/vendor/elabapi-python/elabapi_python/models/metadata_extra_fields.py new file mode 100644 index 0000000..14fccdb --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/metadata_extra_fields.py @@ -0,0 +1,194 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class MetadataExtraFields(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'type': 'str', + 'value': 'str', + 'group_id': 'int', + 'description': 'str' + } + + attribute_map = { + 'type': 'type', + 'value': 'value', + 'group_id': 'group_id', + 'description': 'description' + } + + def __init__(self, type=None, value=None, group_id=None, description=None): # noqa: E501 + """MetadataExtraFields - a model defined in Swagger""" # noqa: E501 + self._type = None + self._value = None + self._group_id = None + self._description = None + self.discriminator = None + if type is not None: + self.type = type + if value is not None: + self.value = value + if group_id is not None: + self.group_id = group_id + if description is not None: + self.description = description + + @property + def type(self): + """Gets the type of this MetadataExtraFields. # noqa: E501 + + + :return: The type of this MetadataExtraFields. # noqa: E501 + :rtype: str + """ + return self._type + + @type.setter + def type(self, type): + """Sets the type of this MetadataExtraFields. + + + :param type: The type of this MetadataExtraFields. # noqa: E501 + :type: str + """ + allowed_values = ["allow_multi_values", "blank_value_on_duplicate", "checkbox", "date", "datetime-local", "description", "email", "experiments", "group_id", "items", "number", "options", "position", "radio", "required", "select", "text", "time", "unit", "url", "users"] # noqa: E501 + if type not in allowed_values: + raise ValueError( + "Invalid value for `type` ({0}), must be one of {1}" # noqa: E501 + .format(type, allowed_values) + ) + + self._type = type + + @property + def value(self): + """Gets the value of this MetadataExtraFields. # noqa: E501 + + + :return: The value of this MetadataExtraFields. # noqa: E501 + :rtype: str + """ + return self._value + + @value.setter + def value(self, value): + """Sets the value of this MetadataExtraFields. + + + :param value: The value of this MetadataExtraFields. # noqa: E501 + :type: str + """ + + self._value = value + + @property + def group_id(self): + """Gets the group_id of this MetadataExtraFields. # noqa: E501 + + + :return: The group_id of this MetadataExtraFields. # noqa: E501 + :rtype: int + """ + return self._group_id + + @group_id.setter + def group_id(self, group_id): + """Sets the group_id of this MetadataExtraFields. + + + :param group_id: The group_id of this MetadataExtraFields. # noqa: E501 + :type: int + """ + + self._group_id = group_id + + @property + def description(self): + """Gets the description of this MetadataExtraFields. # noqa: E501 + + + :return: The description of this MetadataExtraFields. # noqa: E501 + :rtype: str + """ + return self._description + + @description.setter + def description(self, description): + """Sets the description of this MetadataExtraFields. + + + :param description: The description of this MetadataExtraFields. # noqa: E501 + :type: str + """ + + self._description = description + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(MetadataExtraFields, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, MetadataExtraFields): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/notification.py b/vendor/elabapi-python/elabapi_python/models/notification.py new file mode 100644 index 0000000..88c0f89 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/notification.py @@ -0,0 +1,292 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Notification(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'category': 'int', + 'is_ack': 'int', + 'created_at': 'str', + 'userid': 'int', + 'send_email': 'int', + 'email_sent_at': 'str', + 'body': 'str' + } + + attribute_map = { + 'id': 'id', + 'category': 'category', + 'is_ack': 'is_ack', + 'created_at': 'created_at', + 'userid': 'userid', + 'send_email': 'send_email', + 'email_sent_at': 'email_sent_at', + 'body': 'body' + } + + def __init__(self, id=None, category=None, is_ack=None, created_at=None, userid=None, send_email=None, email_sent_at=None, body=None): # noqa: E501 + """Notification - a model defined in Swagger""" # noqa: E501 + self._id = None + self._category = None + self._is_ack = None + self._created_at = None + self._userid = None + self._send_email = None + self._email_sent_at = None + self._body = None + self.discriminator = None + if id is not None: + self.id = id + if category is not None: + self.category = category + if is_ack is not None: + self.is_ack = is_ack + if created_at is not None: + self.created_at = created_at + if userid is not None: + self.userid = userid + if send_email is not None: + self.send_email = send_email + if email_sent_at is not None: + self.email_sent_at = email_sent_at + if body is not None: + self.body = body + + @property + def id(self): + """Gets the id of this Notification. # noqa: E501 + + + :return: The id of this Notification. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this Notification. + + + :param id: The id of this Notification. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def category(self): + """Gets the category of this Notification. # noqa: E501 + + + :return: The category of this Notification. # noqa: E501 + :rtype: int + """ + return self._category + + @category.setter + def category(self, category): + """Sets the category of this Notification. + + + :param category: The category of this Notification. # noqa: E501 + :type: int + """ + + self._category = category + + @property + def is_ack(self): + """Gets the is_ack of this Notification. # noqa: E501 + + + :return: The is_ack of this Notification. # noqa: E501 + :rtype: int + """ + return self._is_ack + + @is_ack.setter + def is_ack(self, is_ack): + """Sets the is_ack of this Notification. + + + :param is_ack: The is_ack of this Notification. # noqa: E501 + :type: int + """ + + self._is_ack = is_ack + + @property + def created_at(self): + """Gets the created_at of this Notification. # noqa: E501 + + + :return: The created_at of this Notification. # noqa: E501 + :rtype: str + """ + return self._created_at + + @created_at.setter + def created_at(self, created_at): + """Sets the created_at of this Notification. + + + :param created_at: The created_at of this Notification. # noqa: E501 + :type: str + """ + + self._created_at = created_at + + @property + def userid(self): + """Gets the userid of this Notification. # noqa: E501 + + + :return: The userid of this Notification. # noqa: E501 + :rtype: int + """ + return self._userid + + @userid.setter + def userid(self, userid): + """Sets the userid of this Notification. + + + :param userid: The userid of this Notification. # noqa: E501 + :type: int + """ + + self._userid = userid + + @property + def send_email(self): + """Gets the send_email of this Notification. # noqa: E501 + + + :return: The send_email of this Notification. # noqa: E501 + :rtype: int + """ + return self._send_email + + @send_email.setter + def send_email(self, send_email): + """Sets the send_email of this Notification. + + + :param send_email: The send_email of this Notification. # noqa: E501 + :type: int + """ + + self._send_email = send_email + + @property + def email_sent_at(self): + """Gets the email_sent_at of this Notification. # noqa: E501 + + + :return: The email_sent_at of this Notification. # noqa: E501 + :rtype: str + """ + return self._email_sent_at + + @email_sent_at.setter + def email_sent_at(self, email_sent_at): + """Sets the email_sent_at of this Notification. + + + :param email_sent_at: The email_sent_at of this Notification. # noqa: E501 + :type: str + """ + + self._email_sent_at = email_sent_at + + @property + def body(self): + """Gets the body of this Notification. # noqa: E501 + + + :return: The body of this Notification. # noqa: E501 + :rtype: str + """ + return self._body + + @body.setter + def body(self, body): + """Sets the body of this Notification. + + + :param body: The body of this Notification. # noqa: E501 + :type: str + """ + + self._body = body + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Notification, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Notification): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/notifications_subid_body.py b/vendor/elabapi-python/elabapi_python/models/notifications_subid_body.py new file mode 100644 index 0000000..cd94784 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/notifications_subid_body.py @@ -0,0 +1,118 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class NotificationsSubidBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'is_ack': 'int' + } + + attribute_map = { + 'is_ack': 'is_ack' + } + + def __init__(self, is_ack=None): # noqa: E501 + """NotificationsSubidBody - a model defined in Swagger""" # noqa: E501 + self._is_ack = None + self.discriminator = None + if is_ack is not None: + self.is_ack = is_ack + + @property + def is_ack(self): + """Gets the is_ack of this NotificationsSubidBody. # noqa: E501 + + Acknowledge the notification. `0` for unacknowledging, `1` for acknowledge. # noqa: E501 + + :return: The is_ack of this NotificationsSubidBody. # noqa: E501 + :rtype: int + """ + return self._is_ack + + @is_ack.setter + def is_ack(self, is_ack): + """Sets the is_ack of this NotificationsSubidBody. + + Acknowledge the notification. `0` for unacknowledging, `1` for acknowledge. # noqa: E501 + + :param is_ack: The is_ack of this NotificationsSubidBody. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_ack not in allowed_values: + raise ValueError( + "Invalid value for `is_ack` ({0}), must be one of {1}" # noqa: E501 + .format(is_ack, allowed_values) + ) + + self._is_ack = is_ack + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(NotificationsSubidBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, NotificationsSubidBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/patch_action.py b/vendor/elabapi-python/elabapi_python/models/patch_action.py new file mode 100644 index 0000000..8194817 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/patch_action.py @@ -0,0 +1,179 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class PatchAction(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'action': 'str', + 'passphrase': 'str', + 'meaning': 'int' + } + + attribute_map = { + 'action': 'action', + 'passphrase': 'passphrase', + 'meaning': 'meaning' + } + + def __init__(self, action=None, passphrase=None, meaning=None): # noqa: E501 + """PatchAction - a model defined in Swagger""" # noqa: E501 + self._action = None + self._passphrase = None + self._meaning = None + self.discriminator = None + self.action = action + if passphrase is not None: + self.passphrase = passphrase + if meaning is not None: + self.meaning = meaning + + @property + def action(self): + """Gets the action of this PatchAction. # noqa: E501 + + + :return: The action of this PatchAction. # noqa: E501 + :rtype: str + """ + return self._action + + @action.setter + def action(self, action): + """Sets the action of this PatchAction. + + + :param action: The action of this PatchAction. # noqa: E501 + :type: str + """ + if action is None: + raise ValueError("Invalid value for `action`, must not be `None`") # noqa: E501 + allowed_values = ["bloxberg", "exclusiveeditmode", "forcelock", "forceunlock", "lock", "pin", "sign", "timestamp", "updatemetadatafield", "update"] # noqa: E501 + if action not in allowed_values: + raise ValueError( + "Invalid value for `action` ({0}), must be one of {1}" # noqa: E501 + .format(action, allowed_values) + ) + + self._action = action + + @property + def passphrase(self): + """Gets the passphrase of this PatchAction. # noqa: E501 + + The passphrase corresponding to your signature key. Required when action is \"sign\". # noqa: E501 + + :return: The passphrase of this PatchAction. # noqa: E501 + :rtype: str + """ + return self._passphrase + + @passphrase.setter + def passphrase(self, passphrase): + """Sets the passphrase of this PatchAction. + + The passphrase corresponding to your signature key. Required when action is \"sign\". # noqa: E501 + + :param passphrase: The passphrase of this PatchAction. # noqa: E501 + :type: str + """ + + self._passphrase = passphrase + + @property + def meaning(self): + """Gets the meaning of this PatchAction. # noqa: E501 + + Meaning of the signature (required when action is \"sign\"): - 10: Approval - 20: Authorship - 30: Responsibility - 40: Review - 50: Safety # noqa: E501 + + :return: The meaning of this PatchAction. # noqa: E501 + :rtype: int + """ + return self._meaning + + @meaning.setter + def meaning(self, meaning): + """Sets the meaning of this PatchAction. + + Meaning of the signature (required when action is \"sign\"): - 10: Approval - 20: Authorship - 30: Responsibility - 40: Review - 50: Safety # noqa: E501 + + :param meaning: The meaning of this PatchAction. # noqa: E501 + :type: int + """ + allowed_values = [10, 20, 30, 40, 50] # noqa: E501 + if meaning not in allowed_values: + raise ValueError( + "Invalid value for `meaning` ({0}), must be one of {1}" # noqa: E501 + .format(meaning, allowed_values) + ) + + self._meaning = meaning + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(PatchAction, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, PatchAction): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/revision.py b/vendor/elabapi-python/elabapi_python/models/revision.py new file mode 100644 index 0000000..9bc249a --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/revision.py @@ -0,0 +1,266 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Revision(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'item_id': 'int', + 'body': 'str', + 'body_html': 'str', + 'content_type': 'int', + 'created_at': 'str', + 'userid': 'int' + } + + attribute_map = { + 'id': 'id', + 'item_id': 'item_id', + 'body': 'body', + 'body_html': 'body_html', + 'content_type': 'content_type', + 'created_at': 'created_at', + 'userid': 'userid' + } + + def __init__(self, id=None, item_id=None, body=None, body_html=None, content_type=None, created_at=None, userid=None): # noqa: E501 + """Revision - a model defined in Swagger""" # noqa: E501 + self._id = None + self._item_id = None + self._body = None + self._body_html = None + self._content_type = None + self._created_at = None + self._userid = None + self.discriminator = None + if id is not None: + self.id = id + if item_id is not None: + self.item_id = item_id + if body is not None: + self.body = body + if body_html is not None: + self.body_html = body_html + if content_type is not None: + self.content_type = content_type + if created_at is not None: + self.created_at = created_at + if userid is not None: + self.userid = userid + + @property + def id(self): + """Gets the id of this Revision. # noqa: E501 + + + :return: The id of this Revision. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this Revision. + + + :param id: The id of this Revision. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def item_id(self): + """Gets the item_id of this Revision. # noqa: E501 + + + :return: The item_id of this Revision. # noqa: E501 + :rtype: int + """ + return self._item_id + + @item_id.setter + def item_id(self, item_id): + """Sets the item_id of this Revision. + + + :param item_id: The item_id of this Revision. # noqa: E501 + :type: int + """ + + self._item_id = item_id + + @property + def body(self): + """Gets the body of this Revision. # noqa: E501 + + + :return: The body of this Revision. # noqa: E501 + :rtype: str + """ + return self._body + + @body.setter + def body(self, body): + """Sets the body of this Revision. + + + :param body: The body of this Revision. # noqa: E501 + :type: str + """ + + self._body = body + + @property + def body_html(self): + """Gets the body_html of this Revision. # noqa: E501 + + + :return: The body_html of this Revision. # noqa: E501 + :rtype: str + """ + return self._body_html + + @body_html.setter + def body_html(self, body_html): + """Sets the body_html of this Revision. + + + :param body_html: The body_html of this Revision. # noqa: E501 + :type: str + """ + + self._body_html = body_html + + @property + def content_type(self): + """Gets the content_type of this Revision. # noqa: E501 + + + :return: The content_type of this Revision. # noqa: E501 + :rtype: int + """ + return self._content_type + + @content_type.setter + def content_type(self, content_type): + """Sets the content_type of this Revision. + + + :param content_type: The content_type of this Revision. # noqa: E501 + :type: int + """ + + self._content_type = content_type + + @property + def created_at(self): + """Gets the created_at of this Revision. # noqa: E501 + + + :return: The created_at of this Revision. # noqa: E501 + :rtype: str + """ + return self._created_at + + @created_at.setter + def created_at(self, created_at): + """Sets the created_at of this Revision. + + + :param created_at: The created_at of this Revision. # noqa: E501 + :type: str + """ + + self._created_at = created_at + + @property + def userid(self): + """Gets the userid of this Revision. # noqa: E501 + + + :return: The userid of this Revision. # noqa: E501 + :rtype: int + """ + return self._userid + + @userid.setter + def userid(self, userid): + """Sets the userid of this Revision. + + + :param userid: The userid of this Revision. # noqa: E501 + :type: int + """ + + self._userid = userid + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Revision, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Revision): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/revisions_subid_body.py b/vendor/elabapi-python/elabapi_python/models/revisions_subid_body.py new file mode 100644 index 0000000..66e1327 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/revisions_subid_body.py @@ -0,0 +1,118 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class RevisionsSubidBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'action': 'str' + } + + attribute_map = { + 'action': 'action' + } + + def __init__(self, action=None): # noqa: E501 + """RevisionsSubidBody - a model defined in Swagger""" # noqa: E501 + self._action = None + self.discriminator = None + if action is not None: + self.action = action + + @property + def action(self): + """Gets the action of this RevisionsSubidBody. # noqa: E501 + + The `replace` action will restore the revision body to the entity. # noqa: E501 + + :return: The action of this RevisionsSubidBody. # noqa: E501 + :rtype: str + """ + return self._action + + @action.setter + def action(self, action): + """Sets the action of this RevisionsSubidBody. + + The `replace` action will restore the revision body to the entity. # noqa: E501 + + :param action: The action of this RevisionsSubidBody. # noqa: E501 + :type: str + """ + allowed_values = ["replace"] # noqa: E501 + if action not in allowed_values: + raise ValueError( + "Invalid value for `action` ({0}), must be one of {1}" # noqa: E501 + .format(action, allowed_values) + ) + + self._action = action + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(RevisionsSubidBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, RevisionsSubidBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/statuslike.py b/vendor/elabapi-python/elabapi_python/models/statuslike.py new file mode 100644 index 0000000..8ebc80b --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/statuslike.py @@ -0,0 +1,162 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Statuslike(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'title': 'str', + 'color': 'str' + } + + attribute_map = { + 'id': 'id', + 'title': 'title', + 'color': 'color' + } + + def __init__(self, id=None, title=None, color=None): # noqa: E501 + """Statuslike - a model defined in Swagger""" # noqa: E501 + self._id = None + self._title = None + self._color = None + self.discriminator = None + if id is not None: + self.id = id + if title is not None: + self.title = title + if color is not None: + self.color = color + + @property + def id(self): + """Gets the id of this Statuslike. # noqa: E501 + + + :return: The id of this Statuslike. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this Statuslike. + + + :param id: The id of this Statuslike. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def title(self): + """Gets the title of this Statuslike. # noqa: E501 + + + :return: The title of this Statuslike. # noqa: E501 + :rtype: str + """ + return self._title + + @title.setter + def title(self, title): + """Sets the title of this Statuslike. + + + :param title: The title of this Statuslike. # noqa: E501 + :type: str + """ + + self._title = title + + @property + def color(self): + """Gets the color of this Statuslike. # noqa: E501 + + + :return: The color of this Statuslike. # noqa: E501 + :rtype: str + """ + return self._color + + @color.setter + def color(self, color): + """Sets the color of this Statuslike. + + + :param color: The color of this Statuslike. # noqa: E501 + :type: str + """ + + self._color = color + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Statuslike, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Statuslike): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/step.py b/vendor/elabapi-python/elabapi_python/models/step.py new file mode 100644 index 0000000..8986abd --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/step.py @@ -0,0 +1,326 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Step(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'item_id': 'int', + 'body': 'str', + 'ordering': 'int', + 'finished': 'int', + 'finished_time': 'str', + 'deadline': 'str', + 'deadline_notif': 'int', + 'is_immutable': 'int' + } + + attribute_map = { + 'id': 'id', + 'item_id': 'item_id', + 'body': 'body', + 'ordering': 'ordering', + 'finished': 'finished', + 'finished_time': 'finished_time', + 'deadline': 'deadline', + 'deadline_notif': 'deadline_notif', + 'is_immutable': 'is_immutable' + } + + def __init__(self, id=None, item_id=None, body=None, ordering=None, finished=None, finished_time=None, deadline=None, deadline_notif=None, is_immutable=None): # noqa: E501 + """Step - a model defined in Swagger""" # noqa: E501 + self._id = None + self._item_id = None + self._body = None + self._ordering = None + self._finished = None + self._finished_time = None + self._deadline = None + self._deadline_notif = None + self._is_immutable = None + self.discriminator = None + if id is not None: + self.id = id + if item_id is not None: + self.item_id = item_id + if body is not None: + self.body = body + if ordering is not None: + self.ordering = ordering + if finished is not None: + self.finished = finished + if finished_time is not None: + self.finished_time = finished_time + if deadline is not None: + self.deadline = deadline + if deadline_notif is not None: + self.deadline_notif = deadline_notif + if is_immutable is not None: + self.is_immutable = is_immutable + + @property + def id(self): + """Gets the id of this Step. # noqa: E501 + + + :return: The id of this Step. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this Step. + + + :param id: The id of this Step. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def item_id(self): + """Gets the item_id of this Step. # noqa: E501 + + + :return: The item_id of this Step. # noqa: E501 + :rtype: int + """ + return self._item_id + + @item_id.setter + def item_id(self, item_id): + """Sets the item_id of this Step. + + + :param item_id: The item_id of this Step. # noqa: E501 + :type: int + """ + + self._item_id = item_id + + @property + def body(self): + """Gets the body of this Step. # noqa: E501 + + + :return: The body of this Step. # noqa: E501 + :rtype: str + """ + return self._body + + @body.setter + def body(self, body): + """Sets the body of this Step. + + + :param body: The body of this Step. # noqa: E501 + :type: str + """ + + self._body = body + + @property + def ordering(self): + """Gets the ordering of this Step. # noqa: E501 + + + :return: The ordering of this Step. # noqa: E501 + :rtype: int + """ + return self._ordering + + @ordering.setter + def ordering(self, ordering): + """Sets the ordering of this Step. + + + :param ordering: The ordering of this Step. # noqa: E501 + :type: int + """ + + self._ordering = ordering + + @property + def finished(self): + """Gets the finished of this Step. # noqa: E501 + + + :return: The finished of this Step. # noqa: E501 + :rtype: int + """ + return self._finished + + @finished.setter + def finished(self, finished): + """Sets the finished of this Step. + + + :param finished: The finished of this Step. # noqa: E501 + :type: int + """ + + self._finished = finished + + @property + def finished_time(self): + """Gets the finished_time of this Step. # noqa: E501 + + + :return: The finished_time of this Step. # noqa: E501 + :rtype: str + """ + return self._finished_time + + @finished_time.setter + def finished_time(self, finished_time): + """Sets the finished_time of this Step. + + + :param finished_time: The finished_time of this Step. # noqa: E501 + :type: str + """ + + self._finished_time = finished_time + + @property + def deadline(self): + """Gets the deadline of this Step. # noqa: E501 + + + :return: The deadline of this Step. # noqa: E501 + :rtype: str + """ + return self._deadline + + @deadline.setter + def deadline(self, deadline): + """Sets the deadline of this Step. + + + :param deadline: The deadline of this Step. # noqa: E501 + :type: str + """ + + self._deadline = deadline + + @property + def deadline_notif(self): + """Gets the deadline_notif of this Step. # noqa: E501 + + + :return: The deadline_notif of this Step. # noqa: E501 + :rtype: int + """ + return self._deadline_notif + + @deadline_notif.setter + def deadline_notif(self, deadline_notif): + """Sets the deadline_notif of this Step. + + + :param deadline_notif: The deadline_notif of this Step. # noqa: E501 + :type: int + """ + + self._deadline_notif = deadline_notif + + @property + def is_immutable(self): + """Gets the is_immutable of this Step. # noqa: E501 + + Only editable via templates. Immutability persists on derived experiments or resources. # noqa: E501 + + :return: The is_immutable of this Step. # noqa: E501 + :rtype: int + """ + return self._is_immutable + + @is_immutable.setter + def is_immutable(self, is_immutable): + """Sets the is_immutable of this Step. + + Only editable via templates. Immutability persists on derived experiments or resources. # noqa: E501 + + :param is_immutable: The is_immutable of this Step. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_immutable not in allowed_values: + raise ValueError( + "Invalid value for `is_immutable` ({0}), must be one of {1}" # noqa: E501 + .format(is_immutable, allowed_values) + ) + + self._is_immutable = is_immutable + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Step, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Step): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/steps_subid_body.py b/vendor/elabapi-python/elabapi_python/models/steps_subid_body.py new file mode 100644 index 0000000..b9b8406 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/steps_subid_body.py @@ -0,0 +1,203 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class StepsSubidBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'action': 'str', + 'is_immutable': 'int', + 'body': 'str', + 'finished': 'int' + } + + attribute_map = { + 'action': 'action', + 'is_immutable': 'is_immutable', + 'body': 'body', + 'finished': 'finished' + } + + def __init__(self, action=None, is_immutable=None, body=None, finished=None): # noqa: E501 + """StepsSubidBody - a model defined in Swagger""" # noqa: E501 + self._action = None + self._is_immutable = None + self._body = None + self._finished = None + self.discriminator = None + self.action = action + if is_immutable is not None: + self.is_immutable = is_immutable + if body is not None: + self.body = body + if finished is not None: + self.finished = finished + + @property + def action(self): + """Gets the action of this StepsSubidBody. # noqa: E501 + + + :return: The action of this StepsSubidBody. # noqa: E501 + :rtype: str + """ + return self._action + + @action.setter + def action(self, action): + """Sets the action of this StepsSubidBody. + + + :param action: The action of this StepsSubidBody. # noqa: E501 + :type: str + """ + if action is None: + raise ValueError("Invalid value for `action`, must not be `None`") # noqa: E501 + allowed_values = ["finish", "notif", "update"] # noqa: E501 + if action not in allowed_values: + raise ValueError( + "Invalid value for `action` ({0}), must be one of {1}" # noqa: E501 + .format(action, allowed_values) + ) + + self._action = action + + @property + def is_immutable(self): + """Gets the is_immutable of this StepsSubidBody. # noqa: E501 + + + :return: The is_immutable of this StepsSubidBody. # noqa: E501 + :rtype: int + """ + return self._is_immutable + + @is_immutable.setter + def is_immutable(self, is_immutable): + """Sets the is_immutable of this StepsSubidBody. + + + :param is_immutable: The is_immutable of this StepsSubidBody. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if is_immutable not in allowed_values: + raise ValueError( + "Invalid value for `is_immutable` ({0}), must be one of {1}" # noqa: E501 + .format(is_immutable, allowed_values) + ) + + self._is_immutable = is_immutable + + @property + def body(self): + """Gets the body of this StepsSubidBody. # noqa: E501 + + The text content of the step. # noqa: E501 + + :return: The body of this StepsSubidBody. # noqa: E501 + :rtype: str + """ + return self._body + + @body.setter + def body(self, body): + """Sets the body of this StepsSubidBody. + + The text content of the step. # noqa: E501 + + :param body: The body of this StepsSubidBody. # noqa: E501 + :type: str + """ + + self._body = body + + @property + def finished(self): + """Gets the finished of this StepsSubidBody. # noqa: E501 + + + :return: The finished of this StepsSubidBody. # noqa: E501 + :rtype: int + """ + return self._finished + + @finished.setter + def finished(self, finished): + """Sets the finished of this StepsSubidBody. + + + :param finished: The finished of this StepsSubidBody. # noqa: E501 + :type: int + """ + + self._finished = finished + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(StepsSubidBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, StepsSubidBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/storage_unit.py b/vendor/elabapi-python/elabapi_python/models/storage_unit.py new file mode 100644 index 0000000..12bd6ce --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/storage_unit.py @@ -0,0 +1,224 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class StorageUnit(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'name': 'str', + 'parent_id': 'int', + 'full_path': 'str', + 'level_depth': 'int' + } + + attribute_map = { + 'id': 'id', + 'name': 'name', + 'parent_id': 'parent_id', + 'full_path': 'full_path', + 'level_depth': 'level_depth' + } + + def __init__(self, id=None, name=None, parent_id=None, full_path=None, level_depth=None): # noqa: E501 + """StorageUnit - a model defined in Swagger""" # noqa: E501 + self._id = None + self._name = None + self._parent_id = None + self._full_path = None + self._level_depth = None + self.discriminator = None + if id is not None: + self.id = id + if name is not None: + self.name = name + if parent_id is not None: + self.parent_id = parent_id + if full_path is not None: + self.full_path = full_path + if level_depth is not None: + self.level_depth = level_depth + + @property + def id(self): + """Gets the id of this StorageUnit. # noqa: E501 + + The storage unit ID # noqa: E501 + + :return: The id of this StorageUnit. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this StorageUnit. + + The storage unit ID # noqa: E501 + + :param id: The id of this StorageUnit. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def name(self): + """Gets the name of this StorageUnit. # noqa: E501 + + Name of the storage unit # noqa: E501 + + :return: The name of this StorageUnit. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this StorageUnit. + + Name of the storage unit # noqa: E501 + + :param name: The name of this StorageUnit. # noqa: E501 + :type: str + """ + + self._name = name + + @property + def parent_id(self): + """Gets the parent_id of this StorageUnit. # noqa: E501 + + ID of the parent storage unit (null for root level) # noqa: E501 + + :return: The parent_id of this StorageUnit. # noqa: E501 + :rtype: int + """ + return self._parent_id + + @parent_id.setter + def parent_id(self, parent_id): + """Sets the parent_id of this StorageUnit. + + ID of the parent storage unit (null for root level) # noqa: E501 + + :param parent_id: The parent_id of this StorageUnit. # noqa: E501 + :type: int + """ + + self._parent_id = parent_id + + @property + def full_path(self): + """Gets the full_path of this StorageUnit. # noqa: E501 + + Full hierarchical path from root to this unit # noqa: E501 + + :return: The full_path of this StorageUnit. # noqa: E501 + :rtype: str + """ + return self._full_path + + @full_path.setter + def full_path(self, full_path): + """Sets the full_path of this StorageUnit. + + Full hierarchical path from root to this unit # noqa: E501 + + :param full_path: The full_path of this StorageUnit. # noqa: E501 + :type: str + """ + + self._full_path = full_path + + @property + def level_depth(self): + """Gets the level_depth of this StorageUnit. # noqa: E501 + + Depth level in the hierarchy (0 for root) # noqa: E501 + + :return: The level_depth of this StorageUnit. # noqa: E501 + :rtype: int + """ + return self._level_depth + + @level_depth.setter + def level_depth(self, level_depth): + """Sets the level_depth of this StorageUnit. + + Depth level in the hierarchy (0 for root) # noqa: E501 + + :param level_depth: The level_depth of this StorageUnit. # noqa: E501 + :type: int + """ + + self._level_depth = level_depth + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(StorageUnit, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, StorageUnit): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/storage_units_body.py b/vendor/elabapi-python/elabapi_python/models/storage_units_body.py new file mode 100644 index 0000000..fe33e63 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/storage_units_body.py @@ -0,0 +1,141 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class StorageUnitsBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'name': 'str', + 'parent_id': 'int' + } + + attribute_map = { + 'name': 'name', + 'parent_id': 'parent_id' + } + + def __init__(self, name=None, parent_id=None): # noqa: E501 + """StorageUnitsBody - a model defined in Swagger""" # noqa: E501 + self._name = None + self._parent_id = None + self.discriminator = None + self.name = name + if parent_id is not None: + self.parent_id = parent_id + + @property + def name(self): + """Gets the name of this StorageUnitsBody. # noqa: E501 + + Name of the storage unit. # noqa: E501 + + :return: The name of this StorageUnitsBody. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this StorageUnitsBody. + + Name of the storage unit. # noqa: E501 + + :param name: The name of this StorageUnitsBody. # noqa: E501 + :type: str + """ + if name is None: + raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501 + + self._name = name + + @property + def parent_id(self): + """Gets the parent_id of this StorageUnitsBody. # noqa: E501 + + ID of the parent storage unit. Set to null for a top-level unit. # noqa: E501 + + :return: The parent_id of this StorageUnitsBody. # noqa: E501 + :rtype: int + """ + return self._parent_id + + @parent_id.setter + def parent_id(self, parent_id): + """Sets the parent_id of this StorageUnitsBody. + + ID of the parent storage unit. Set to null for a top-level unit. # noqa: E501 + + :param parent_id: The parent_id of this StorageUnitsBody. # noqa: E501 + :type: int + """ + + self._parent_id = parent_id + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(StorageUnitsBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, StorageUnitsBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/storage_units_id_body.py b/vendor/elabapi-python/elabapi_python/models/storage_units_id_body.py new file mode 100644 index 0000000..031ff45 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/storage_units_id_body.py @@ -0,0 +1,140 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class StorageUnitsIdBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'name': 'str', + 'parent_id': 'int' + } + + attribute_map = { + 'name': 'name', + 'parent_id': 'parent_id' + } + + def __init__(self, name=None, parent_id=None): # noqa: E501 + """StorageUnitsIdBody - a model defined in Swagger""" # noqa: E501 + self._name = None + self._parent_id = None + self.discriminator = None + if name is not None: + self.name = name + if parent_id is not None: + self.parent_id = parent_id + + @property + def name(self): + """Gets the name of this StorageUnitsIdBody. # noqa: E501 + + New name for the storage unit. # noqa: E501 + + :return: The name of this StorageUnitsIdBody. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this StorageUnitsIdBody. + + New name for the storage unit. # noqa: E501 + + :param name: The name of this StorageUnitsIdBody. # noqa: E501 + :type: str + """ + + self._name = name + + @property + def parent_id(self): + """Gets the parent_id of this StorageUnitsIdBody. # noqa: E501 + + New parent storage unit id, or `null` to move to the root. Cannot be the unit itself or any of its descendants. # noqa: E501 + + :return: The parent_id of this StorageUnitsIdBody. # noqa: E501 + :rtype: int + """ + return self._parent_id + + @parent_id.setter + def parent_id(self, parent_id): + """Sets the parent_id of this StorageUnitsIdBody. + + New parent storage unit id, or `null` to move to the root. Cannot be the unit itself or any of its descendants. # noqa: E501 + + :param parent_id: The parent_id of this StorageUnitsIdBody. # noqa: E501 + :type: int + """ + + self._parent_id = parent_id + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(StorageUnitsIdBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, StorageUnitsIdBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/tag.py b/vendor/elabapi-python/elabapi_python/models/tag.py new file mode 100644 index 0000000..c751eac --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/tag.py @@ -0,0 +1,214 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Tag(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'item_count': 'int', + 'is_favorite': 'int', + 'tag': 'str', + 'team': 'int' + } + + attribute_map = { + 'id': 'id', + 'item_count': 'item_count', + 'is_favorite': 'is_favorite', + 'tag': 'tag', + 'team': 'team' + } + + def __init__(self, id=None, item_count=None, is_favorite=None, tag=None, team=None): # noqa: E501 + """Tag - a model defined in Swagger""" # noqa: E501 + self._id = None + self._item_count = None + self._is_favorite = None + self._tag = None + self._team = None + self.discriminator = None + if id is not None: + self.id = id + if item_count is not None: + self.item_count = item_count + if is_favorite is not None: + self.is_favorite = is_favorite + if tag is not None: + self.tag = tag + if team is not None: + self.team = team + + @property + def id(self): + """Gets the id of this Tag. # noqa: E501 + + + :return: The id of this Tag. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this Tag. + + + :param id: The id of this Tag. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def item_count(self): + """Gets the item_count of this Tag. # noqa: E501 + + + :return: The item_count of this Tag. # noqa: E501 + :rtype: int + """ + return self._item_count + + @item_count.setter + def item_count(self, item_count): + """Sets the item_count of this Tag. + + + :param item_count: The item_count of this Tag. # noqa: E501 + :type: int + """ + + self._item_count = item_count + + @property + def is_favorite(self): + """Gets the is_favorite of this Tag. # noqa: E501 + + + :return: The is_favorite of this Tag. # noqa: E501 + :rtype: int + """ + return self._is_favorite + + @is_favorite.setter + def is_favorite(self, is_favorite): + """Sets the is_favorite of this Tag. + + + :param is_favorite: The is_favorite of this Tag. # noqa: E501 + :type: int + """ + + self._is_favorite = is_favorite + + @property + def tag(self): + """Gets the tag of this Tag. # noqa: E501 + + + :return: The tag of this Tag. # noqa: E501 + :rtype: str + """ + return self._tag + + @tag.setter + def tag(self, tag): + """Sets the tag of this Tag. + + + :param tag: The tag of this Tag. # noqa: E501 + :type: str + """ + + self._tag = tag + + @property + def team(self): + """Gets the team of this Tag. # noqa: E501 + + + :return: The team of this Tag. # noqa: E501 + :rtype: int + """ + return self._team + + @team.setter + def team(self, team): + """Sets the team of this Tag. + + + :param team: The team of this Tag. # noqa: E501 + :type: int + """ + + self._team = team + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Tag, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Tag): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/tags_subid_body.py b/vendor/elabapi-python/elabapi_python/models/tags_subid_body.py new file mode 100644 index 0000000..96f829b --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/tags_subid_body.py @@ -0,0 +1,144 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class TagsSubidBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'action': 'str', + 'tag': 'str' + } + + attribute_map = { + 'action': 'action', + 'tag': 'tag' + } + + def __init__(self, action=None, tag=None): # noqa: E501 + """TagsSubidBody - a model defined in Swagger""" # noqa: E501 + self._action = None + self._tag = None + self.discriminator = None + if action is not None: + self.action = action + if tag is not None: + self.tag = tag + + @property + def action(self): + """Gets the action of this TagsSubidBody. # noqa: E501 + + + :return: The action of this TagsSubidBody. # noqa: E501 + :rtype: str + """ + return self._action + + @action.setter + def action(self, action): + """Sets the action of this TagsSubidBody. + + + :param action: The action of this TagsSubidBody. # noqa: E501 + :type: str + """ + allowed_values = ["updatetag"] # noqa: E501 + if action not in allowed_values: + raise ValueError( + "Invalid value for `action` ({0}), must be one of {1}" # noqa: E501 + .format(action, allowed_values) + ) + + self._action = action + + @property + def tag(self): + """Gets the tag of this TagsSubidBody. # noqa: E501 + + The content of the tag. # noqa: E501 + + :return: The tag of this TagsSubidBody. # noqa: E501 + :rtype: str + """ + return self._tag + + @tag.setter + def tag(self, tag): + """Sets the tag of this TagsSubidBody. + + The content of the tag. # noqa: E501 + + :param tag: The tag of this TagsSubidBody. # noqa: E501 + :type: str + """ + + self._tag = tag + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(TagsSubidBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, TagsSubidBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/tags_subid_body1.py b/vendor/elabapi-python/elabapi_python/models/tags_subid_body1.py new file mode 100644 index 0000000..63a032b --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/tags_subid_body1.py @@ -0,0 +1,117 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class TagsSubidBody1(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'action': 'str' + } + + attribute_map = { + 'action': 'action' + } + + def __init__(self, action=None): # noqa: E501 + """TagsSubidBody1 - a model defined in Swagger""" # noqa: E501 + self._action = None + self.discriminator = None + self.action = action + + @property + def action(self): + """Gets the action of this TagsSubidBody1. # noqa: E501 + + + :return: The action of this TagsSubidBody1. # noqa: E501 + :rtype: str + """ + return self._action + + @action.setter + def action(self, action): + """Sets the action of this TagsSubidBody1. + + + :param action: The action of this TagsSubidBody1. # noqa: E501 + :type: str + """ + if action is None: + raise ValueError("Invalid value for `action`, must not be `None`") # noqa: E501 + allowed_values = ["unreference"] # noqa: E501 + if action not in allowed_values: + raise ValueError( + "Invalid value for `action` ({0}), must be one of {1}" # noqa: E501 + .format(action, allowed_values) + ) + + self._action = action + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(TagsSubidBody1, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, TagsSubidBody1): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/team.py b/vendor/elabapi-python/elabapi_python/models/team.py new file mode 100644 index 0000000..af91946 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/team.py @@ -0,0 +1,410 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Team(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'name': 'str', + 'user_create_tag': 'int', + 'force_exp_tpl': 'int', + 'force_res_tpl': 'int', + 'created_at': 'str', + 'orgid': 'str', + 'visible': 'int', + 'announcement': 'str', + 'onboarding_email_active': 'int', + 'onboarding_email_body': 'str', + 'onboarding_email_subject': 'str' + } + + attribute_map = { + 'id': 'id', + 'name': 'name', + 'user_create_tag': 'user_create_tag', + 'force_exp_tpl': 'force_exp_tpl', + 'force_res_tpl': 'force_res_tpl', + 'created_at': 'created_at', + 'orgid': 'orgid', + 'visible': 'visible', + 'announcement': 'announcement', + 'onboarding_email_active': 'onboarding_email_active', + 'onboarding_email_body': 'onboarding_email_body', + 'onboarding_email_subject': 'onboarding_email_subject' + } + + def __init__(self, id=None, name=None, user_create_tag=None, force_exp_tpl=0, force_res_tpl=0, created_at=None, orgid=None, visible=None, announcement=None, onboarding_email_active=None, onboarding_email_body=None, onboarding_email_subject=None): # noqa: E501 + """Team - a model defined in Swagger""" # noqa: E501 + self._id = None + self._name = None + self._user_create_tag = None + self._force_exp_tpl = None + self._force_res_tpl = None + self._created_at = None + self._orgid = None + self._visible = None + self._announcement = None + self._onboarding_email_active = None + self._onboarding_email_body = None + self._onboarding_email_subject = None + self.discriminator = None + if id is not None: + self.id = id + if name is not None: + self.name = name + if user_create_tag is not None: + self.user_create_tag = user_create_tag + if force_exp_tpl is not None: + self.force_exp_tpl = force_exp_tpl + if force_res_tpl is not None: + self.force_res_tpl = force_res_tpl + if created_at is not None: + self.created_at = created_at + if orgid is not None: + self.orgid = orgid + if visible is not None: + self.visible = visible + if announcement is not None: + self.announcement = announcement + if onboarding_email_active is not None: + self.onboarding_email_active = onboarding_email_active + if onboarding_email_body is not None: + self.onboarding_email_body = onboarding_email_body + if onboarding_email_subject is not None: + self.onboarding_email_subject = onboarding_email_subject + + @property + def id(self): + """Gets the id of this Team. # noqa: E501 + + + :return: The id of this Team. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this Team. + + + :param id: The id of this Team. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def name(self): + """Gets the name of this Team. # noqa: E501 + + + :return: The name of this Team. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this Team. + + + :param name: The name of this Team. # noqa: E501 + :type: str + """ + + self._name = name + + @property + def user_create_tag(self): + """Gets the user_create_tag of this Team. # noqa: E501 + + + :return: The user_create_tag of this Team. # noqa: E501 + :rtype: int + """ + return self._user_create_tag + + @user_create_tag.setter + def user_create_tag(self, user_create_tag): + """Sets the user_create_tag of this Team. + + + :param user_create_tag: The user_create_tag of this Team. # noqa: E501 + :type: int + """ + + self._user_create_tag = user_create_tag + + @property + def force_exp_tpl(self): + """Gets the force_exp_tpl of this Team. # noqa: E501 + + Binary toggle to force usage of templates. # noqa: E501 + + :return: The force_exp_tpl of this Team. # noqa: E501 + :rtype: int + """ + return self._force_exp_tpl + + @force_exp_tpl.setter + def force_exp_tpl(self, force_exp_tpl): + """Sets the force_exp_tpl of this Team. + + Binary toggle to force usage of templates. # noqa: E501 + + :param force_exp_tpl: The force_exp_tpl of this Team. # noqa: E501 + :type: int + """ + + self._force_exp_tpl = force_exp_tpl + + @property + def force_res_tpl(self): + """Gets the force_res_tpl of this Team. # noqa: E501 + + Binary toggle to force usage of templates. # noqa: E501 + + :return: The force_res_tpl of this Team. # noqa: E501 + :rtype: int + """ + return self._force_res_tpl + + @force_res_tpl.setter + def force_res_tpl(self, force_res_tpl): + """Sets the force_res_tpl of this Team. + + Binary toggle to force usage of templates. # noqa: E501 + + :param force_res_tpl: The force_res_tpl of this Team. # noqa: E501 + :type: int + """ + + self._force_res_tpl = force_res_tpl + + @property + def created_at(self): + """Gets the created_at of this Team. # noqa: E501 + + + :return: The created_at of this Team. # noqa: E501 + :rtype: str + """ + return self._created_at + + @created_at.setter + def created_at(self, created_at): + """Sets the created_at of this Team. + + + :param created_at: The created_at of this Team. # noqa: E501 + :type: str + """ + + self._created_at = created_at + + @property + def orgid(self): + """Gets the orgid of this Team. # noqa: E501 + + + :return: The orgid of this Team. # noqa: E501 + :rtype: str + """ + return self._orgid + + @orgid.setter + def orgid(self, orgid): + """Sets the orgid of this Team. + + + :param orgid: The orgid of this Team. # noqa: E501 + :type: str + """ + + self._orgid = orgid + + @property + def visible(self): + """Gets the visible of this Team. # noqa: E501 + + + :return: The visible of this Team. # noqa: E501 + :rtype: int + """ + return self._visible + + @visible.setter + def visible(self, visible): + """Sets the visible of this Team. + + + :param visible: The visible of this Team. # noqa: E501 + :type: int + """ + + self._visible = visible + + @property + def announcement(self): + """Gets the announcement of this Team. # noqa: E501 + + Text shown on top of every page for all users of this team. # noqa: E501 + + :return: The announcement of this Team. # noqa: E501 + :rtype: str + """ + return self._announcement + + @announcement.setter + def announcement(self, announcement): + """Sets the announcement of this Team. + + Text shown on top of every page for all users of this team. # noqa: E501 + + :param announcement: The announcement of this Team. # noqa: E501 + :type: str + """ + + self._announcement = announcement + + @property + def onboarding_email_active(self): + """Gets the onboarding_email_active of this Team. # noqa: E501 + + Do we send onboarding emails to new users? # noqa: E501 + + :return: The onboarding_email_active of this Team. # noqa: E501 + :rtype: int + """ + return self._onboarding_email_active + + @onboarding_email_active.setter + def onboarding_email_active(self, onboarding_email_active): + """Sets the onboarding_email_active of this Team. + + Do we send onboarding emails to new users? # noqa: E501 + + :param onboarding_email_active: The onboarding_email_active of this Team. # noqa: E501 + :type: int + """ + allowed_values = [0, 1] # noqa: E501 + if onboarding_email_active not in allowed_values: + raise ValueError( + "Invalid value for `onboarding_email_active` ({0}), must be one of {1}" # noqa: E501 + .format(onboarding_email_active, allowed_values) + ) + + self._onboarding_email_active = onboarding_email_active + + @property + def onboarding_email_body(self): + """Gets the onboarding_email_body of this Team. # noqa: E501 + + + :return: The onboarding_email_body of this Team. # noqa: E501 + :rtype: str + """ + return self._onboarding_email_body + + @onboarding_email_body.setter + def onboarding_email_body(self, onboarding_email_body): + """Sets the onboarding_email_body of this Team. + + + :param onboarding_email_body: The onboarding_email_body of this Team. # noqa: E501 + :type: str + """ + + self._onboarding_email_body = onboarding_email_body + + @property + def onboarding_email_subject(self): + """Gets the onboarding_email_subject of this Team. # noqa: E501 + + + :return: The onboarding_email_subject of this Team. # noqa: E501 + :rtype: str + """ + return self._onboarding_email_subject + + @onboarding_email_subject.setter + def onboarding_email_subject(self, onboarding_email_subject): + """Sets the onboarding_email_subject of this Team. + + + :param onboarding_email_subject: The onboarding_email_subject of this Team. # noqa: E501 + :type: str + """ + + self._onboarding_email_subject = onboarding_email_subject + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Team, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Team): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/teamgroup.py b/vendor/elabapi-python/elabapi_python/models/teamgroup.py new file mode 100644 index 0000000..9807fb2 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/teamgroup.py @@ -0,0 +1,162 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Teamgroup(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'name': 'str', + 'users': 'list[TeamgroupUsers]' + } + + attribute_map = { + 'id': 'id', + 'name': 'name', + 'users': 'users' + } + + def __init__(self, id=None, name=None, users=None): # noqa: E501 + """Teamgroup - a model defined in Swagger""" # noqa: E501 + self._id = None + self._name = None + self._users = None + self.discriminator = None + if id is not None: + self.id = id + if name is not None: + self.name = name + if users is not None: + self.users = users + + @property + def id(self): + """Gets the id of this Teamgroup. # noqa: E501 + + + :return: The id of this Teamgroup. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this Teamgroup. + + + :param id: The id of this Teamgroup. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def name(self): + """Gets the name of this Teamgroup. # noqa: E501 + + + :return: The name of this Teamgroup. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this Teamgroup. + + + :param name: The name of this Teamgroup. # noqa: E501 + :type: str + """ + + self._name = name + + @property + def users(self): + """Gets the users of this Teamgroup. # noqa: E501 + + + :return: The users of this Teamgroup. # noqa: E501 + :rtype: list[TeamgroupUsers] + """ + return self._users + + @users.setter + def users(self, users): + """Sets the users of this Teamgroup. + + + :param users: The users of this Teamgroup. # noqa: E501 + :type: list[TeamgroupUsers] + """ + + self._users = users + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Teamgroup, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Teamgroup): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/teamgroup_users.py b/vendor/elabapi-python/elabapi_python/models/teamgroup_users.py new file mode 100644 index 0000000..d7c076b --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/teamgroup_users.py @@ -0,0 +1,136 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class TeamgroupUsers(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'userid': 'int', + 'fullname': 'str' + } + + attribute_map = { + 'userid': 'userid', + 'fullname': 'fullname' + } + + def __init__(self, userid=None, fullname=None): # noqa: E501 + """TeamgroupUsers - a model defined in Swagger""" # noqa: E501 + self._userid = None + self._fullname = None + self.discriminator = None + if userid is not None: + self.userid = userid + if fullname is not None: + self.fullname = fullname + + @property + def userid(self): + """Gets the userid of this TeamgroupUsers. # noqa: E501 + + + :return: The userid of this TeamgroupUsers. # noqa: E501 + :rtype: int + """ + return self._userid + + @userid.setter + def userid(self, userid): + """Sets the userid of this TeamgroupUsers. + + + :param userid: The userid of this TeamgroupUsers. # noqa: E501 + :type: int + """ + + self._userid = userid + + @property + def fullname(self): + """Gets the fullname of this TeamgroupUsers. # noqa: E501 + + + :return: The fullname of this TeamgroupUsers. # noqa: E501 + :rtype: str + """ + return self._fullname + + @fullname.setter + def fullname(self, fullname): + """Sets the fullname of this TeamgroupUsers. + + + :param fullname: The fullname of this TeamgroupUsers. # noqa: E501 + :type: str + """ + + self._fullname = fullname + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(TeamgroupUsers, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, TeamgroupUsers): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/teamgroups_subid_body.py b/vendor/elabapi-python/elabapi_python/models/teamgroups_subid_body.py new file mode 100644 index 0000000..60a905d --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/teamgroups_subid_body.py @@ -0,0 +1,84 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class TeamgroupsSubidBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + } + + attribute_map = { + } + + def __init__(self): # noqa: E501 + """TeamgroupsSubidBody - a model defined in Swagger""" # noqa: E501 + self.discriminator = None + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(TeamgroupsSubidBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, TeamgroupsSubidBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/teams_body.py b/vendor/elabapi-python/elabapi_python/models/teams_body.py new file mode 100644 index 0000000..15499cf --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/teams_body.py @@ -0,0 +1,112 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class TeamsBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'name': 'str' + } + + attribute_map = { + 'name': 'name' + } + + def __init__(self, name='New team name'): # noqa: E501 + """TeamsBody - a model defined in Swagger""" # noqa: E501 + self._name = None + self.discriminator = None + if name is not None: + self.name = name + + @property + def name(self): + """Gets the name of this TeamsBody. # noqa: E501 + + Team name. # noqa: E501 + + :return: The name of this TeamsBody. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this TeamsBody. + + Team name. # noqa: E501 + + :param name: The name of this TeamsBody. # noqa: E501 + :type: str + """ + + self._name = name + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(TeamsBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, TeamsBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/teams_id_body.py b/vendor/elabapi-python/elabapi_python/models/teams_id_body.py new file mode 100644 index 0000000..386006d --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/teams_id_body.py @@ -0,0 +1,84 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class TeamsIdBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + } + + attribute_map = { + } + + def __init__(self): # noqa: E501 + """TeamsIdBody - a model defined in Swagger""" # noqa: E501 + self.discriminator = None + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(TeamsIdBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, TeamsIdBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/todoitem.py b/vendor/elabapi-python/elabapi_python/models/todoitem.py new file mode 100644 index 0000000..679336c --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/todoitem.py @@ -0,0 +1,214 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Todoitem(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'body': 'str', + 'creation_time': 'str', + 'ordering': 'int', + 'userid': 'int' + } + + attribute_map = { + 'id': 'id', + 'body': 'body', + 'creation_time': 'creation_time', + 'ordering': 'ordering', + 'userid': 'userid' + } + + def __init__(self, id=None, body=None, creation_time=None, ordering=None, userid=None): # noqa: E501 + """Todoitem - a model defined in Swagger""" # noqa: E501 + self._id = None + self._body = None + self._creation_time = None + self._ordering = None + self._userid = None + self.discriminator = None + if id is not None: + self.id = id + if body is not None: + self.body = body + if creation_time is not None: + self.creation_time = creation_time + if ordering is not None: + self.ordering = ordering + if userid is not None: + self.userid = userid + + @property + def id(self): + """Gets the id of this Todoitem. # noqa: E501 + + + :return: The id of this Todoitem. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this Todoitem. + + + :param id: The id of this Todoitem. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def body(self): + """Gets the body of this Todoitem. # noqa: E501 + + + :return: The body of this Todoitem. # noqa: E501 + :rtype: str + """ + return self._body + + @body.setter + def body(self, body): + """Sets the body of this Todoitem. + + + :param body: The body of this Todoitem. # noqa: E501 + :type: str + """ + + self._body = body + + @property + def creation_time(self): + """Gets the creation_time of this Todoitem. # noqa: E501 + + + :return: The creation_time of this Todoitem. # noqa: E501 + :rtype: str + """ + return self._creation_time + + @creation_time.setter + def creation_time(self, creation_time): + """Sets the creation_time of this Todoitem. + + + :param creation_time: The creation_time of this Todoitem. # noqa: E501 + :type: str + """ + + self._creation_time = creation_time + + @property + def ordering(self): + """Gets the ordering of this Todoitem. # noqa: E501 + + + :return: The ordering of this Todoitem. # noqa: E501 + :rtype: int + """ + return self._ordering + + @ordering.setter + def ordering(self, ordering): + """Sets the ordering of this Todoitem. + + + :param ordering: The ordering of this Todoitem. # noqa: E501 + :type: int + """ + + self._ordering = ordering + + @property + def userid(self): + """Gets the userid of this Todoitem. # noqa: E501 + + + :return: The userid of this Todoitem. # noqa: E501 + :rtype: int + """ + return self._userid + + @userid.setter + def userid(self, userid): + """Sets the userid of this Todoitem. + + + :param userid: The userid of this Todoitem. # noqa: E501 + :type: int + """ + + self._userid = userid + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Todoitem, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Todoitem): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/todolist_body.py b/vendor/elabapi-python/elabapi_python/models/todolist_body.py new file mode 100644 index 0000000..c8a5a41 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/todolist_body.py @@ -0,0 +1,112 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class TodolistBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'content': 'str' + } + + attribute_map = { + 'content': 'content' + } + + def __init__(self, content=None): # noqa: E501 + """TodolistBody - a model defined in Swagger""" # noqa: E501 + self._content = None + self.discriminator = None + if content is not None: + self.content = content + + @property + def content(self): + """Gets the content of this TodolistBody. # noqa: E501 + + What to do # noqa: E501 + + :return: The content of this TodolistBody. # noqa: E501 + :rtype: str + """ + return self._content + + @content.setter + def content(self, content): + """Sets the content of this TodolistBody. + + What to do # noqa: E501 + + :param content: The content of this TodolistBody. # noqa: E501 + :type: str + """ + + self._content = content + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(TodolistBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, TodolistBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/todolist_id_body.py b/vendor/elabapi-python/elabapi_python/models/todolist_id_body.py new file mode 100644 index 0000000..9ed5628 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/todolist_id_body.py @@ -0,0 +1,111 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class TodolistIdBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'body': 'str' + } + + attribute_map = { + 'body': 'body' + } + + def __init__(self, body=None): # noqa: E501 + """TodolistIdBody - a model defined in Swagger""" # noqa: E501 + self._body = None + self.discriminator = None + self.body = body + + @property + def body(self): + """Gets the body of this TodolistIdBody. # noqa: E501 + + + :return: The body of this TodolistIdBody. # noqa: E501 + :rtype: str + """ + return self._body + + @body.setter + def body(self, body): + """Sets the body of this TodolistIdBody. + + + :param body: The body of this TodolistIdBody. # noqa: E501 + :type: str + """ + if body is None: + raise ValueError("Invalid value for `body`, must not be `None`") # noqa: E501 + + self._body = body + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(TodolistIdBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, TodolistIdBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/unfinished_step.py b/vendor/elabapi-python/elabapi_python/models/unfinished_step.py new file mode 100644 index 0000000..c9bb330 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/unfinished_step.py @@ -0,0 +1,162 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class UnfinishedStep(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'title': 'str', + 'steps': 'list[str]' + } + + attribute_map = { + 'id': 'id', + 'title': 'title', + 'steps': 'steps' + } + + def __init__(self, id=None, title=None, steps=None): # noqa: E501 + """UnfinishedStep - a model defined in Swagger""" # noqa: E501 + self._id = None + self._title = None + self._steps = None + self.discriminator = None + if id is not None: + self.id = id + if title is not None: + self.title = title + if steps is not None: + self.steps = steps + + @property + def id(self): + """Gets the id of this UnfinishedStep. # noqa: E501 + + + :return: The id of this UnfinishedStep. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this UnfinishedStep. + + + :param id: The id of this UnfinishedStep. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def title(self): + """Gets the title of this UnfinishedStep. # noqa: E501 + + + :return: The title of this UnfinishedStep. # noqa: E501 + :rtype: str + """ + return self._title + + @title.setter + def title(self, title): + """Sets the title of this UnfinishedStep. + + + :param title: The title of this UnfinishedStep. # noqa: E501 + :type: str + """ + + self._title = title + + @property + def steps(self): + """Gets the steps of this UnfinishedStep. # noqa: E501 + + + :return: The steps of this UnfinishedStep. # noqa: E501 + :rtype: list[str] + """ + return self._steps + + @steps.setter + def steps(self, steps): + """Sets the steps of this UnfinishedStep. + + + :param steps: The steps of this UnfinishedStep. # noqa: E501 + :type: list[str] + """ + + self._steps = steps + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(UnfinishedStep, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, UnfinishedStep): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/unfinished_steps.py b/vendor/elabapi-python/elabapi_python/models/unfinished_steps.py new file mode 100644 index 0000000..708489e --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/unfinished_steps.py @@ -0,0 +1,136 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class UnfinishedSteps(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'experiments': 'list[UnfinishedStep]', + 'items': 'list[UnfinishedStep]' + } + + attribute_map = { + 'experiments': 'experiments', + 'items': 'items' + } + + def __init__(self, experiments=None, items=None): # noqa: E501 + """UnfinishedSteps - a model defined in Swagger""" # noqa: E501 + self._experiments = None + self._items = None + self.discriminator = None + if experiments is not None: + self.experiments = experiments + if items is not None: + self.items = items + + @property + def experiments(self): + """Gets the experiments of this UnfinishedSteps. # noqa: E501 + + + :return: The experiments of this UnfinishedSteps. # noqa: E501 + :rtype: list[UnfinishedStep] + """ + return self._experiments + + @experiments.setter + def experiments(self, experiments): + """Sets the experiments of this UnfinishedSteps. + + + :param experiments: The experiments of this UnfinishedSteps. # noqa: E501 + :type: list[UnfinishedStep] + """ + + self._experiments = experiments + + @property + def items(self): + """Gets the items of this UnfinishedSteps. # noqa: E501 + + + :return: The items of this UnfinishedSteps. # noqa: E501 + :rtype: list[UnfinishedStep] + """ + return self._items + + @items.setter + def items(self, items): + """Sets the items of this UnfinishedSteps. + + + :param items: The items of this UnfinishedSteps. # noqa: E501 + :type: list[UnfinishedStep] + """ + + self._items = items + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(UnfinishedSteps, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, UnfinishedSteps): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/upload.py b/vendor/elabapi-python/elabapi_python/models/upload.py new file mode 100644 index 0000000..3cdba20 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/upload.py @@ -0,0 +1,474 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Upload(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'real_name': 'str', + 'long_name': 'str', + 'comment': 'str', + 'item_id': 'int', + 'userid': 'int', + 'type': 'str', + 'created_at': 'str', + 'hash': 'str', + 'hash_algorithm': 'str', + 'storage': 'int', + 'filesize': 'int', + 'state': 'int', + 'immutable': 'int', + 'fullname': 'str' + } + + attribute_map = { + 'id': 'id', + 'real_name': 'real_name', + 'long_name': 'long_name', + 'comment': 'comment', + 'item_id': 'item_id', + 'userid': 'userid', + 'type': 'type', + 'created_at': 'created_at', + 'hash': 'hash', + 'hash_algorithm': 'hash_algorithm', + 'storage': 'storage', + 'filesize': 'filesize', + 'state': 'state', + 'immutable': 'immutable', + 'fullname': 'fullname' + } + + def __init__(self, id=None, real_name=None, long_name=None, comment=None, item_id=None, userid=None, type=None, created_at=None, hash=None, hash_algorithm=None, storage=None, filesize=None, state=None, immutable=None, fullname=None): # noqa: E501 + """Upload - a model defined in Swagger""" # noqa: E501 + self._id = None + self._real_name = None + self._long_name = None + self._comment = None + self._item_id = None + self._userid = None + self._type = None + self._created_at = None + self._hash = None + self._hash_algorithm = None + self._storage = None + self._filesize = None + self._state = None + self._immutable = None + self._fullname = None + self.discriminator = None + if id is not None: + self.id = id + if real_name is not None: + self.real_name = real_name + if long_name is not None: + self.long_name = long_name + if comment is not None: + self.comment = comment + if item_id is not None: + self.item_id = item_id + if userid is not None: + self.userid = userid + if type is not None: + self.type = type + if created_at is not None: + self.created_at = created_at + if hash is not None: + self.hash = hash + if hash_algorithm is not None: + self.hash_algorithm = hash_algorithm + if storage is not None: + self.storage = storage + if filesize is not None: + self.filesize = filesize + if state is not None: + self.state = state + if immutable is not None: + self.immutable = immutable + if fullname is not None: + self.fullname = fullname + + @property + def id(self): + """Gets the id of this Upload. # noqa: E501 + + + :return: The id of this Upload. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this Upload. + + + :param id: The id of this Upload. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def real_name(self): + """Gets the real_name of this Upload. # noqa: E501 + + + :return: The real_name of this Upload. # noqa: E501 + :rtype: str + """ + return self._real_name + + @real_name.setter + def real_name(self, real_name): + """Sets the real_name of this Upload. + + + :param real_name: The real_name of this Upload. # noqa: E501 + :type: str + """ + + self._real_name = real_name + + @property + def long_name(self): + """Gets the long_name of this Upload. # noqa: E501 + + + :return: The long_name of this Upload. # noqa: E501 + :rtype: str + """ + return self._long_name + + @long_name.setter + def long_name(self, long_name): + """Sets the long_name of this Upload. + + + :param long_name: The long_name of this Upload. # noqa: E501 + :type: str + """ + + self._long_name = long_name + + @property + def comment(self): + """Gets the comment of this Upload. # noqa: E501 + + + :return: The comment of this Upload. # noqa: E501 + :rtype: str + """ + return self._comment + + @comment.setter + def comment(self, comment): + """Sets the comment of this Upload. + + + :param comment: The comment of this Upload. # noqa: E501 + :type: str + """ + + self._comment = comment + + @property + def item_id(self): + """Gets the item_id of this Upload. # noqa: E501 + + + :return: The item_id of this Upload. # noqa: E501 + :rtype: int + """ + return self._item_id + + @item_id.setter + def item_id(self, item_id): + """Sets the item_id of this Upload. + + + :param item_id: The item_id of this Upload. # noqa: E501 + :type: int + """ + + self._item_id = item_id + + @property + def userid(self): + """Gets the userid of this Upload. # noqa: E501 + + + :return: The userid of this Upload. # noqa: E501 + :rtype: int + """ + return self._userid + + @userid.setter + def userid(self, userid): + """Sets the userid of this Upload. + + + :param userid: The userid of this Upload. # noqa: E501 + :type: int + """ + + self._userid = userid + + @property + def type(self): + """Gets the type of this Upload. # noqa: E501 + + + :return: The type of this Upload. # noqa: E501 + :rtype: str + """ + return self._type + + @type.setter + def type(self, type): + """Sets the type of this Upload. + + + :param type: The type of this Upload. # noqa: E501 + :type: str + """ + + self._type = type + + @property + def created_at(self): + """Gets the created_at of this Upload. # noqa: E501 + + + :return: The created_at of this Upload. # noqa: E501 + :rtype: str + """ + return self._created_at + + @created_at.setter + def created_at(self, created_at): + """Sets the created_at of this Upload. + + + :param created_at: The created_at of this Upload. # noqa: E501 + :type: str + """ + + self._created_at = created_at + + @property + def hash(self): + """Gets the hash of this Upload. # noqa: E501 + + + :return: The hash of this Upload. # noqa: E501 + :rtype: str + """ + return self._hash + + @hash.setter + def hash(self, hash): + """Sets the hash of this Upload. + + + :param hash: The hash of this Upload. # noqa: E501 + :type: str + """ + + self._hash = hash + + @property + def hash_algorithm(self): + """Gets the hash_algorithm of this Upload. # noqa: E501 + + + :return: The hash_algorithm of this Upload. # noqa: E501 + :rtype: str + """ + return self._hash_algorithm + + @hash_algorithm.setter + def hash_algorithm(self, hash_algorithm): + """Sets the hash_algorithm of this Upload. + + + :param hash_algorithm: The hash_algorithm of this Upload. # noqa: E501 + :type: str + """ + + self._hash_algorithm = hash_algorithm + + @property + def storage(self): + """Gets the storage of this Upload. # noqa: E501 + + + :return: The storage of this Upload. # noqa: E501 + :rtype: int + """ + return self._storage + + @storage.setter + def storage(self, storage): + """Sets the storage of this Upload. + + + :param storage: The storage of this Upload. # noqa: E501 + :type: int + """ + + self._storage = storage + + @property + def filesize(self): + """Gets the filesize of this Upload. # noqa: E501 + + + :return: The filesize of this Upload. # noqa: E501 + :rtype: int + """ + return self._filesize + + @filesize.setter + def filesize(self, filesize): + """Sets the filesize of this Upload. + + + :param filesize: The filesize of this Upload. # noqa: E501 + :type: int + """ + + self._filesize = filesize + + @property + def state(self): + """Gets the state of this Upload. # noqa: E501 + + + :return: The state of this Upload. # noqa: E501 + :rtype: int + """ + return self._state + + @state.setter + def state(self, state): + """Sets the state of this Upload. + + + :param state: The state of this Upload. # noqa: E501 + :type: int + """ + + self._state = state + + @property + def immutable(self): + """Gets the immutable of this Upload. # noqa: E501 + + + :return: The immutable of this Upload. # noqa: E501 + :rtype: int + """ + return self._immutable + + @immutable.setter + def immutable(self, immutable): + """Sets the immutable of this Upload. + + + :param immutable: The immutable of this Upload. # noqa: E501 + :type: int + """ + + self._immutable = immutable + + @property + def fullname(self): + """Gets the fullname of this Upload. # noqa: E501 + + + :return: The fullname of this Upload. # noqa: E501 + :rtype: str + """ + return self._fullname + + @fullname.setter + def fullname(self, fullname): + """Sets the fullname of this Upload. + + + :param fullname: The fullname of this Upload. # noqa: E501 + :type: str + """ + + self._fullname = fullname + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Upload, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Upload): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/uploads_subid_body.py b/vendor/elabapi-python/elabapi_python/models/uploads_subid_body.py new file mode 100644 index 0000000..6c42cee --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/uploads_subid_body.py @@ -0,0 +1,141 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class UploadsSubidBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'file': 'str', + 'comment': 'str' + } + + attribute_map = { + 'file': 'file', + 'comment': 'comment' + } + + def __init__(self, file=None, comment=None): # noqa: E501 + """UploadsSubidBody - a model defined in Swagger""" # noqa: E501 + self._file = None + self._comment = None + self.discriminator = None + self.file = file + if comment is not None: + self.comment = comment + + @property + def file(self): + """Gets the file of this UploadsSubidBody. # noqa: E501 + + The file to upload. # noqa: E501 + + :return: The file of this UploadsSubidBody. # noqa: E501 + :rtype: str + """ + return self._file + + @file.setter + def file(self, file): + """Sets the file of this UploadsSubidBody. + + The file to upload. # noqa: E501 + + :param file: The file of this UploadsSubidBody. # noqa: E501 + :type: str + """ + if file is None: + raise ValueError("Invalid value for `file`, must not be `None`") # noqa: E501 + + self._file = file + + @property + def comment(self): + """Gets the comment of this UploadsSubidBody. # noqa: E501 + + Optional file comment. # noqa: E501 + + :return: The comment of this UploadsSubidBody. # noqa: E501 + :rtype: str + """ + return self._comment + + @comment.setter + def comment(self, comment): + """Sets the comment of this UploadsSubidBody. + + Optional file comment. # noqa: E501 + + :param comment: The comment of this UploadsSubidBody. # noqa: E501 + :type: str + """ + + self._comment = comment + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(UploadsSubidBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, UploadsSubidBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/uploads_subid_body1.py b/vendor/elabapi-python/elabapi_python/models/uploads_subid_body1.py new file mode 100644 index 0000000..389f076 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/uploads_subid_body1.py @@ -0,0 +1,200 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class UploadsSubidBody1(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'action': 'str', + 'real_name': 'str', + 'comment': 'str', + 'state': 'int' + } + + attribute_map = { + 'action': 'action', + 'real_name': 'real_name', + 'comment': 'comment', + 'state': 'state' + } + + def __init__(self, action=None, real_name=None, comment=None, state=None): # noqa: E501 + """UploadsSubidBody1 - a model defined in Swagger""" # noqa: E501 + self._action = None + self._real_name = None + self._comment = None + self._state = None + self.discriminator = None + if action is not None: + self.action = action + if real_name is not None: + self.real_name = real_name + if comment is not None: + self.comment = comment + if state is not None: + self.state = state + + @property + def action(self): + """Gets the action of this UploadsSubidBody1. # noqa: E501 + + + :return: The action of this UploadsSubidBody1. # noqa: E501 + :rtype: str + """ + return self._action + + @action.setter + def action(self, action): + """Sets the action of this UploadsSubidBody1. + + + :param action: The action of this UploadsSubidBody1. # noqa: E501 + :type: str + """ + allowed_values = ["update"] # noqa: E501 + if action not in allowed_values: + raise ValueError( + "Invalid value for `action` ({0}), must be one of {1}" # noqa: E501 + .format(action, allowed_values) + ) + + self._action = action + + @property + def real_name(self): + """Gets the real_name of this UploadsSubidBody1. # noqa: E501 + + + :return: The real_name of this UploadsSubidBody1. # noqa: E501 + :rtype: str + """ + return self._real_name + + @real_name.setter + def real_name(self, real_name): + """Sets the real_name of this UploadsSubidBody1. + + + :param real_name: The real_name of this UploadsSubidBody1. # noqa: E501 + :type: str + """ + + self._real_name = real_name + + @property + def comment(self): + """Gets the comment of this UploadsSubidBody1. # noqa: E501 + + + :return: The comment of this UploadsSubidBody1. # noqa: E501 + :rtype: str + """ + return self._comment + + @comment.setter + def comment(self, comment): + """Sets the comment of this UploadsSubidBody1. + + + :param comment: The comment of this UploadsSubidBody1. # noqa: E501 + :type: str + """ + + self._comment = comment + + @property + def state(self): + """Gets the state of this UploadsSubidBody1. # noqa: E501 + + + :return: The state of this UploadsSubidBody1. # noqa: E501 + :rtype: int + """ + return self._state + + @state.setter + def state(self, state): + """Sets the state of this UploadsSubidBody1. + + + :param state: The state of this UploadsSubidBody1. # noqa: E501 + :type: int + """ + allowed_values = [1, 2, 3] # noqa: E501 + if state not in allowed_values: + raise ValueError( + "Invalid value for `state` ({0}), must be one of {1}" # noqa: E501 + .format(state, allowed_values) + ) + + self._state = state + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(UploadsSubidBody1, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, UploadsSubidBody1): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/users.py b/vendor/elabapi-python/elabapi_python/models/users.py new file mode 100644 index 0000000..da3844d --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/users.py @@ -0,0 +1,294 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class Users(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'userid': 'int', + 'firstname': 'str', + 'lastname': 'str', + 'initials': 'str', + 'email': 'str', + 'fullname': 'str', + 'orcid': 'str', + 'sig_pubkey': 'str' + } + + attribute_map = { + 'userid': 'userid', + 'firstname': 'firstname', + 'lastname': 'lastname', + 'initials': 'initials', + 'email': 'email', + 'fullname': 'fullname', + 'orcid': 'orcid', + 'sig_pubkey': 'sig_pubkey' + } + + def __init__(self, userid=None, firstname=None, lastname=None, initials=None, email=None, fullname=None, orcid=None, sig_pubkey=None): # noqa: E501 + """Users - a model defined in Swagger""" # noqa: E501 + self._userid = None + self._firstname = None + self._lastname = None + self._initials = None + self._email = None + self._fullname = None + self._orcid = None + self._sig_pubkey = None + self.discriminator = None + if userid is not None: + self.userid = userid + if firstname is not None: + self.firstname = firstname + if lastname is not None: + self.lastname = lastname + if initials is not None: + self.initials = initials + if email is not None: + self.email = email + if fullname is not None: + self.fullname = fullname + if orcid is not None: + self.orcid = orcid + if sig_pubkey is not None: + self.sig_pubkey = sig_pubkey + + @property + def userid(self): + """Gets the userid of this Users. # noqa: E501 + + + :return: The userid of this Users. # noqa: E501 + :rtype: int + """ + return self._userid + + @userid.setter + def userid(self, userid): + """Sets the userid of this Users. + + + :param userid: The userid of this Users. # noqa: E501 + :type: int + """ + + self._userid = userid + + @property + def firstname(self): + """Gets the firstname of this Users. # noqa: E501 + + + :return: The firstname of this Users. # noqa: E501 + :rtype: str + """ + return self._firstname + + @firstname.setter + def firstname(self, firstname): + """Sets the firstname of this Users. + + + :param firstname: The firstname of this Users. # noqa: E501 + :type: str + """ + + self._firstname = firstname + + @property + def lastname(self): + """Gets the lastname of this Users. # noqa: E501 + + + :return: The lastname of this Users. # noqa: E501 + :rtype: str + """ + return self._lastname + + @lastname.setter + def lastname(self, lastname): + """Sets the lastname of this Users. + + + :param lastname: The lastname of this Users. # noqa: E501 + :type: str + """ + + self._lastname = lastname + + @property + def initials(self): + """Gets the initials of this Users. # noqa: E501 + + + :return: The initials of this Users. # noqa: E501 + :rtype: str + """ + return self._initials + + @initials.setter + def initials(self, initials): + """Sets the initials of this Users. + + + :param initials: The initials of this Users. # noqa: E501 + :type: str + """ + + self._initials = initials + + @property + def email(self): + """Gets the email of this Users. # noqa: E501 + + + :return: The email of this Users. # noqa: E501 + :rtype: str + """ + return self._email + + @email.setter + def email(self, email): + """Sets the email of this Users. + + + :param email: The email of this Users. # noqa: E501 + :type: str + """ + + self._email = email + + @property + def fullname(self): + """Gets the fullname of this Users. # noqa: E501 + + + :return: The fullname of this Users. # noqa: E501 + :rtype: str + """ + return self._fullname + + @fullname.setter + def fullname(self, fullname): + """Sets the fullname of this Users. + + + :param fullname: The fullname of this Users. # noqa: E501 + :type: str + """ + + self._fullname = fullname + + @property + def orcid(self): + """Gets the orcid of this Users. # noqa: E501 + + + :return: The orcid of this Users. # noqa: E501 + :rtype: str + """ + return self._orcid + + @orcid.setter + def orcid(self, orcid): + """Sets the orcid of this Users. + + + :param orcid: The orcid of this Users. # noqa: E501 + :type: str + """ + + self._orcid = orcid + + @property + def sig_pubkey(self): + """Gets the sig_pubkey of this Users. # noqa: E501 + + Public signature key (minisign format) # noqa: E501 + + :return: The sig_pubkey of this Users. # noqa: E501 + :rtype: str + """ + return self._sig_pubkey + + @sig_pubkey.setter + def sig_pubkey(self, sig_pubkey): + """Sets the sig_pubkey of this Users. + + Public signature key (minisign format) # noqa: E501 + + :param sig_pubkey: The sig_pubkey of this Users. # noqa: E501 + :type: str + """ + + self._sig_pubkey = sig_pubkey + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(Users, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Users): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/users_body.py b/vendor/elabapi-python/elabapi_python/models/users_body.py new file mode 100644 index 0000000..7fe5e18 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/users_body.py @@ -0,0 +1,289 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class UsersBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'firstname': 'str', + 'lastname': 'str', + 'email': 'str', + 'team': 'int', + 'valid_until': 'str', + 'orgid': 'str', + 'usergroup': 'int' + } + + attribute_map = { + 'firstname': 'firstname', + 'lastname': 'lastname', + 'email': 'email', + 'team': 'team', + 'valid_until': 'valid_until', + 'orgid': 'orgid', + 'usergroup': 'usergroup' + } + + def __init__(self, firstname=None, lastname=None, email=None, team=None, valid_until=None, orgid=None, usergroup=None): # noqa: E501 + """UsersBody - a model defined in Swagger""" # noqa: E501 + self._firstname = None + self._lastname = None + self._email = None + self._team = None + self._valid_until = None + self._orgid = None + self._usergroup = None + self.discriminator = None + self.firstname = firstname + self.lastname = lastname + self.email = email + if team is not None: + self.team = team + if valid_until is not None: + self.valid_until = valid_until + if orgid is not None: + self.orgid = orgid + if usergroup is not None: + self.usergroup = usergroup + + @property + def firstname(self): + """Gets the firstname of this UsersBody. # noqa: E501 + + User's first name. # noqa: E501 + + :return: The firstname of this UsersBody. # noqa: E501 + :rtype: str + """ + return self._firstname + + @firstname.setter + def firstname(self, firstname): + """Sets the firstname of this UsersBody. + + User's first name. # noqa: E501 + + :param firstname: The firstname of this UsersBody. # noqa: E501 + :type: str + """ + if firstname is None: + raise ValueError("Invalid value for `firstname`, must not be `None`") # noqa: E501 + + self._firstname = firstname + + @property + def lastname(self): + """Gets the lastname of this UsersBody. # noqa: E501 + + User's last name. # noqa: E501 + + :return: The lastname of this UsersBody. # noqa: E501 + :rtype: str + """ + return self._lastname + + @lastname.setter + def lastname(self, lastname): + """Sets the lastname of this UsersBody. + + User's last name. # noqa: E501 + + :param lastname: The lastname of this UsersBody. # noqa: E501 + :type: str + """ + if lastname is None: + raise ValueError("Invalid value for `lastname`, must not be `None`") # noqa: E501 + + self._lastname = lastname + + @property + def email(self): + """Gets the email of this UsersBody. # noqa: E501 + + User's email address. # noqa: E501 + + :return: The email of this UsersBody. # noqa: E501 + :rtype: str + """ + return self._email + + @email.setter + def email(self, email): + """Sets the email of this UsersBody. + + User's email address. # noqa: E501 + + :param email: The email of this UsersBody. # noqa: E501 + :type: str + """ + if email is None: + raise ValueError("Invalid value for `email`, must not be `None`") # noqa: E501 + + self._email = email + + @property + def team(self): + """Gets the team of this UsersBody. # noqa: E501 + + The team id. # noqa: E501 + + :return: The team of this UsersBody. # noqa: E501 + :rtype: int + """ + return self._team + + @team.setter + def team(self, team): + """Sets the team of this UsersBody. + + The team id. # noqa: E501 + + :param team: The team of this UsersBody. # noqa: E501 + :type: int + """ + + self._team = team + + @property + def valid_until(self): + """Gets the valid_until of this UsersBody. # noqa: E501 + + Date in the YYYY-MM-DD format for account expiration date. # noqa: E501 + + :return: The valid_until of this UsersBody. # noqa: E501 + :rtype: str + """ + return self._valid_until + + @valid_until.setter + def valid_until(self, valid_until): + """Sets the valid_until of this UsersBody. + + Date in the YYYY-MM-DD format for account expiration date. # noqa: E501 + + :param valid_until: The valid_until of this UsersBody. # noqa: E501 + :type: str + """ + + self._valid_until = valid_until + + @property + def orgid(self): + """Gets the orgid of this UsersBody. # noqa: E501 + + Internal id. # noqa: E501 + + :return: The orgid of this UsersBody. # noqa: E501 + :rtype: str + """ + return self._orgid + + @orgid.setter + def orgid(self, orgid): + """Sets the orgid of this UsersBody. + + Internal id. # noqa: E501 + + :param orgid: The orgid of this UsersBody. # noqa: E501 + :type: str + """ + + self._orgid = orgid + + @property + def usergroup(self): + """Gets the usergroup of this UsersBody. # noqa: E501 + + Which permissions level the user will get? `1` is Sysadmin, `2` is Admin, `4` is user (default) # noqa: E501 + + :return: The usergroup of this UsersBody. # noqa: E501 + :rtype: int + """ + return self._usergroup + + @usergroup.setter + def usergroup(self, usergroup): + """Sets the usergroup of this UsersBody. + + Which permissions level the user will get? `1` is Sysadmin, `2` is Admin, `4` is user (default) # noqa: E501 + + :param usergroup: The usergroup of this UsersBody. # noqa: E501 + :type: int + """ + allowed_values = [1, 2, 4] # noqa: E501 + if usergroup not in allowed_values: + raise ValueError( + "Invalid value for `usergroup` ({0}), must be one of {1}" # noqa: E501 + .format(usergroup, allowed_values) + ) + + self._usergroup = usergroup + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(UsersBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, UsersBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/users_full.py b/vendor/elabapi-python/elabapi_python/models/users_full.py new file mode 100644 index 0000000..a7ef470 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/users_full.py @@ -0,0 +1,482 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six +from elabapi_python.models.users import Users # noqa: F401,E501 + +class UsersFull(Users): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'created_at': 'str', + 'validated': 'int', + 'valid_until': 'str', + 'last_login': 'str', + 'orgid': 'str', + 'auth_service': 'int', + 'is_sysadmin': 'int', + 'default_read': 'str', + 'default_read_base': 'float', + 'default_read_base_human': 'str', + 'default_write': 'str', + 'default_write_base': 'float', + 'default_write_base_human': 'str', + 'teams': 'list[UsersFullTeams]' + } + if hasattr(Users, "swagger_types"): + swagger_types.update(Users.swagger_types) + + attribute_map = { + 'created_at': 'created_at', + 'validated': 'validated', + 'valid_until': 'valid_until', + 'last_login': 'last_login', + 'orgid': 'orgid', + 'auth_service': 'auth_service', + 'is_sysadmin': 'is_sysadmin', + 'default_read': 'default_read', + 'default_read_base': 'default_read_base', + 'default_read_base_human': 'default_read_base_human', + 'default_write': 'default_write', + 'default_write_base': 'default_write_base', + 'default_write_base_human': 'default_write_base_human', + 'teams': 'teams' + } + if hasattr(Users, "attribute_map"): + attribute_map.update(Users.attribute_map) + + def __init__(self, created_at=None, validated=None, valid_until=None, last_login=None, orgid=None, auth_service=None, is_sysadmin=0, default_read='{"teams": [], "users": [], "teamgroups": []}', default_read_base=None, default_read_base_human=None, default_write='{"teams": [], "users": [], "teamgroups": []}', default_write_base=None, default_write_base_human=None, teams=None, *args, **kwargs): # noqa: E501 + """UsersFull - a model defined in Swagger""" # noqa: E501 + self._created_at = None + self._validated = None + self._valid_until = None + self._last_login = None + self._orgid = None + self._auth_service = None + self._is_sysadmin = None + self._default_read = None + self._default_read_base = None + self._default_read_base_human = None + self._default_write = None + self._default_write_base = None + self._default_write_base_human = None + self._teams = None + self.discriminator = None + if created_at is not None: + self.created_at = created_at + if validated is not None: + self.validated = validated + if valid_until is not None: + self.valid_until = valid_until + if last_login is not None: + self.last_login = last_login + if orgid is not None: + self.orgid = orgid + if auth_service is not None: + self.auth_service = auth_service + if is_sysadmin is not None: + self.is_sysadmin = is_sysadmin + if default_read is not None: + self.default_read = default_read + if default_read_base is not None: + self.default_read_base = default_read_base + if default_read_base_human is not None: + self.default_read_base_human = default_read_base_human + if default_write is not None: + self.default_write = default_write + if default_write_base is not None: + self.default_write_base = default_write_base + if default_write_base_human is not None: + self.default_write_base_human = default_write_base_human + if teams is not None: + self.teams = teams + Users.__init__(self, *args, **kwargs) + + @property + def created_at(self): + """Gets the created_at of this UsersFull. # noqa: E501 + + Account creation timestamp. # noqa: E501 + + :return: The created_at of this UsersFull. # noqa: E501 + :rtype: str + """ + return self._created_at + + @created_at.setter + def created_at(self, created_at): + """Sets the created_at of this UsersFull. + + Account creation timestamp. # noqa: E501 + + :param created_at: The created_at of this UsersFull. # noqa: E501 + :type: str + """ + + self._created_at = created_at + + @property + def validated(self): + """Gets the validated of this UsersFull. # noqa: E501 + + + :return: The validated of this UsersFull. # noqa: E501 + :rtype: int + """ + return self._validated + + @validated.setter + def validated(self, validated): + """Sets the validated of this UsersFull. + + + :param validated: The validated of this UsersFull. # noqa: E501 + :type: int + """ + + self._validated = validated + + @property + def valid_until(self): + """Gets the valid_until of this UsersFull. # noqa: E501 + + + :return: The valid_until of this UsersFull. # noqa: E501 + :rtype: str + """ + return self._valid_until + + @valid_until.setter + def valid_until(self, valid_until): + """Sets the valid_until of this UsersFull. + + + :param valid_until: The valid_until of this UsersFull. # noqa: E501 + :type: str + """ + + self._valid_until = valid_until + + @property + def last_login(self): + """Gets the last_login of this UsersFull. # noqa: E501 + + Last time a full authentication happened. # noqa: E501 + + :return: The last_login of this UsersFull. # noqa: E501 + :rtype: str + """ + return self._last_login + + @last_login.setter + def last_login(self, last_login): + """Sets the last_login of this UsersFull. + + Last time a full authentication happened. # noqa: E501 + + :param last_login: The last_login of this UsersFull. # noqa: E501 + :type: str + """ + + self._last_login = last_login + + @property + def orgid(self): + """Gets the orgid of this UsersFull. # noqa: E501 + + Internal organization id used to match user with something other than email. # noqa: E501 + + :return: The orgid of this UsersFull. # noqa: E501 + :rtype: str + """ + return self._orgid + + @orgid.setter + def orgid(self, orgid): + """Sets the orgid of this UsersFull. + + Internal organization id used to match user with something other than email. # noqa: E501 + + :param orgid: The orgid of this UsersFull. # noqa: E501 + :type: str + """ + + self._orgid = orgid + + @property + def auth_service(self): + """Gets the auth_service of this UsersFull. # noqa: E501 + + What mechanism was used to login, see AuthType Enum. # noqa: E501 + + :return: The auth_service of this UsersFull. # noqa: E501 + :rtype: int + """ + return self._auth_service + + @auth_service.setter + def auth_service(self, auth_service): + """Sets the auth_service of this UsersFull. + + What mechanism was used to login, see AuthType Enum. # noqa: E501 + + :param auth_service: The auth_service of this UsersFull. # noqa: E501 + :type: int + """ + + self._auth_service = auth_service + + @property + def is_sysadmin(self): + """Gets the is_sysadmin of this UsersFull. # noqa: E501 + + + :return: The is_sysadmin of this UsersFull. # noqa: E501 + :rtype: int + """ + return self._is_sysadmin + + @is_sysadmin.setter + def is_sysadmin(self, is_sysadmin): + """Sets the is_sysadmin of this UsersFull. + + + :param is_sysadmin: The is_sysadmin of this UsersFull. # noqa: E501 + :type: int + """ + + self._is_sysadmin = is_sysadmin + + @property + def default_read(self): + """Gets the default_read of this UsersFull. # noqa: E501 + + + :return: The default_read of this UsersFull. # noqa: E501 + :rtype: str + """ + return self._default_read + + @default_read.setter + def default_read(self, default_read): + """Sets the default_read of this UsersFull. + + + :param default_read: The default_read of this UsersFull. # noqa: E501 + :type: str + """ + + self._default_read = default_read + + @property + def default_read_base(self): + """Gets the default_read_base of this UsersFull. # noqa: E501 + + Base permission for default read access: - 10: Owner only - 20: Owner + Admins - 30: Team members - 40: Everyone with an account - 50: Everyone including anonymous users # noqa: E501 + + :return: The default_read_base of this UsersFull. # noqa: E501 + :rtype: float + """ + return self._default_read_base + + @default_read_base.setter + def default_read_base(self, default_read_base): + """Sets the default_read_base of this UsersFull. + + Base permission for default read access: - 10: Owner only - 20: Owner + Admins - 30: Team members - 40: Everyone with an account - 50: Everyone including anonymous users # noqa: E501 + + :param default_read_base: The default_read_base of this UsersFull. # noqa: E501 + :type: float + """ + allowed_values = [10, 20, 30, 40, 50] # noqa: E501 + if default_read_base not in allowed_values: + raise ValueError( + "Invalid value for `default_read_base` ({0}), must be one of {1}" # noqa: E501 + .format(default_read_base, allowed_values) + ) + + self._default_read_base = default_read_base + + @property + def default_read_base_human(self): + """Gets the default_read_base_human of this UsersFull. # noqa: E501 + + Default read base permission as human readable value # noqa: E501 + + :return: The default_read_base_human of this UsersFull. # noqa: E501 + :rtype: str + """ + return self._default_read_base_human + + @default_read_base_human.setter + def default_read_base_human(self, default_read_base_human): + """Sets the default_read_base_human of this UsersFull. + + Default read base permission as human readable value # noqa: E501 + + :param default_read_base_human: The default_read_base_human of this UsersFull. # noqa: E501 + :type: str + """ + + self._default_read_base_human = default_read_base_human + + @property + def default_write(self): + """Gets the default_write of this UsersFull. # noqa: E501 + + + :return: The default_write of this UsersFull. # noqa: E501 + :rtype: str + """ + return self._default_write + + @default_write.setter + def default_write(self, default_write): + """Sets the default_write of this UsersFull. + + + :param default_write: The default_write of this UsersFull. # noqa: E501 + :type: str + """ + + self._default_write = default_write + + @property + def default_write_base(self): + """Gets the default_write_base of this UsersFull. # noqa: E501 + + Base permission for default write access: - 10: Owner only - 20: Owner + Admins - 30: Team members - 40: Everyone with an account - 50: Everyone including anonymous users # noqa: E501 + + :return: The default_write_base of this UsersFull. # noqa: E501 + :rtype: float + """ + return self._default_write_base + + @default_write_base.setter + def default_write_base(self, default_write_base): + """Sets the default_write_base of this UsersFull. + + Base permission for default write access: - 10: Owner only - 20: Owner + Admins - 30: Team members - 40: Everyone with an account - 50: Everyone including anonymous users # noqa: E501 + + :param default_write_base: The default_write_base of this UsersFull. # noqa: E501 + :type: float + """ + allowed_values = [10, 20, 30, 40, 50] # noqa: E501 + if default_write_base not in allowed_values: + raise ValueError( + "Invalid value for `default_write_base` ({0}), must be one of {1}" # noqa: E501 + .format(default_write_base, allowed_values) + ) + + self._default_write_base = default_write_base + + @property + def default_write_base_human(self): + """Gets the default_write_base_human of this UsersFull. # noqa: E501 + + Default write base permission as human readable value # noqa: E501 + + :return: The default_write_base_human of this UsersFull. # noqa: E501 + :rtype: str + """ + return self._default_write_base_human + + @default_write_base_human.setter + def default_write_base_human(self, default_write_base_human): + """Sets the default_write_base_human of this UsersFull. + + Default write base permission as human readable value # noqa: E501 + + :param default_write_base_human: The default_write_base_human of this UsersFull. # noqa: E501 + :type: str + """ + + self._default_write_base_human = default_write_base_human + + @property + def teams(self): + """Gets the teams of this UsersFull. # noqa: E501 + + + :return: The teams of this UsersFull. # noqa: E501 + :rtype: list[UsersFullTeams] + """ + return self._teams + + @teams.setter + def teams(self, teams): + """Sets the teams of this UsersFull. + + + :param teams: The teams of this UsersFull. # noqa: E501 + :type: list[UsersFullTeams] + """ + + self._teams = teams + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(UsersFull, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, UsersFull): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/users_full_teams.py b/vendor/elabapi-python/elabapi_python/models/users_full_teams.py new file mode 100644 index 0000000..71462a3 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/users_full_teams.py @@ -0,0 +1,214 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class UsersFullTeams(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'id': 'int', + 'name': 'str', + 'is_admin': 'int', + 'is_owner': 'int', + 'is_archived': 'int' + } + + attribute_map = { + 'id': 'id', + 'name': 'name', + 'is_admin': 'is_admin', + 'is_owner': 'is_owner', + 'is_archived': 'is_archived' + } + + def __init__(self, id=None, name=None, is_admin=None, is_owner=None, is_archived=None): # noqa: E501 + """UsersFullTeams - a model defined in Swagger""" # noqa: E501 + self._id = None + self._name = None + self._is_admin = None + self._is_owner = None + self._is_archived = None + self.discriminator = None + if id is not None: + self.id = id + if name is not None: + self.name = name + if is_admin is not None: + self.is_admin = is_admin + if is_owner is not None: + self.is_owner = is_owner + if is_archived is not None: + self.is_archived = is_archived + + @property + def id(self): + """Gets the id of this UsersFullTeams. # noqa: E501 + + + :return: The id of this UsersFullTeams. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this UsersFullTeams. + + + :param id: The id of this UsersFullTeams. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def name(self): + """Gets the name of this UsersFullTeams. # noqa: E501 + + + :return: The name of this UsersFullTeams. # noqa: E501 + :rtype: str + """ + return self._name + + @name.setter + def name(self, name): + """Sets the name of this UsersFullTeams. + + + :param name: The name of this UsersFullTeams. # noqa: E501 + :type: str + """ + + self._name = name + + @property + def is_admin(self): + """Gets the is_admin of this UsersFullTeams. # noqa: E501 + + + :return: The is_admin of this UsersFullTeams. # noqa: E501 + :rtype: int + """ + return self._is_admin + + @is_admin.setter + def is_admin(self, is_admin): + """Sets the is_admin of this UsersFullTeams. + + + :param is_admin: The is_admin of this UsersFullTeams. # noqa: E501 + :type: int + """ + + self._is_admin = is_admin + + @property + def is_owner(self): + """Gets the is_owner of this UsersFullTeams. # noqa: E501 + + + :return: The is_owner of this UsersFullTeams. # noqa: E501 + :rtype: int + """ + return self._is_owner + + @is_owner.setter + def is_owner(self, is_owner): + """Sets the is_owner of this UsersFullTeams. + + + :param is_owner: The is_owner of this UsersFullTeams. # noqa: E501 + :type: int + """ + + self._is_owner = is_owner + + @property + def is_archived(self): + """Gets the is_archived of this UsersFullTeams. # noqa: E501 + + + :return: The is_archived of this UsersFullTeams. # noqa: E501 + :rtype: int + """ + return self._is_archived + + @is_archived.setter + def is_archived(self, is_archived): + """Sets the is_archived of this UsersFullTeams. + + + :param is_archived: The is_archived of this UsersFullTeams. # noqa: E501 + :type: int + """ + + self._is_archived = is_archived + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(UsersFullTeams, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, UsersFullTeams): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/models/users_id_body.py b/vendor/elabapi-python/elabapi_python/models/users_id_body.py new file mode 100644 index 0000000..9822367 --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/models/users_id_body.py @@ -0,0 +1,84 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +import pprint +import re # noqa: F401 + +import six + +class UsersIdBody(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + } + + attribute_map = { + } + + def __init__(self): # noqa: E501 + """UsersIdBody - a model defined in Swagger""" # noqa: E501 + self.discriminator = None + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(UsersIdBody, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, UsersIdBody): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/vendor/elabapi-python/elabapi_python/rest.py b/vendor/elabapi-python/elabapi_python/rest.py new file mode 100644 index 0000000..c6aa9ac --- /dev/null +++ b/vendor/elabapi-python/elabapi_python/rest.py @@ -0,0 +1,317 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import io +import json +import logging +import re +import ssl + +import certifi +# python 2 and python 3 compatibility library +import six +from six.moves.urllib.parse import urlencode + +try: + import urllib3 +except ImportError: + raise ImportError('Swagger python client requires urllib3.') + + +logger = logging.getLogger(__name__) + + +class RESTResponse(io.IOBase): + + def __init__(self, resp): + self.urllib3_response = resp + self.status = resp.status + self.reason = resp.reason + self.data = resp.data + + def getheaders(self): + """Returns a dictionary of the response headers.""" + return self.urllib3_response.headers + + def getheader(self, name, default=None): + """Returns a given response header.""" + return self.urllib3_response.headers.get(name, default) + + +class RESTClientObject(object): + + def __init__(self, configuration, pools_size=4, maxsize=None): + # urllib3.PoolManager will pass all kw parameters to connectionpool + # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/poolmanager.py#L75 # noqa: E501 + # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/connectionpool.py#L680 # noqa: E501 + # maxsize is the number of requests to host that are allowed in parallel # noqa: E501 + # Custom SSL certificates and client certificates: http://urllib3.readthedocs.io/en/latest/advanced-usage.html # noqa: E501 + + # cert_reqs + if configuration.verify_ssl: + cert_reqs = ssl.CERT_REQUIRED + else: + cert_reqs = ssl.CERT_NONE + + # ca_certs + if configuration.ssl_ca_cert: + ca_certs = configuration.ssl_ca_cert + else: + # if not set certificate file, use Mozilla's root certificates. + ca_certs = certifi.where() + + addition_pool_args = {} + if configuration.assert_hostname is not None: + addition_pool_args['assert_hostname'] = configuration.assert_hostname # noqa: E501 + + if maxsize is None: + if configuration.connection_pool_maxsize is not None: + maxsize = configuration.connection_pool_maxsize + else: + maxsize = 4 + + # https pool manager + if configuration.proxy: + self.pool_manager = urllib3.ProxyManager( + num_pools=pools_size, + maxsize=maxsize, + cert_reqs=cert_reqs, + ca_certs=ca_certs, + cert_file=configuration.cert_file, + key_file=configuration.key_file, + proxy_url=configuration.proxy, + **addition_pool_args + ) + else: + self.pool_manager = urllib3.PoolManager( + num_pools=pools_size, + maxsize=maxsize, + cert_reqs=cert_reqs, + ca_certs=ca_certs, + cert_file=configuration.cert_file, + key_file=configuration.key_file, + **addition_pool_args + ) + + def request(self, method, url, query_params=None, headers=None, + body=None, post_params=None, _preload_content=True, + _request_timeout=None): + """Perform requests. + + :param method: http request method + :param url: http request url + :param query_params: query parameters in the url + :param headers: http request headers + :param body: request json body, for `application/json` + :param post_params: request post parameters, + `application/x-www-form-urlencoded` + and `multipart/form-data` + :param _preload_content: if False, the urllib3.HTTPResponse object will + be returned without reading/decoding response + data. Default is True. + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + """ + method = method.upper() + assert method in ['GET', 'HEAD', 'DELETE', 'POST', 'PUT', + 'PATCH', 'OPTIONS'] + + if post_params and body: + raise ValueError( + "body parameter cannot be used with post_params parameter." + ) + + post_params = post_params or {} + headers = headers or {} + + timeout = None + if _request_timeout: + if isinstance(_request_timeout, (int, ) if six.PY3 else (int, long)): # noqa: E501,F821 + timeout = urllib3.Timeout(total=_request_timeout) + elif (isinstance(_request_timeout, tuple) and + len(_request_timeout) == 2): + timeout = urllib3.Timeout( + connect=_request_timeout[0], read=_request_timeout[1]) + + if 'Content-Type' not in headers: + headers['Content-Type'] = 'application/json' + + try: + # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE` + if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']: + if query_params: + url += '?' + urlencode(query_params) + if re.search('json', headers['Content-Type'], re.IGNORECASE): + request_body = '{}' + if body is not None: + request_body = json.dumps(body) + r = self.pool_manager.request( + method, url, + body=request_body, + preload_content=_preload_content, + timeout=timeout, + headers=headers) + elif headers['Content-Type'] == 'application/x-www-form-urlencoded': # noqa: E501 + r = self.pool_manager.request( + method, url, + fields=post_params, + encode_multipart=False, + preload_content=_preload_content, + timeout=timeout, + headers=headers) + elif headers['Content-Type'] == 'multipart/form-data': + # must del headers['Content-Type'], or the correct + # Content-Type which generated by urllib3 will be + # overwritten. + del headers['Content-Type'] + r = self.pool_manager.request( + method, url, + fields=post_params, + encode_multipart=True, + preload_content=_preload_content, + timeout=timeout, + headers=headers) + # Pass a `string` parameter directly in the body to support + # other content types than Json when `body` argument is + # provided in serialized form + elif isinstance(body, str): + request_body = body + r = self.pool_manager.request( + method, url, + body=request_body, + preload_content=_preload_content, + timeout=timeout, + headers=headers) + else: + # Cannot generate the request from given parameters + msg = """Cannot prepare a request message for provided + arguments. Please check that your arguments match + declared content type.""" + raise ApiException(status=0, reason=msg) + # For `GET`, `HEAD` + else: + r = self.pool_manager.request(method, url, + fields=query_params, + preload_content=_preload_content, + timeout=timeout, + headers=headers) + except urllib3.exceptions.SSLError as e: + msg = "{0}\n{1}".format(type(e).__name__, str(e)) + raise ApiException(status=0, reason=msg) + + if _preload_content: + r = RESTResponse(r) + + # log response body + logger.debug("response body: %s", r.data) + + if not 200 <= r.status <= 299: + raise ApiException(http_resp=r) + + return r + + def GET(self, url, headers=None, query_params=None, _preload_content=True, + _request_timeout=None): + return self.request("GET", url, + headers=headers, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + query_params=query_params) + + def HEAD(self, url, headers=None, query_params=None, _preload_content=True, + _request_timeout=None): + return self.request("HEAD", url, + headers=headers, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + query_params=query_params) + + def OPTIONS(self, url, headers=None, query_params=None, post_params=None, + body=None, _preload_content=True, _request_timeout=None): + return self.request("OPTIONS", url, + headers=headers, + query_params=query_params, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + + def DELETE(self, url, headers=None, query_params=None, body=None, + _preload_content=True, _request_timeout=None): + return self.request("DELETE", url, + headers=headers, + query_params=query_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + + def POST(self, url, headers=None, query_params=None, post_params=None, + body=None, _preload_content=True, _request_timeout=None): + return self.request("POST", url, + headers=headers, + query_params=query_params, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + + def PUT(self, url, headers=None, query_params=None, post_params=None, + body=None, _preload_content=True, _request_timeout=None): + return self.request("PUT", url, + headers=headers, + query_params=query_params, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + + def PATCH(self, url, headers=None, query_params=None, post_params=None, + body=None, _preload_content=True, _request_timeout=None): + return self.request("PATCH", url, + headers=headers, + query_params=query_params, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + + +class ApiException(Exception): + + def __init__(self, status=None, reason=None, http_resp=None): + if http_resp: + self.status = http_resp.status + self.reason = http_resp.reason + self.body = http_resp.data + self.headers = http_resp.getheaders() + else: + self.status = status + self.reason = reason + self.body = None + self.headers = None + + def __str__(self): + """Custom error messages for exception""" + error_message = "({0})\n"\ + "Reason: {1}\n".format(self.status, self.reason) + if self.headers: + error_message += "HTTP response headers: {0}\n".format( + self.headers) + + if self.body: + error_message += "HTTP response body: {0}\n".format(self.body) + + return error_message diff --git a/vendor/elabapi-python/setup.cfg b/vendor/elabapi-python/setup.cfg new file mode 100644 index 0000000..8bfd5a1 --- /dev/null +++ b/vendor/elabapi-python/setup.cfg @@ -0,0 +1,4 @@ +[egg_info] +tag_build = +tag_date = 0 + diff --git a/vendor/elabapi-python/setup.py b/vendor/elabapi-python/setup.py new file mode 100644 index 0000000..8ab3c92 --- /dev/null +++ b/vendor/elabapi-python/setup.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from setuptools import setup, find_packages # noqa: H301 + +NAME = "elabapi-python" +VERSION = "5.6.1" +# To install the library, run the following +# +# python setup.py install +# +# prerequisite: setuptools +# http://pypi.python.org/pypi/setuptools + +REQUIRES = ["urllib3 >= 1.15", "six >= 1.10", "certifi", "python-dateutil"] + +setup( + name=NAME, + version=VERSION, + description="eLabFTW REST API v2 Documentation", + author_email="", + url="https://github.com/elabftw/elabapi-python", + keywords=["Swagger", "eLabFTW REST API v2 Documentation"], + install_requires=REQUIRES, + packages=find_packages(), + include_package_data=True, + long_description="""\ + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + """ +) diff --git a/vendor/elabapi-python/test/__init__.py b/vendor/elabapi-python/test/__init__.py new file mode 100644 index 0000000..576f56f --- /dev/null +++ b/vendor/elabapi-python/test/__init__.py @@ -0,0 +1 @@ +# coding: utf-8 \ No newline at end of file diff --git a/vendor/elabapi-python/test/test_all_ofentity_editable_metadatamerge.py b/vendor/elabapi-python/test/test_all_ofentity_editable_metadatamerge.py new file mode 100644 index 0000000..6398f51 --- /dev/null +++ b/vendor/elabapi-python/test/test_all_ofentity_editable_metadatamerge.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.all_ofentity_editable_metadatamerge import AllOfentityEditableMetadatamerge # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestAllOfentityEditableMetadatamerge(unittest.TestCase): + """AllOfentityEditableMetadatamerge unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testAllOfentityEditableMetadatamerge(self): + """Test AllOfentityEditableMetadatamerge""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.all_ofentity_editable_metadatamerge.AllOfentityEditableMetadatamerge() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_any_ofuploads_subid_body1.py b/vendor/elabapi-python/test/test_any_ofuploads_subid_body1.py new file mode 100644 index 0000000..9c123f5 --- /dev/null +++ b/vendor/elabapi-python/test/test_any_ofuploads_subid_body1.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.any_ofuploads_subid_body1 import AnyOfuploadsSubidBody1 # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestAnyOfuploadsSubidBody1(unittest.TestCase): + """AnyOfuploadsSubidBody1 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testAnyOfuploadsSubidBody1(self): + """Test AnyOfuploadsSubidBody1""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.any_ofuploads_subid_body1.AnyOfuploadsSubidBody1() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_api_keys_api.py b/vendor/elabapi-python/test/test_api_keys_api.py new file mode 100644 index 0000000..cbda4a5 --- /dev/null +++ b/vendor/elabapi-python/test/test_api_keys_api.py @@ -0,0 +1,54 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.api_keys_api import ApiKeysApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestApiKeysApi(unittest.TestCase): + """ApiKeysApi unit test stubs""" + + def setUp(self): + self.api = ApiKeysApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_apikey(self): + """Test case for delete_apikey + + Delete an API key. # noqa: E501 + """ + pass + + def test_get_apikeys(self): + """Test case for get_apikeys + + Read API keys # noqa: E501 + """ + pass + + def test_post_apikeys(self): + """Test case for post_apikeys + + Create an API key # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_apikey.py b/vendor/elabapi-python/test/test_apikey.py new file mode 100644 index 0000000..7db9c26 --- /dev/null +++ b/vendor/elabapi-python/test/test_apikey.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.apikey import Apikey # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestApikey(unittest.TestCase): + """Apikey unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testApikey(self): + """Test Apikey""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.apikey.Apikey() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_apikeys_body.py b/vendor/elabapi-python/test/test_apikeys_body.py new file mode 100644 index 0000000..2037483 --- /dev/null +++ b/vendor/elabapi-python/test/test_apikeys_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.apikeys_body import ApikeysBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestApikeysBody(unittest.TestCase): + """ApikeysBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testApikeysBody(self): + """Test ApikeysBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.apikeys_body.ApikeysBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_branding_api.py b/vendor/elabapi-python/test/test_branding_api.py new file mode 100644 index 0000000..5296d2f --- /dev/null +++ b/vendor/elabapi-python/test/test_branding_api.py @@ -0,0 +1,47 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.branding_api import BrandingApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestBrandingApi(unittest.TestCase): + """BrandingApi unit test stubs""" + + def setUp(self): + self.api = BrandingApi() # noqa: E501 + + def tearDown(self): + pass + + def test_get_instance_branding(self): + """Test case for get_instance_branding + + Read a branding asset as a binary file. # noqa: E501 + """ + pass + + def test_post_instance_branding(self): + """Test case for post_instance_branding + + Update a branding asset. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_branding_id_body.py b/vendor/elabapi-python/test/test_branding_id_body.py new file mode 100644 index 0000000..7ca5155 --- /dev/null +++ b/vendor/elabapi-python/test/test_branding_id_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.branding_id_body import BrandingIdBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestBrandingIdBody(unittest.TestCase): + """BrandingIdBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testBrandingIdBody(self): + """Test BrandingIdBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.branding_id_body.BrandingIdBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_changelog.py b/vendor/elabapi-python/test/test_changelog.py new file mode 100644 index 0000000..2735e36 --- /dev/null +++ b/vendor/elabapi-python/test/test_changelog.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.changelog import Changelog # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestChangelog(unittest.TestCase): + """Changelog unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testChangelog(self): + """Test Changelog""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.changelog.Changelog() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_comment.py b/vendor/elabapi-python/test/test_comment.py new file mode 100644 index 0000000..de675c8 --- /dev/null +++ b/vendor/elabapi-python/test/test_comment.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.comment import Comment # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestComment(unittest.TestCase): + """Comment unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testComment(self): + """Test Comment""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.comment.Comment() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_comments_api.py b/vendor/elabapi-python/test/test_comments_api.py new file mode 100644 index 0000000..3b59b24 --- /dev/null +++ b/vendor/elabapi-python/test/test_comments_api.py @@ -0,0 +1,68 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.comments_api import CommentsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestCommentsApi(unittest.TestCase): + """CommentsApi unit test stubs""" + + def setUp(self): + self.api = CommentsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_entity_comment(self): + """Test case for delete_entity_comment + + Delete an entity comment. # noqa: E501 + """ + pass + + def test_patch_entity_comment(self): + """Test case for patch_entity_comment + + Modify an entity comment. # noqa: E501 + """ + pass + + def test_post_entity_comments(self): + """Test case for post_entity_comments + + Create a comment. # noqa: E501 + """ + pass + + def test_read_entity_comment(self): + """Test case for read_entity_comment + + Read a comment of that entity. # noqa: E501 + """ + pass + + def test_read_entity_comments(self): + """Test case for read_entity_comments + + Read all comments of that entity. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_compound.py b/vendor/elabapi-python/test/test_compound.py new file mode 100644 index 0000000..384f6df --- /dev/null +++ b/vendor/elabapi-python/test/test_compound.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.compound import Compound # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestCompound(unittest.TestCase): + """Compound unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testCompound(self): + """Test Compound""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.compound.Compound() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_compound_create_request.py b/vendor/elabapi-python/test/test_compound_create_request.py new file mode 100644 index 0000000..9f5cb74 --- /dev/null +++ b/vendor/elabapi-python/test/test_compound_create_request.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.compound_create_request import CompoundCreateRequest # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestCompoundCreateRequest(unittest.TestCase): + """CompoundCreateRequest unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testCompoundCreateRequest(self): + """Test CompoundCreateRequest""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.compound_create_request.CompoundCreateRequest() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_compound_duplicate_request.py b/vendor/elabapi-python/test/test_compound_duplicate_request.py new file mode 100644 index 0000000..a66b2b4 --- /dev/null +++ b/vendor/elabapi-python/test/test_compound_duplicate_request.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.compound_duplicate_request import CompoundDuplicateRequest # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestCompoundDuplicateRequest(unittest.TestCase): + """CompoundDuplicateRequest unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testCompoundDuplicateRequest(self): + """Test CompoundDuplicateRequest""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.compound_duplicate_request.CompoundDuplicateRequest() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_compounds_api.py b/vendor/elabapi-python/test/test_compounds_api.py new file mode 100644 index 0000000..94f349a --- /dev/null +++ b/vendor/elabapi-python/test/test_compounds_api.py @@ -0,0 +1,61 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.compounds_api import CompoundsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestCompoundsApi(unittest.TestCase): + """CompoundsApi unit test stubs""" + + def setUp(self): + self.api = CompoundsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_compound(self): + """Test case for delete_compound + + Soft-delete a compound # noqa: E501 + """ + pass + + def test_get_compound(self): + """Test case for get_compound + + Get a single compound # noqa: E501 + """ + pass + + def test_get_compounds(self): + """Test case for get_compounds + + Read compounds # noqa: E501 + """ + pass + + def test_post_compounds(self): + """Test case for post_compounds + + Create or import a compound # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_compounds_body.py b/vendor/elabapi-python/test/test_compounds_body.py new file mode 100644 index 0000000..88a6fa4 --- /dev/null +++ b/vendor/elabapi-python/test/test_compounds_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.compounds_body import CompoundsBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestCompoundsBody(unittest.TestCase): + """CompoundsBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testCompoundsBody(self): + """Test CompoundsBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.compounds_body.CompoundsBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_compounds_links_subid_body.py b/vendor/elabapi-python/test/test_compounds_links_subid_body.py new file mode 100644 index 0000000..33b88e8 --- /dev/null +++ b/vendor/elabapi-python/test/test_compounds_links_subid_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.compounds_links_subid_body import CompoundsLinksSubidBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestCompoundsLinksSubidBody(unittest.TestCase): + """CompoundsLinksSubidBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testCompoundsLinksSubidBody(self): + """Test CompoundsLinksSubidBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.compounds_links_subid_body.CompoundsLinksSubidBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_config.py b/vendor/elabapi-python/test/test_config.py new file mode 100644 index 0000000..0fe2634 --- /dev/null +++ b/vendor/elabapi-python/test/test_config.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.config import Config # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestConfig(unittest.TestCase): + """Config unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testConfig(self): + """Test Config""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.config.Config() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_config_api.py b/vendor/elabapi-python/test/test_config_api.py new file mode 100644 index 0000000..fbffcc0 --- /dev/null +++ b/vendor/elabapi-python/test/test_config_api.py @@ -0,0 +1,54 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.config_api import ConfigApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestConfigApi(unittest.TestCase): + """ConfigApi unit test stubs""" + + def setUp(self): + self.api = ConfigApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_config(self): + """Test case for delete_config + + Reset the config to default values # noqa: E501 + """ + pass + + def test_get_config(self): + """Test case for get_config + + Read the config # noqa: E501 + """ + pass + + def test_patch_config(self): + """Test case for patch_config + + Modify the config # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_container.py b/vendor/elabapi-python/test/test_container.py new file mode 100644 index 0000000..fa8a416 --- /dev/null +++ b/vendor/elabapi-python/test/test_container.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.container import Container # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestContainer(unittest.TestCase): + """Container unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testContainer(self): + """Test Container""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.container.Container() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_containers_api.py b/vendor/elabapi-python/test/test_containers_api.py new file mode 100644 index 0000000..3224dae --- /dev/null +++ b/vendor/elabapi-python/test/test_containers_api.py @@ -0,0 +1,68 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.containers_api import ContainersApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestContainersApi(unittest.TestCase): + """ContainersApi unit test stubs""" + + def setUp(self): + self.api = ContainersApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_container(self): + """Test case for delete_container + + Delete a container. # noqa: E501 + """ + pass + + def test_patch_container(self): + """Test case for patch_container + + Modify a container. # noqa: E501 + """ + pass + + def test_post_container(self): + """Test case for post_container + + Create a container for this entity. # noqa: E501 + """ + pass + + def test_read_container(self): + """Test case for read_container + + Read a container. # noqa: E501 + """ + pass + + def test_read_containers(self): + """Test case for read_containers + + Read all containers for this entity. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_containers_subid_body.py b/vendor/elabapi-python/test/test_containers_subid_body.py new file mode 100644 index 0000000..53566a1 --- /dev/null +++ b/vendor/elabapi-python/test/test_containers_subid_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.containers_subid_body import ContainersSubidBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestContainersSubidBody(unittest.TestCase): + """ContainersSubidBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testContainersSubidBody(self): + """Test ContainersSubidBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.containers_subid_body.ContainersSubidBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_containers_subid_body1.py b/vendor/elabapi-python/test/test_containers_subid_body1.py new file mode 100644 index 0000000..1471aa9 --- /dev/null +++ b/vendor/elabapi-python/test/test_containers_subid_body1.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.containers_subid_body1 import ContainersSubidBody1 # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestContainersSubidBody1(unittest.TestCase): + """ContainersSubidBody1 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testContainersSubidBody1(self): + """Test ContainersSubidBody1""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.containers_subid_body1.ContainersSubidBody1() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_custom_fields_keys_api.py b/vendor/elabapi-python/test/test_custom_fields_keys_api.py new file mode 100644 index 0000000..37628ed --- /dev/null +++ b/vendor/elabapi-python/test/test_custom_fields_keys_api.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.custom_fields_keys_api import CustomFieldsKeysApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestCustomFieldsKeysApi(unittest.TestCase): + """CustomFieldsKeysApi unit test stubs""" + + def setUp(self): + self.api = CustomFieldsKeysApi() # noqa: E501 + + def tearDown(self): + pass + + def test_custom_fields_keys(self): + """Test case for custom_fields_keys + + Read custom fields keys. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_d_space_api.py b/vendor/elabapi-python/test/test_d_space_api.py new file mode 100644 index 0000000..3f35609 --- /dev/null +++ b/vendor/elabapi-python/test/test_d_space_api.py @@ -0,0 +1,54 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.d_space_api import DSpaceApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestDSpaceApi(unittest.TestCase): + """DSpaceApi unit test stubs""" + + def setUp(self): + self.api = DSpaceApi() # noqa: E501 + + def tearDown(self): + pass + + def test_dspace_create(self): + """Test case for dspace_create + + Create a new DSpace workspace item. # noqa: E501 + """ + pass + + def test_dspace_read(self): + """Test case for dspace_read + + Read DSpace information. # noqa: E501 + """ + pass + + def test_dspace_submit(self): + """Test case for dspace_submit + + Submit an eLabFTW entry to DSpace. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_dspace_body.py b/vendor/elabapi-python/test/test_dspace_body.py new file mode 100644 index 0000000..b7de155 --- /dev/null +++ b/vendor/elabapi-python/test/test_dspace_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.dspace_body import DspaceBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestDspaceBody(unittest.TestCase): + """DspaceBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testDspaceBody(self): + """Test DspaceBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.dspace_body.DspaceBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_dspace_body1.py b/vendor/elabapi-python/test/test_dspace_body1.py new file mode 100644 index 0000000..3f8e423 --- /dev/null +++ b/vendor/elabapi-python/test/test_dspace_body1.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.dspace_body1 import DspaceBody1 # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestDspaceBody1(unittest.TestCase): + """DspaceBody1 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testDspaceBody1(self): + """Test DspaceBody1""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.dspace_body1.DspaceBody1() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_dspace_entity.py b/vendor/elabapi-python/test/test_dspace_entity.py new file mode 100644 index 0000000..caa3f4c --- /dev/null +++ b/vendor/elabapi-python/test/test_dspace_entity.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.dspace_entity import DspaceEntity # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestDspaceEntity(unittest.TestCase): + """DspaceEntity unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testDspaceEntity(self): + """Test DspaceEntity""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.dspace_entity.DspaceEntity() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_dspace_metadata.py b/vendor/elabapi-python/test/test_dspace_metadata.py new file mode 100644 index 0000000..a1f7ecb --- /dev/null +++ b/vendor/elabapi-python/test/test_dspace_metadata.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.dspace_metadata import DspaceMetadata # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestDspaceMetadata(unittest.TestCase): + """DspaceMetadata unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testDspaceMetadata(self): + """Test DspaceMetadata""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.dspace_metadata.DspaceMetadata() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_dspace_metadata1.py b/vendor/elabapi-python/test/test_dspace_metadata1.py new file mode 100644 index 0000000..3bfec8f --- /dev/null +++ b/vendor/elabapi-python/test/test_dspace_metadata1.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.dspace_metadata1 import DspaceMetadata1 # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestDspaceMetadata1(unittest.TestCase): + """DspaceMetadata1 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testDspaceMetadata1(self): + """Test DspaceMetadata1""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.dspace_metadata1.DspaceMetadata1() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_entity.py b/vendor/elabapi-python/test/test_entity.py new file mode 100644 index 0000000..80853ad --- /dev/null +++ b/vendor/elabapi-python/test/test_entity.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.entity import Entity # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestEntity(unittest.TestCase): + """Entity unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testEntity(self): + """Test Entity""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.entity.Entity() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_entity_and_item_editable.py b/vendor/elabapi-python/test/test_entity_and_item_editable.py new file mode 100644 index 0000000..9cc5f4d --- /dev/null +++ b/vendor/elabapi-python/test/test_entity_and_item_editable.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.entity_and_item_editable import EntityAndItemEditable # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestEntityAndItemEditable(unittest.TestCase): + """EntityAndItemEditable unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testEntityAndItemEditable(self): + """Test EntityAndItemEditable""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.entity_and_item_editable.EntityAndItemEditable() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_entity_duplicate.py b/vendor/elabapi-python/test/test_entity_duplicate.py new file mode 100644 index 0000000..cf563c5 --- /dev/null +++ b/vendor/elabapi-python/test/test_entity_duplicate.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.entity_duplicate import EntityDuplicate # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestEntityDuplicate(unittest.TestCase): + """EntityDuplicate unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testEntityDuplicate(self): + """Test EntityDuplicate""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.entity_duplicate.EntityDuplicate() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_entity_editable.py b/vendor/elabapi-python/test/test_entity_editable.py new file mode 100644 index 0000000..1fb20f8 --- /dev/null +++ b/vendor/elabapi-python/test/test_entity_editable.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.entity_editable import EntityEditable # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestEntityEditable(unittest.TestCase): + """EntityEditable unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testEntityEditable(self): + """Test EntityEditable""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.entity_editable.EntityEditable() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_entity_template.py b/vendor/elabapi-python/test/test_entity_template.py new file mode 100644 index 0000000..fd71d2e --- /dev/null +++ b/vendor/elabapi-python/test/test_entity_template.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.entity_template import EntityTemplate # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestEntityTemplate(unittest.TestCase): + """EntityTemplate unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testEntityTemplate(self): + """Test EntityTemplate""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.entity_template.EntityTemplate() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_entity_template_editable.py b/vendor/elabapi-python/test/test_entity_template_editable.py new file mode 100644 index 0000000..bea3b45 --- /dev/null +++ b/vendor/elabapi-python/test/test_entity_template_editable.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.entity_template_editable import EntityTemplateEditable # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestEntityTemplateEditable(unittest.TestCase): + """EntityTemplateEditable unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testEntityTemplateEditable(self): + """Test EntityTemplateEditable""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.entity_template_editable.EntityTemplateEditable() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_error.py b/vendor/elabapi-python/test/test_error.py new file mode 100644 index 0000000..fa3b51c --- /dev/null +++ b/vendor/elabapi-python/test/test_error.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.error import Error # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestError(unittest.TestCase): + """Error unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testError(self): + """Test Error""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.error.Error() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_event.py b/vendor/elabapi-python/test/test_event.py new file mode 100644 index 0000000..0a3522e --- /dev/null +++ b/vendor/elabapi-python/test/test_event.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.event import Event # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestEvent(unittest.TestCase): + """Event unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testEvent(self): + """Test Event""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.event.Event() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_event_id_body.py b/vendor/elabapi-python/test/test_event_id_body.py new file mode 100644 index 0000000..f1b8b9d --- /dev/null +++ b/vendor/elabapi-python/test/test_event_id_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.event_id_body import EventIdBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestEventIdBody(unittest.TestCase): + """EventIdBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testEventIdBody(self): + """Test EventIdBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.event_id_body.EventIdBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_eventid_delta.py b/vendor/elabapi-python/test/test_eventid_delta.py new file mode 100644 index 0000000..0a7772e --- /dev/null +++ b/vendor/elabapi-python/test/test_eventid_delta.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.eventid_delta import EventidDelta # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestEventidDelta(unittest.TestCase): + """EventidDelta unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testEventidDelta(self): + """Test EventidDelta""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.eventid_delta.EventidDelta() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_events_api.py b/vendor/elabapi-python/test/test_events_api.py new file mode 100644 index 0000000..a821b81 --- /dev/null +++ b/vendor/elabapi-python/test/test_events_api.py @@ -0,0 +1,68 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.events_api import EventsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestEventsApi(unittest.TestCase): + """EventsApi unit test stubs""" + + def setUp(self): + self.api = EventsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_event(self): + """Test case for delete_event + + Delete a booking slot. # noqa: E501 + """ + pass + + def test_patch_event(self): + """Test case for patch_event + + Modify a booking slot. # noqa: E501 + """ + pass + + def test_post_events(self): + """Test case for post_events + + Create an event for the item specified as id. # noqa: E501 + """ + pass + + def test_read_event(self): + """Test case for read_event + + Read a booking slot. # noqa: E501 + """ + pass + + def test_read_events(self): + """Test case for read_events + + Read all events in the team. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_events_id_body.py b/vendor/elabapi-python/test/test_events_id_body.py new file mode 100644 index 0000000..3d03213 --- /dev/null +++ b/vendor/elabapi-python/test/test_events_id_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.events_id_body import EventsIdBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestEventsIdBody(unittest.TestCase): + """EventsIdBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testEventsIdBody(self): + """Test EventsIdBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.events_id_body.EventsIdBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_exclusive_edit_mode.py b/vendor/elabapi-python/test/test_exclusive_edit_mode.py new file mode 100644 index 0000000..e9737a0 --- /dev/null +++ b/vendor/elabapi-python/test/test_exclusive_edit_mode.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.exclusive_edit_mode import ExclusiveEditMode # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestExclusiveEditMode(unittest.TestCase): + """ExclusiveEditMode unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testExclusiveEditMode(self): + """Test ExclusiveEditMode""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.exclusive_edit_mode.ExclusiveEditMode() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_experiment.py b/vendor/elabapi-python/test/test_experiment.py new file mode 100644 index 0000000..a90f39c --- /dev/null +++ b/vendor/elabapi-python/test/test_experiment.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.experiment import Experiment # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestExperiment(unittest.TestCase): + """Experiment unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testExperiment(self): + """Test Experiment""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.experiment.Experiment() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_experiments_api.py b/vendor/elabapi-python/test/test_experiments_api.py new file mode 100644 index 0000000..ba738d0 --- /dev/null +++ b/vendor/elabapi-python/test/test_experiments_api.py @@ -0,0 +1,75 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.experiments_api import ExperimentsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestExperimentsApi(unittest.TestCase): + """ExperimentsApi unit test stubs""" + + def setUp(self): + self.api = ExperimentsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_experiment(self): + """Test case for delete_experiment + + Delete an experiment. # noqa: E501 + """ + pass + + def test_get_experiment(self): + """Test case for get_experiment + + Read an experiment # noqa: E501 + """ + pass + + def test_patch_experiment(self): + """Test case for patch_experiment + + Modify an experiment # noqa: E501 + """ + pass + + def test_post_experiment(self): + """Test case for post_experiment + + Create an experiment # noqa: E501 + """ + pass + + def test_post_experiment_by_id(self): + """Test case for post_experiment_by_id + + Duplicate an experiment with its ID # noqa: E501 + """ + pass + + def test_read_experiments(self): + """Test case for read_experiments + + Read all experiments that are accessible # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_experiments_categories_api.py b/vendor/elabapi-python/test/test_experiments_categories_api.py new file mode 100644 index 0000000..f7fcc05 --- /dev/null +++ b/vendor/elabapi-python/test/test_experiments_categories_api.py @@ -0,0 +1,68 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.experiments_categories_api import ExperimentsCategoriesApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestExperimentsCategoriesApi(unittest.TestCase): + """ExperimentsCategoriesApi unit test stubs""" + + def setUp(self): + self.api = ExperimentsCategoriesApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_expcat(self): + """Test case for delete_expcat + + Delete a category. # noqa: E501 + """ + pass + + def test_patch_expcat(self): + """Test case for patch_expcat + + Modify a category. # noqa: E501 + """ + pass + + def test_post_team_one_expcat(self): + """Test case for post_team_one_expcat + + Create a new category for experiments. # noqa: E501 + """ + pass + + def test_read_team_experiments_categories(self): + """Test case for read_team_experiments_categories + + Read experiments categories of a team. # noqa: E501 + """ + pass + + def test_read_team_one_expcat(self): + """Test case for read_team_one_expcat + + Read a category. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_experiments_links_subid_body.py b/vendor/elabapi-python/test/test_experiments_links_subid_body.py new file mode 100644 index 0000000..e9d687a --- /dev/null +++ b/vendor/elabapi-python/test/test_experiments_links_subid_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.experiments_links_subid_body import ExperimentsLinksSubidBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestExperimentsLinksSubidBody(unittest.TestCase): + """ExperimentsLinksSubidBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testExperimentsLinksSubidBody(self): + """Test ExperimentsLinksSubidBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.experiments_links_subid_body.ExperimentsLinksSubidBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_experiments_status_api.py b/vendor/elabapi-python/test/test_experiments_status_api.py new file mode 100644 index 0000000..4426813 --- /dev/null +++ b/vendor/elabapi-python/test/test_experiments_status_api.py @@ -0,0 +1,68 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.experiments_status_api import ExperimentsStatusApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestExperimentsStatusApi(unittest.TestCase): + """ExperimentsStatusApi unit test stubs""" + + def setUp(self): + self.api = ExperimentsStatusApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_expstatus(self): + """Test case for delete_expstatus + + Delete a status. # noqa: E501 + """ + pass + + def test_patch_expstatus(self): + """Test case for patch_expstatus + + Modify a status. # noqa: E501 + """ + pass + + def test_post_team_one_expstatus(self): + """Test case for post_team_one_expstatus + + Create a new experiments status. # noqa: E501 + """ + pass + + def test_read_team_experiments_status(self): + """Test case for read_team_experiments_status + + Read experiments status of a team. # noqa: E501 + """ + pass + + def test_read_team_one_expstatus(self): + """Test case for read_team_one_expstatus + + Read a status. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_experiments_templates_api.py b/vendor/elabapi-python/test/test_experiments_templates_api.py new file mode 100644 index 0000000..4977fb5 --- /dev/null +++ b/vendor/elabapi-python/test/test_experiments_templates_api.py @@ -0,0 +1,75 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.experiments_templates_api import ExperimentsTemplatesApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestExperimentsTemplatesApi(unittest.TestCase): + """ExperimentsTemplatesApi unit test stubs""" + + def setUp(self): + self.api = ExperimentsTemplatesApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_experiment_template(self): + """Test case for delete_experiment_template + + Delete an experiment template. # noqa: E501 + """ + pass + + def test_get_experiment_template(self): + """Test case for get_experiment_template + + Read an experiment template # noqa: E501 + """ + pass + + def test_patch_experiment_template(self): + """Test case for patch_experiment_template + + Modify an experiment template # noqa: E501 + """ + pass + + def test_post_experiment_template(self): + """Test case for post_experiment_template + + Create an experiment template # noqa: E501 + """ + pass + + def test_post_experiment_template_by_id(self): + """Test case for post_experiment_template_by_id + + Duplicate an experiment template with its ID # noqa: E501 + """ + pass + + def test_read_experiments_templates(self): + """Test case for read_experiments_templates + + Read all experiments_templates that are accessible # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_experiments_templates_id_body.py b/vendor/elabapi-python/test/test_experiments_templates_id_body.py new file mode 100644 index 0000000..4306443 --- /dev/null +++ b/vendor/elabapi-python/test/test_experiments_templates_id_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.experiments_templates_id_body import ExperimentsTemplatesIdBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestExperimentsTemplatesIdBody(unittest.TestCase): + """ExperimentsTemplatesIdBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testExperimentsTemplatesIdBody(self): + """Test ExperimentsTemplatesIdBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.experiments_templates_id_body.ExperimentsTemplatesIdBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_export.py b/vendor/elabapi-python/test/test_export.py new file mode 100644 index 0000000..709ada4 --- /dev/null +++ b/vendor/elabapi-python/test/test_export.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.export import Export # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestExport(unittest.TestCase): + """Export unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testExport(self): + """Test Export""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.export.Export() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_exports_api.py b/vendor/elabapi-python/test/test_exports_api.py new file mode 100644 index 0000000..9d88d71 --- /dev/null +++ b/vendor/elabapi-python/test/test_exports_api.py @@ -0,0 +1,61 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.exports_api import ExportsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestExportsApi(unittest.TestCase): + """ExportsApi unit test stubs""" + + def setUp(self): + self.api = ExportsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_export(self): + """Test case for delete_export + + Remove an export request and its associated file # noqa: E501 + """ + pass + + def test_post_export(self): + """Test case for post_export + + Register an export request # noqa: E501 + """ + pass + + def test_read_export(self): + """Test case for read_export + + Get export # noqa: E501 + """ + pass + + def test_readall_exports(self): + """Test case for readall_exports + + List exports # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_exports_body.py b/vendor/elabapi-python/test/test_exports_body.py new file mode 100644 index 0000000..8e00af8 --- /dev/null +++ b/vendor/elabapi-python/test/test_exports_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.exports_body import ExportsBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestExportsBody(unittest.TestCase): + """ExportsBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testExportsBody(self): + """Test ExportsBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.exports_body.ExportsBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_extra_fields_keys.py b/vendor/elabapi-python/test/test_extra_fields_keys.py new file mode 100644 index 0000000..10d8622 --- /dev/null +++ b/vendor/elabapi-python/test/test_extra_fields_keys.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.extra_fields_keys import ExtraFieldsKeys # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestExtraFieldsKeys(unittest.TestCase): + """ExtraFieldsKeys unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testExtraFieldsKeys(self): + """Test ExtraFieldsKeys""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.extra_fields_keys.ExtraFieldsKeys() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_favorite_tags_api.py b/vendor/elabapi-python/test/test_favorite_tags_api.py new file mode 100644 index 0000000..a05cbb3 --- /dev/null +++ b/vendor/elabapi-python/test/test_favorite_tags_api.py @@ -0,0 +1,54 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.favorite_tags_api import FavoriteTagsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestFavoriteTagsApi(unittest.TestCase): + """FavoriteTagsApi unit test stubs""" + + def setUp(self): + self.api = FavoriteTagsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_favtag(self): + """Test case for delete_favtag + + Unfavorite a tag. # noqa: E501 + """ + pass + + def test_post_favtags(self): + """Test case for post_favtags + + Add a tag as favorite. # noqa: E501 + """ + pass + + def test_read_favtags(self): + """Test case for read_favtags + + Read all favorite tags for the user. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_favtags_body.py b/vendor/elabapi-python/test/test_favtags_body.py new file mode 100644 index 0000000..d0458d0 --- /dev/null +++ b/vendor/elabapi-python/test/test_favtags_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.favtags_body import FavtagsBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestFavtagsBody(unittest.TestCase): + """FavtagsBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testFavtagsBody(self): + """Test FavtagsBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.favtags_body.FavtagsBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_id.py b/vendor/elabapi-python/test/test_id.py new file mode 100644 index 0000000..e248625 --- /dev/null +++ b/vendor/elabapi-python/test/test_id.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.id import Id # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestId(unittest.TestCase): + """Id unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testId(self): + """Test Id""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.id.Id() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_id1.py b/vendor/elabapi-python/test/test_id1.py new file mode 100644 index 0000000..9c8c325 --- /dev/null +++ b/vendor/elabapi-python/test/test_id1.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.id1 import Id1 # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestId1(unittest.TestCase): + """Id1 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testId1(self): + """Test Id1""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.id1.Id1() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_id2.py b/vendor/elabapi-python/test/test_id2.py new file mode 100644 index 0000000..976a0c0 --- /dev/null +++ b/vendor/elabapi-python/test/test_id2.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.id2 import Id2 # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestId2(unittest.TestCase): + """Id2 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testId2(self): + """Test Id2""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.id2.Id2() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_id3.py b/vendor/elabapi-python/test/test_id3.py new file mode 100644 index 0000000..c1eb68d --- /dev/null +++ b/vendor/elabapi-python/test/test_id3.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.id3 import Id3 # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestId3(unittest.TestCase): + """Id3 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testId3(self): + """Test Id3""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.id3.Id3() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_id4.py b/vendor/elabapi-python/test/test_id4.py new file mode 100644 index 0000000..47e02e2 --- /dev/null +++ b/vendor/elabapi-python/test/test_id4.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.id4 import Id4 # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestId4(unittest.TestCase): + """Id4 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testId4(self): + """Test Id4""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.id4.Id4() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_id_certs_body.py b/vendor/elabapi-python/test/test_id_certs_body.py new file mode 100644 index 0000000..c73b7a7 --- /dev/null +++ b/vendor/elabapi-python/test/test_id_certs_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.id_certs_body import IdCertsBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestIdCertsBody(unittest.TestCase): + """IdCertsBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testIdCertsBody(self): + """Test IdCertsBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.id_certs_body.IdCertsBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_id_comments_body.py b/vendor/elabapi-python/test/test_id_comments_body.py new file mode 100644 index 0000000..2318ac1 --- /dev/null +++ b/vendor/elabapi-python/test/test_id_comments_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.id_comments_body import IdCommentsBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestIdCommentsBody(unittest.TestCase): + """IdCommentsBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testIdCommentsBody(self): + """Test IdCommentsBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.id_comments_body.IdCommentsBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_id_endpoints_body.py b/vendor/elabapi-python/test/test_id_endpoints_body.py new file mode 100644 index 0000000..77722ea --- /dev/null +++ b/vendor/elabapi-python/test/test_id_endpoints_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.id_endpoints_body import IdEndpointsBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestIdEndpointsBody(unittest.TestCase): + """IdEndpointsBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testIdEndpointsBody(self): + """Test IdEndpointsBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.id_endpoints_body.IdEndpointsBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_id_experiments_categories_body.py b/vendor/elabapi-python/test/test_id_experiments_categories_body.py new file mode 100644 index 0000000..93049fc --- /dev/null +++ b/vendor/elabapi-python/test/test_id_experiments_categories_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.id_experiments_categories_body import IdExperimentsCategoriesBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestIdExperimentsCategoriesBody(unittest.TestCase): + """IdExperimentsCategoriesBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testIdExperimentsCategoriesBody(self): + """Test IdExperimentsCategoriesBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.id_experiments_categories_body.IdExperimentsCategoriesBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_id_experiments_status_body.py b/vendor/elabapi-python/test/test_id_experiments_status_body.py new file mode 100644 index 0000000..13d7786 --- /dev/null +++ b/vendor/elabapi-python/test/test_id_experiments_status_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.id_experiments_status_body import IdExperimentsStatusBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestIdExperimentsStatusBody(unittest.TestCase): + """IdExperimentsStatusBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testIdExperimentsStatusBody(self): + """Test IdExperimentsStatusBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.id_experiments_status_body.IdExperimentsStatusBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_id_items_status_body.py b/vendor/elabapi-python/test/test_id_items_status_body.py new file mode 100644 index 0000000..6987f81 --- /dev/null +++ b/vendor/elabapi-python/test/test_id_items_status_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.id_items_status_body import IdItemsStatusBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestIdItemsStatusBody(unittest.TestCase): + """IdItemsStatusBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testIdItemsStatusBody(self): + """Test IdItemsStatusBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.id_items_status_body.IdItemsStatusBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_id_resources_categories_body.py b/vendor/elabapi-python/test/test_id_resources_categories_body.py new file mode 100644 index 0000000..8d922da --- /dev/null +++ b/vendor/elabapi-python/test/test_id_resources_categories_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.id_resources_categories_body import IdResourcesCategoriesBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestIdResourcesCategoriesBody(unittest.TestCase): + """IdResourcesCategoriesBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testIdResourcesCategoriesBody(self): + """Test IdResourcesCategoriesBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.id_resources_categories_body.IdResourcesCategoriesBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_id_steps_body.py b/vendor/elabapi-python/test/test_id_steps_body.py new file mode 100644 index 0000000..6c605cf --- /dev/null +++ b/vendor/elabapi-python/test/test_id_steps_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.id_steps_body import IdStepsBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestIdStepsBody(unittest.TestCase): + """IdStepsBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testIdStepsBody(self): + """Test IdStepsBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.id_steps_body.IdStepsBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_id_tags_body.py b/vendor/elabapi-python/test/test_id_tags_body.py new file mode 100644 index 0000000..3ceb0d3 --- /dev/null +++ b/vendor/elabapi-python/test/test_id_tags_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.id_tags_body import IdTagsBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestIdTagsBody(unittest.TestCase): + """IdTagsBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testIdTagsBody(self): + """Test IdTagsBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.id_tags_body.IdTagsBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_id_tags_body1.py b/vendor/elabapi-python/test/test_id_tags_body1.py new file mode 100644 index 0000000..c30257c --- /dev/null +++ b/vendor/elabapi-python/test/test_id_tags_body1.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.id_tags_body1 import IdTagsBody1 # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestIdTagsBody1(unittest.TestCase): + """IdTagsBody1 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testIdTagsBody1(self): + """Test IdTagsBody1""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.id_tags_body1.IdTagsBody1() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_id_teamgroups_body.py b/vendor/elabapi-python/test/test_id_teamgroups_body.py new file mode 100644 index 0000000..3687a3f --- /dev/null +++ b/vendor/elabapi-python/test/test_id_teamgroups_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.id_teamgroups_body import IdTeamgroupsBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestIdTeamgroupsBody(unittest.TestCase): + """IdTeamgroupsBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testIdTeamgroupsBody(self): + """Test IdTeamgroupsBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.id_teamgroups_body.IdTeamgroupsBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_id_uploads_body.py b/vendor/elabapi-python/test/test_id_uploads_body.py new file mode 100644 index 0000000..f3414ae --- /dev/null +++ b/vendor/elabapi-python/test/test_id_uploads_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.id_uploads_body import IdUploadsBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestIdUploadsBody(unittest.TestCase): + """IdUploadsBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testIdUploadsBody(self): + """Test IdUploadsBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.id_uploads_body.IdUploadsBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_idp.py b/vendor/elabapi-python/test/test_idp.py new file mode 100644 index 0000000..38d4124 --- /dev/null +++ b/vendor/elabapi-python/test/test_idp.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.idp import Idp # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestIdp(unittest.TestCase): + """Idp unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testIdp(self): + """Test Idp""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.idp.Idp() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_idp_cert.py b/vendor/elabapi-python/test/test_idp_cert.py new file mode 100644 index 0000000..19e30b7 --- /dev/null +++ b/vendor/elabapi-python/test/test_idp_cert.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.idp_cert import IdpCert # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestIdpCert(unittest.TestCase): + """IdpCert unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testIdpCert(self): + """Test IdpCert""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.idp_cert.IdpCert() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_idp_endpoint.py b/vendor/elabapi-python/test/test_idp_endpoint.py new file mode 100644 index 0000000..b155f48 --- /dev/null +++ b/vendor/elabapi-python/test/test_idp_endpoint.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.idp_endpoint import IdpEndpoint # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestIdpEndpoint(unittest.TestCase): + """IdpEndpoint unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testIdpEndpoint(self): + """Test IdpEndpoint""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.idp_endpoint.IdpEndpoint() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_idp_source.py b/vendor/elabapi-python/test/test_idp_source.py new file mode 100644 index 0000000..7b65e21 --- /dev/null +++ b/vendor/elabapi-python/test/test_idp_source.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.idp_source import IdpSource # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestIdpSource(unittest.TestCase): + """IdpSource unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testIdpSource(self): + """Test IdpSource""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.idp_source.IdpSource() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_idps_api.py b/vendor/elabapi-python/test/test_idps_api.py new file mode 100644 index 0000000..925875a --- /dev/null +++ b/vendor/elabapi-python/test/test_idps_api.py @@ -0,0 +1,124 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.idps_api import IdpsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestIdpsApi(unittest.TestCase): + """IdpsApi unit test stubs""" + + def setUp(self): + self.api = IdpsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_idp(self): + """Test case for delete_idp + + Delete an idp. # noqa: E501 + """ + pass + + def test_delete_idp_cert(self): + """Test case for delete_idp_cert + + Delete an idp cert. # noqa: E501 + """ + pass + + def test_delete_idp_endpoint(self): + """Test case for delete_idp_endpoint + + Delete an idp endpoint. # noqa: E501 + """ + pass + + def test_patch_idp(self): + """Test case for patch_idp + + Actions on an idp. # noqa: E501 + """ + pass + + def test_post_idp(self): + """Test case for post_idp + + Create an idp. # noqa: E501 + """ + pass + + def test_post_idp_cert(self): + """Test case for post_idp_cert + + Add a cert to this IdP. # noqa: E501 + """ + pass + + def test_post_idp_endpoint(self): + """Test case for post_idp_endpoint + + Add an endpoint to this IdP. # noqa: E501 + """ + pass + + def test_read_idp(self): + """Test case for read_idp + + Read an idp. # noqa: E501 + """ + pass + + def test_read_idp_cert(self): + """Test case for read_idp_cert + + Read a cert for an IdP. # noqa: E501 + """ + pass + + def test_read_idp_certs(self): + """Test case for read_idp_certs + + Read all certs for an IdP. # noqa: E501 + """ + pass + + def test_read_idp_endpoint(self): + """Test case for read_idp_endpoint + + Read an endpoint for an IdP. # noqa: E501 + """ + pass + + def test_read_idp_endpoints(self): + """Test case for read_idp_endpoints + + Read all endpoints for an IdP. # noqa: E501 + """ + pass + + def test_read_idps(self): + """Test case for read_idps + + Read all IDPs. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_idps_body.py b/vendor/elabapi-python/test/test_idps_body.py new file mode 100644 index 0000000..194feda --- /dev/null +++ b/vendor/elabapi-python/test/test_idps_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.idps_body import IdpsBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestIdpsBody(unittest.TestCase): + """IdpsBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testIdpsBody(self): + """Test IdpsBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.idps_body.IdpsBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_idps_id_body.py b/vendor/elabapi-python/test/test_idps_id_body.py new file mode 100644 index 0000000..781287d --- /dev/null +++ b/vendor/elabapi-python/test/test_idps_id_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.idps_id_body import IdpsIdBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestIdpsIdBody(unittest.TestCase): + """IdpsIdBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testIdpsIdBody(self): + """Test IdpsIdBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.idps_id_body.IdpsIdBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_idps_sources_api.py b/vendor/elabapi-python/test/test_idps_sources_api.py new file mode 100644 index 0000000..bcd0ea8 --- /dev/null +++ b/vendor/elabapi-python/test/test_idps_sources_api.py @@ -0,0 +1,68 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.idps_sources_api import IdpsSourcesApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestIdpsSourcesApi(unittest.TestCase): + """IdpsSourcesApi unit test stubs""" + + def setUp(self): + self.api = IdpsSourcesApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_idps_source(self): + """Test case for delete_idps_source + + Delete an idp source. # noqa: E501 + """ + pass + + def test_patch_idps_source(self): + """Test case for patch_idps_source + + Patch an idp source. # noqa: E501 + """ + pass + + def test_post_idp_source(self): + """Test case for post_idp_source + + Create an idp source. # noqa: E501 + """ + pass + + def test_read_idps_source(self): + """Test case for read_idps_source + + Read an IdPs source # noqa: E501 + """ + pass + + def test_read_idps_sources(self): + """Test case for read_idps_sources + + Read all IDPs sources # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_idps_sources_body.py b/vendor/elabapi-python/test/test_idps_sources_body.py new file mode 100644 index 0000000..8fcfc8c --- /dev/null +++ b/vendor/elabapi-python/test/test_idps_sources_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.idps_sources_body import IdpsSourcesBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestIdpsSourcesBody(unittest.TestCase): + """IdpsSourcesBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testIdpsSourcesBody(self): + """Test IdpsSourcesBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.idps_sources_body.IdpsSourcesBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_idps_sources_id_body.py b/vendor/elabapi-python/test/test_idps_sources_id_body.py new file mode 100644 index 0000000..6dc4463 --- /dev/null +++ b/vendor/elabapi-python/test/test_idps_sources_id_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.idps_sources_id_body import IdpsSourcesIdBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestIdpsSourcesIdBody(unittest.TestCase): + """IdpsSourcesIdBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testIdpsSourcesIdBody(self): + """Test IdpsSourcesIdBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.idps_sources_id_body.IdpsSourcesIdBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_import_api.py b/vendor/elabapi-python/test/test_import_api.py new file mode 100644 index 0000000..ccf81fa --- /dev/null +++ b/vendor/elabapi-python/test/test_import_api.py @@ -0,0 +1,47 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.import_api import ImportApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestImportApi(unittest.TestCase): + """ImportApi unit test stubs""" + + def setUp(self): + self.api = ImportApi() # noqa: E501 + + def tearDown(self): + pass + + def test_post_import(self): + """Test case for post_import + + Send a file to import # noqa: E501 + """ + pass + + def test_read_import(self): + """Test case for read_import + + Get information about this endpoint # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_import_body.py b/vendor/elabapi-python/test/test_import_body.py new file mode 100644 index 0000000..56f9529 --- /dev/null +++ b/vendor/elabapi-python/test/test_import_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.import_body import ImportBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestImportBody(unittest.TestCase): + """ImportBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testImportBody(self): + """Test ImportBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.import_body.ImportBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_info_api.py b/vendor/elabapi-python/test/test_info_api.py new file mode 100644 index 0000000..62b36ee --- /dev/null +++ b/vendor/elabapi-python/test/test_info_api.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.info_api import InfoApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestInfoApi(unittest.TestCase): + """InfoApi unit test stubs""" + + def setUp(self): + self.api = InfoApi() # noqa: E501 + + def tearDown(self): + pass + + def test_get_info(self): + """Test case for get_info + + Get information about the instance. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_inline_response200.py b/vendor/elabapi-python/test/test_inline_response200.py new file mode 100644 index 0000000..4d0731d --- /dev/null +++ b/vendor/elabapi-python/test/test_inline_response200.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.inline_response200 import InlineResponse200 # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestInlineResponse200(unittest.TestCase): + """InlineResponse200 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse200(self): + """Test InlineResponse200""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.inline_response200.InlineResponse200() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_inline_response2001.py b/vendor/elabapi-python/test/test_inline_response2001.py new file mode 100644 index 0000000..5de80b8 --- /dev/null +++ b/vendor/elabapi-python/test/test_inline_response2001.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.inline_response2001 import InlineResponse2001 # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestInlineResponse2001(unittest.TestCase): + """InlineResponse2001 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2001(self): + """Test InlineResponse2001""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.inline_response2001.InlineResponse2001() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_inline_response20010.py b/vendor/elabapi-python/test/test_inline_response20010.py new file mode 100644 index 0000000..9c074ec --- /dev/null +++ b/vendor/elabapi-python/test/test_inline_response20010.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.inline_response20010 import InlineResponse20010 # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestInlineResponse20010(unittest.TestCase): + """InlineResponse20010 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse20010(self): + """Test InlineResponse20010""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.inline_response20010.InlineResponse20010() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_inline_response2001_experiments.py b/vendor/elabapi-python/test/test_inline_response2001_experiments.py new file mode 100644 index 0000000..bcd5b85 --- /dev/null +++ b/vendor/elabapi-python/test/test_inline_response2001_experiments.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.inline_response2001_experiments import InlineResponse2001Experiments # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestInlineResponse2001Experiments(unittest.TestCase): + """InlineResponse2001Experiments unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2001Experiments(self): + """Test InlineResponse2001Experiments""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.inline_response2001_experiments.InlineResponse2001Experiments() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_inline_response2001_items.py b/vendor/elabapi-python/test/test_inline_response2001_items.py new file mode 100644 index 0000000..0e444a4 --- /dev/null +++ b/vendor/elabapi-python/test/test_inline_response2001_items.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.inline_response2001_items import InlineResponse2001Items # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestInlineResponse2001Items(unittest.TestCase): + """InlineResponse2001Items unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2001Items(self): + """Test InlineResponse2001Items""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.inline_response2001_items.InlineResponse2001Items() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_inline_response2001_users.py b/vendor/elabapi-python/test/test_inline_response2001_users.py new file mode 100644 index 0000000..6ab9e56 --- /dev/null +++ b/vendor/elabapi-python/test/test_inline_response2001_users.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.inline_response2001_users import InlineResponse2001Users # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestInlineResponse2001Users(unittest.TestCase): + """InlineResponse2001Users unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2001Users(self): + """Test InlineResponse2001Users""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.inline_response2001_users.InlineResponse2001Users() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_inline_response2002.py b/vendor/elabapi-python/test/test_inline_response2002.py new file mode 100644 index 0000000..797f60f --- /dev/null +++ b/vendor/elabapi-python/test/test_inline_response2002.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.inline_response2002 import InlineResponse2002 # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestInlineResponse2002(unittest.TestCase): + """InlineResponse2002 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2002(self): + """Test InlineResponse2002""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.inline_response2002.InlineResponse2002() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_inline_response2003.py b/vendor/elabapi-python/test/test_inline_response2003.py new file mode 100644 index 0000000..92d41fc --- /dev/null +++ b/vendor/elabapi-python/test/test_inline_response2003.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.inline_response2003 import InlineResponse2003 # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestInlineResponse2003(unittest.TestCase): + """InlineResponse2003 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2003(self): + """Test InlineResponse2003""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.inline_response2003.InlineResponse2003() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_inline_response2004.py b/vendor/elabapi-python/test/test_inline_response2004.py new file mode 100644 index 0000000..3019f78 --- /dev/null +++ b/vendor/elabapi-python/test/test_inline_response2004.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.inline_response2004 import InlineResponse2004 # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestInlineResponse2004(unittest.TestCase): + """InlineResponse2004 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2004(self): + """Test InlineResponse2004""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.inline_response2004.InlineResponse2004() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_inline_response2004_query_parameters.py b/vendor/elabapi-python/test/test_inline_response2004_query_parameters.py new file mode 100644 index 0000000..5645767 --- /dev/null +++ b/vendor/elabapi-python/test/test_inline_response2004_query_parameters.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.inline_response2004_query_parameters import InlineResponse2004QueryParameters # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestInlineResponse2004QueryParameters(unittest.TestCase): + """InlineResponse2004QueryParameters unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2004QueryParameters(self): + """Test InlineResponse2004QueryParameters""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.inline_response2004_query_parameters.InlineResponse2004QueryParameters() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_inline_response2005.py b/vendor/elabapi-python/test/test_inline_response2005.py new file mode 100644 index 0000000..dbbbe25 --- /dev/null +++ b/vendor/elabapi-python/test/test_inline_response2005.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.inline_response2005 import InlineResponse2005 # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestInlineResponse2005(unittest.TestCase): + """InlineResponse2005 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2005(self): + """Test InlineResponse2005""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.inline_response2005.InlineResponse2005() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_inline_response2006.py b/vendor/elabapi-python/test/test_inline_response2006.py new file mode 100644 index 0000000..b8fccb0 --- /dev/null +++ b/vendor/elabapi-python/test/test_inline_response2006.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.inline_response2006 import InlineResponse2006 # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestInlineResponse2006(unittest.TestCase): + """InlineResponse2006 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2006(self): + """Test InlineResponse2006""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.inline_response2006.InlineResponse2006() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_inline_response2007.py b/vendor/elabapi-python/test/test_inline_response2007.py new file mode 100644 index 0000000..20fae55 --- /dev/null +++ b/vendor/elabapi-python/test/test_inline_response2007.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.inline_response2007 import InlineResponse2007 # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestInlineResponse2007(unittest.TestCase): + """InlineResponse2007 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2007(self): + """Test InlineResponse2007""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.inline_response2007.InlineResponse2007() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_inline_response2008.py b/vendor/elabapi-python/test/test_inline_response2008.py new file mode 100644 index 0000000..abd5953 --- /dev/null +++ b/vendor/elabapi-python/test/test_inline_response2008.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.inline_response2008 import InlineResponse2008 # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestInlineResponse2008(unittest.TestCase): + """InlineResponse2008 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2008(self): + """Test InlineResponse2008""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.inline_response2008.InlineResponse2008() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_inline_response2009.py b/vendor/elabapi-python/test/test_inline_response2009.py new file mode 100644 index 0000000..49036d1 --- /dev/null +++ b/vendor/elabapi-python/test/test_inline_response2009.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.inline_response2009 import InlineResponse2009 # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestInlineResponse2009(unittest.TestCase): + """InlineResponse2009 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2009(self): + """Test InlineResponse2009""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.inline_response2009.InlineResponse2009() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_inline_response2009_embedded.py b/vendor/elabapi-python/test/test_inline_response2009_embedded.py new file mode 100644 index 0000000..6ddae6c --- /dev/null +++ b/vendor/elabapi-python/test/test_inline_response2009_embedded.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.inline_response2009_embedded import InlineResponse2009Embedded # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestInlineResponse2009Embedded(unittest.TestCase): + """InlineResponse2009Embedded unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2009Embedded(self): + """Test InlineResponse2009Embedded""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.inline_response2009_embedded.InlineResponse2009Embedded() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_inline_response2009_embedded_entries.py b/vendor/elabapi-python/test/test_inline_response2009_embedded_entries.py new file mode 100644 index 0000000..7dd5833 --- /dev/null +++ b/vendor/elabapi-python/test/test_inline_response2009_embedded_entries.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.inline_response2009_embedded_entries import InlineResponse2009EmbeddedEntries # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestInlineResponse2009EmbeddedEntries(unittest.TestCase): + """InlineResponse2009EmbeddedEntries unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2009EmbeddedEntries(self): + """Test InlineResponse2009EmbeddedEntries""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.inline_response2009_embedded_entries.InlineResponse2009EmbeddedEntries() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_instance_api.py b/vendor/elabapi-python/test/test_instance_api.py new file mode 100644 index 0000000..12d54a5 --- /dev/null +++ b/vendor/elabapi-python/test/test_instance_api.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.instance_api import InstanceApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestInstanceApi(unittest.TestCase): + """InstanceApi unit test stubs""" + + def setUp(self): + self.api = InstanceApi() # noqa: E501 + + def tearDown(self): + pass + + def test_post_instance(self): + """Test case for post_instance + + Run an instance level action. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_instance_body.py b/vendor/elabapi-python/test/test_instance_body.py new file mode 100644 index 0000000..ef40c63 --- /dev/null +++ b/vendor/elabapi-python/test/test_instance_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.instance_body import InstanceBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestInstanceBody(unittest.TestCase): + """InstanceBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInstanceBody(self): + """Test InstanceBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.instance_body.InstanceBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_item.py b/vendor/elabapi-python/test/test_item.py new file mode 100644 index 0000000..b88f0fd --- /dev/null +++ b/vendor/elabapi-python/test/test_item.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.item import Item # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestItem(unittest.TestCase): + """Item unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testItem(self): + """Test Item""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.item.Item() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_item_editable.py b/vendor/elabapi-python/test/test_item_editable.py new file mode 100644 index 0000000..6c399b6 --- /dev/null +++ b/vendor/elabapi-python/test/test_item_editable.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.item_editable import ItemEditable # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestItemEditable(unittest.TestCase): + """ItemEditable unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testItemEditable(self): + """Test ItemEditable""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.item_editable.ItemEditable() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_items_api.py b/vendor/elabapi-python/test/test_items_api.py new file mode 100644 index 0000000..9c26869 --- /dev/null +++ b/vendor/elabapi-python/test/test_items_api.py @@ -0,0 +1,75 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.items_api import ItemsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestItemsApi(unittest.TestCase): + """ItemsApi unit test stubs""" + + def setUp(self): + self.api = ItemsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_item(self): + """Test case for delete_item + + Delete an item. # noqa: E501 + """ + pass + + def test_get_item(self): + """Test case for get_item + + Read an item # noqa: E501 + """ + pass + + def test_patch_item(self): + """Test case for patch_item + + Modify an item # noqa: E501 + """ + pass + + def test_post_item(self): + """Test case for post_item + + Create an item # noqa: E501 + """ + pass + + def test_post_item_by_id(self): + """Test case for post_item_by_id + + Duplicate an item with its ID # noqa: E501 + """ + pass + + def test_read_items(self): + """Test case for read_items + + Read all items that are accessible # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_items_links_subid_body.py b/vendor/elabapi-python/test/test_items_links_subid_body.py new file mode 100644 index 0000000..d37164c --- /dev/null +++ b/vendor/elabapi-python/test/test_items_links_subid_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.items_links_subid_body import ItemsLinksSubidBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestItemsLinksSubidBody(unittest.TestCase): + """ItemsLinksSubidBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testItemsLinksSubidBody(self): + """Test ItemsLinksSubidBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.items_links_subid_body.ItemsLinksSubidBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_items_types__resources_templates_api.py b/vendor/elabapi-python/test/test_items_types__resources_templates_api.py new file mode 100644 index 0000000..269d525 --- /dev/null +++ b/vendor/elabapi-python/test/test_items_types__resources_templates_api.py @@ -0,0 +1,75 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.items_types__resources_templates_api import ItemsTypesResourcesTemplatesApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestItemsTypesResourcesTemplatesApi(unittest.TestCase): + """ItemsTypesResourcesTemplatesApi unit test stubs""" + + def setUp(self): + self.api = ItemsTypesResourcesTemplatesApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_items_type(self): + """Test case for delete_items_type + + Delete a resource template. # noqa: E501 + """ + pass + + def test_get_items_type(self): + """Test case for get_items_type + + Read a resource template # noqa: E501 + """ + pass + + def test_patch_items_type(self): + """Test case for patch_items_type + + Modify a resource template # noqa: E501 + """ + pass + + def test_post_items_types(self): + """Test case for post_items_types + + Create a resource template # noqa: E501 + """ + pass + + def test_post_items_types_by_id(self): + """Test case for post_items_types_by_id + + Duplicate a resource template with its ID # noqa: E501 + """ + pass + + def test_read_items_types(self): + """Test case for read_items_types + + Read all resources templates that are accessible # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_items_types_id_body.py b/vendor/elabapi-python/test/test_items_types_id_body.py new file mode 100644 index 0000000..d1f4cd5 --- /dev/null +++ b/vendor/elabapi-python/test/test_items_types_id_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.items_types_id_body import ItemsTypesIdBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestItemsTypesIdBody(unittest.TestCase): + """ItemsTypesIdBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testItemsTypesIdBody(self): + """Test ItemsTypesIdBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.items_types_id_body.ItemsTypesIdBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_link.py b/vendor/elabapi-python/test/test_link.py new file mode 100644 index 0000000..71628e2 --- /dev/null +++ b/vendor/elabapi-python/test/test_link.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.link import Link # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestLink(unittest.TestCase): + """Link unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testLink(self): + """Test Link""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.link.Link() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_links_to_compounds_api.py b/vendor/elabapi-python/test/test_links_to_compounds_api.py new file mode 100644 index 0000000..43756d7 --- /dev/null +++ b/vendor/elabapi-python/test/test_links_to_compounds_api.py @@ -0,0 +1,54 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.links_to_compounds_api import LinksToCompoundsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestLinksToCompoundsApi(unittest.TestCase): + """LinksToCompoundsApi unit test stubs""" + + def setUp(self): + self.api = LinksToCompoundsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_entity_compounds_link(self): + """Test case for delete_entity_compounds_link + + Delete a compound link. # noqa: E501 + """ + pass + + def test_post_entity_compounds_links(self): + """Test case for post_entity_compounds_links + + Link an entity to a compound. # noqa: E501 + """ + pass + + def test_read_entity_compounds_links(self): + """Test case for read_entity_compounds_links + + Read all compounds links of that entity. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_links_to_experiments_api.py b/vendor/elabapi-python/test/test_links_to_experiments_api.py new file mode 100644 index 0000000..87da021 --- /dev/null +++ b/vendor/elabapi-python/test/test_links_to_experiments_api.py @@ -0,0 +1,54 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.links_to_experiments_api import LinksToExperimentsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestLinksToExperimentsApi(unittest.TestCase): + """LinksToExperimentsApi unit test stubs""" + + def setUp(self): + self.api = LinksToExperimentsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_entity_experiments_link(self): + """Test case for delete_entity_experiments_link + + Delete an experiment link. # noqa: E501 + """ + pass + + def test_post_entity_experiments_links(self): + """Test case for post_entity_experiments_links + + Create or import a link. # noqa: E501 + """ + pass + + def test_read_entity_experiments_links(self): + """Test case for read_entity_experiments_links + + Read all experiments links of that entity. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_links_to_items_api.py b/vendor/elabapi-python/test/test_links_to_items_api.py new file mode 100644 index 0000000..45d7675 --- /dev/null +++ b/vendor/elabapi-python/test/test_links_to_items_api.py @@ -0,0 +1,54 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.links_to_items_api import LinksToItemsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestLinksToItemsApi(unittest.TestCase): + """LinksToItemsApi unit test stubs""" + + def setUp(self): + self.api = LinksToItemsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_entitiy_items_link(self): + """Test case for delete_entitiy_items_link + + Delete an item link. # noqa: E501 + """ + pass + + def test_post_entity_items_links(self): + """Test case for post_entity_items_links + + Create or import a link. # noqa: E501 + """ + pass + + def test_read_entity_items_links(self): + """Test case for read_entity_items_links + + Read all items links of that entity. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_metadata.py b/vendor/elabapi-python/test/test_metadata.py new file mode 100644 index 0000000..d839086 --- /dev/null +++ b/vendor/elabapi-python/test/test_metadata.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.metadata import Metadata # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestMetadata(unittest.TestCase): + """Metadata unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testMetadata(self): + """Test Metadata""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.metadata.Metadata() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_metadata_elabftw.py b/vendor/elabapi-python/test/test_metadata_elabftw.py new file mode 100644 index 0000000..3c616a8 --- /dev/null +++ b/vendor/elabapi-python/test/test_metadata_elabftw.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.metadata_elabftw import MetadataElabftw # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestMetadataElabftw(unittest.TestCase): + """MetadataElabftw unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testMetadataElabftw(self): + """Test MetadataElabftw""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.metadata_elabftw.MetadataElabftw() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_metadata_elabftw_extra_fields_groups.py b/vendor/elabapi-python/test/test_metadata_elabftw_extra_fields_groups.py new file mode 100644 index 0000000..43991fb --- /dev/null +++ b/vendor/elabapi-python/test/test_metadata_elabftw_extra_fields_groups.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.metadata_elabftw_extra_fields_groups import MetadataElabftwExtraFieldsGroups # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestMetadataElabftwExtraFieldsGroups(unittest.TestCase): + """MetadataElabftwExtraFieldsGroups unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testMetadataElabftwExtraFieldsGroups(self): + """Test MetadataElabftwExtraFieldsGroups""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.metadata_elabftw_extra_fields_groups.MetadataElabftwExtraFieldsGroups() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_metadata_extra_fields.py b/vendor/elabapi-python/test/test_metadata_extra_fields.py new file mode 100644 index 0000000..686f89e --- /dev/null +++ b/vendor/elabapi-python/test/test_metadata_extra_fields.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.metadata_extra_fields import MetadataExtraFields # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestMetadataExtraFields(unittest.TestCase): + """MetadataExtraFields unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testMetadataExtraFields(self): + """Test MetadataExtraFields""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.metadata_extra_fields.MetadataExtraFields() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_notification.py b/vendor/elabapi-python/test/test_notification.py new file mode 100644 index 0000000..21c3900 --- /dev/null +++ b/vendor/elabapi-python/test/test_notification.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.notification import Notification # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestNotification(unittest.TestCase): + """Notification unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testNotification(self): + """Test Notification""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.notification.Notification() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_notifications_api.py b/vendor/elabapi-python/test/test_notifications_api.py new file mode 100644 index 0000000..398ca2f --- /dev/null +++ b/vendor/elabapi-python/test/test_notifications_api.py @@ -0,0 +1,61 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.notifications_api import NotificationsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestNotificationsApi(unittest.TestCase): + """NotificationsApi unit test stubs""" + + def setUp(self): + self.api = NotificationsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_notifications(self): + """Test case for delete_notifications + + Delete all notifications of the user. # noqa: E501 + """ + pass + + def test_patch_notification(self): + """Test case for patch_notification + + Update the acknowledgment status of a notification. # noqa: E501 + """ + pass + + def test_read_notification(self): + """Test case for read_notification + + Read a notification. # noqa: E501 + """ + pass + + def test_read_notifications(self): + """Test case for read_notifications + + Read notifications of a user. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_notifications_subid_body.py b/vendor/elabapi-python/test/test_notifications_subid_body.py new file mode 100644 index 0000000..b9ffc5a --- /dev/null +++ b/vendor/elabapi-python/test/test_notifications_subid_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.notifications_subid_body import NotificationsSubidBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestNotificationsSubidBody(unittest.TestCase): + """NotificationsSubidBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testNotificationsSubidBody(self): + """Test NotificationsSubidBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.notifications_subid_body.NotificationsSubidBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_patch_action.py b/vendor/elabapi-python/test/test_patch_action.py new file mode 100644 index 0000000..683a302 --- /dev/null +++ b/vendor/elabapi-python/test/test_patch_action.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.patch_action import PatchAction # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestPatchAction(unittest.TestCase): + """PatchAction unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testPatchAction(self): + """Test PatchAction""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.patch_action.PatchAction() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_reports_api.py b/vendor/elabapi-python/test/test_reports_api.py new file mode 100644 index 0000000..bd318e7 --- /dev/null +++ b/vendor/elabapi-python/test/test_reports_api.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.reports_api import ReportsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestReportsApi(unittest.TestCase): + """ReportsApi unit test stubs""" + + def setUp(self): + self.api = ReportsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_get_reports(self): + """Test case for get_reports + + Get usage reports # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_resources_categories_api.py b/vendor/elabapi-python/test/test_resources_categories_api.py new file mode 100644 index 0000000..17ee58c --- /dev/null +++ b/vendor/elabapi-python/test/test_resources_categories_api.py @@ -0,0 +1,68 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.resources_categories_api import ResourcesCategoriesApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestResourcesCategoriesApi(unittest.TestCase): + """ResourcesCategoriesApi unit test stubs""" + + def setUp(self): + self.api = ResourcesCategoriesApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_rescat(self): + """Test case for delete_rescat + + Delete a category. # noqa: E501 + """ + pass + + def test_patch_rescat(self): + """Test case for patch_rescat + + Modify a category. # noqa: E501 + """ + pass + + def test_post_team_one_rescat(self): + """Test case for post_team_one_rescat + + Create a new category for resources. # noqa: E501 + """ + pass + + def test_read_team_one_rescat(self): + """Test case for read_team_one_rescat + + Read a category. # noqa: E501 + """ + pass + + def test_read_team_resources_categories(self): + """Test case for read_team_resources_categories + + Read resources categories of a team. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_resources_status_api.py b/vendor/elabapi-python/test/test_resources_status_api.py new file mode 100644 index 0000000..222e38f --- /dev/null +++ b/vendor/elabapi-python/test/test_resources_status_api.py @@ -0,0 +1,68 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.resources_status_api import ResourcesStatusApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestResourcesStatusApi(unittest.TestCase): + """ResourcesStatusApi unit test stubs""" + + def setUp(self): + self.api = ResourcesStatusApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_resstatus(self): + """Test case for delete_resstatus + + Delete a status. # noqa: E501 + """ + pass + + def test_patch_resstatus(self): + """Test case for patch_resstatus + + Modify a status. # noqa: E501 + """ + pass + + def test_post_team_one_resstat(self): + """Test case for post_team_one_resstat + + Create a new status for resources. # noqa: E501 + """ + pass + + def test_read_team_items_status(self): + """Test case for read_team_items_status + + Read resources status of a team. # noqa: E501 + """ + pass + + def test_read_team_one_resstatus(self): + """Test case for read_team_one_resstatus + + Read a status. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_revision.py b/vendor/elabapi-python/test/test_revision.py new file mode 100644 index 0000000..a1e8bdc --- /dev/null +++ b/vendor/elabapi-python/test/test_revision.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.revision import Revision # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestRevision(unittest.TestCase): + """Revision unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testRevision(self): + """Test Revision""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.revision.Revision() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_revisions_api.py b/vendor/elabapi-python/test/test_revisions_api.py new file mode 100644 index 0000000..afb6451 --- /dev/null +++ b/vendor/elabapi-python/test/test_revisions_api.py @@ -0,0 +1,54 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.revisions_api import RevisionsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestRevisionsApi(unittest.TestCase): + """RevisionsApi unit test stubs""" + + def setUp(self): + self.api = RevisionsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_patch_entity_revision(self): + """Test case for patch_entity_revision + + Restore a revision. # noqa: E501 + """ + pass + + def test_read_entity_revision(self): + """Test case for read_entity_revision + + Read a revision of that entity. # noqa: E501 + """ + pass + + def test_read_entity_revisions(self): + """Test case for read_entity_revisions + + Read all revisions of that entity. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_revisions_subid_body.py b/vendor/elabapi-python/test/test_revisions_subid_body.py new file mode 100644 index 0000000..c322fed --- /dev/null +++ b/vendor/elabapi-python/test/test_revisions_subid_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.revisions_subid_body import RevisionsSubidBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestRevisionsSubidBody(unittest.TestCase): + """RevisionsSubidBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testRevisionsSubidBody(self): + """Test RevisionsSubidBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.revisions_subid_body.RevisionsSubidBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_statuslike.py b/vendor/elabapi-python/test/test_statuslike.py new file mode 100644 index 0000000..5ee9904 --- /dev/null +++ b/vendor/elabapi-python/test/test_statuslike.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.statuslike import Statuslike # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestStatuslike(unittest.TestCase): + """Statuslike unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testStatuslike(self): + """Test Statuslike""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.statuslike.Statuslike() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_step.py b/vendor/elabapi-python/test/test_step.py new file mode 100644 index 0000000..4550ca1 --- /dev/null +++ b/vendor/elabapi-python/test/test_step.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.step import Step # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestStep(unittest.TestCase): + """Step unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testStep(self): + """Test Step""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.step.Step() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_steps_api.py b/vendor/elabapi-python/test/test_steps_api.py new file mode 100644 index 0000000..518a34b --- /dev/null +++ b/vendor/elabapi-python/test/test_steps_api.py @@ -0,0 +1,61 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.steps_api import StepsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestStepsApi(unittest.TestCase): + """StepsApi unit test stubs""" + + def setUp(self): + self.api = StepsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_step(self): + """Test case for delete_step + + Delete a step. # noqa: E501 + """ + pass + + def test_patch_step(self): + """Test case for patch_step + + Actions on a step. # noqa: E501 + """ + pass + + def test_post_step(self): + """Test case for post_step + + Create a step. # noqa: E501 + """ + pass + + def test_read_steps(self): + """Test case for read_steps + + Read all steps of that entity. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_steps_subid_body.py b/vendor/elabapi-python/test/test_steps_subid_body.py new file mode 100644 index 0000000..a076a7c --- /dev/null +++ b/vendor/elabapi-python/test/test_steps_subid_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.steps_subid_body import StepsSubidBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestStepsSubidBody(unittest.TestCase): + """StepsSubidBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testStepsSubidBody(self): + """Test StepsSubidBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.steps_subid_body.StepsSubidBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_storage_unit.py b/vendor/elabapi-python/test/test_storage_unit.py new file mode 100644 index 0000000..4ad6975 --- /dev/null +++ b/vendor/elabapi-python/test/test_storage_unit.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.storage_unit import StorageUnit # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestStorageUnit(unittest.TestCase): + """StorageUnit unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testStorageUnit(self): + """Test StorageUnit""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.storage_unit.StorageUnit() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_storage_units_api.py b/vendor/elabapi-python/test/test_storage_units_api.py new file mode 100644 index 0000000..799b30b --- /dev/null +++ b/vendor/elabapi-python/test/test_storage_units_api.py @@ -0,0 +1,68 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.storage_units_api import StorageUnitsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestStorageUnitsApi(unittest.TestCase): + """StorageUnitsApi unit test stubs""" + + def setUp(self): + self.api = StorageUnitsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_storage_unit(self): + """Test case for delete_storage_unit + + Delete a storage unit. # noqa: E501 + """ + pass + + def test_patch_storage_unit(self): + """Test case for patch_storage_unit + + Modify a storage unit. # noqa: E501 + """ + pass + + def test_post_storage_unit(self): + """Test case for post_storage_unit + + Create a new storage unit. # noqa: E501 + """ + pass + + def test_read_storage_unit(self): + """Test case for read_storage_unit + + Read a storage unit. # noqa: E501 + """ + pass + + def test_read_storage_units(self): + """Test case for read_storage_units + + Read all containers, or the storage unit hierarchy when `?hierarchy=true`. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_storage_units_body.py b/vendor/elabapi-python/test/test_storage_units_body.py new file mode 100644 index 0000000..db9b1bc --- /dev/null +++ b/vendor/elabapi-python/test/test_storage_units_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.storage_units_body import StorageUnitsBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestStorageUnitsBody(unittest.TestCase): + """StorageUnitsBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testStorageUnitsBody(self): + """Test StorageUnitsBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.storage_units_body.StorageUnitsBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_storage_units_id_body.py b/vendor/elabapi-python/test/test_storage_units_id_body.py new file mode 100644 index 0000000..1600e0f --- /dev/null +++ b/vendor/elabapi-python/test/test_storage_units_id_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.storage_units_id_body import StorageUnitsIdBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestStorageUnitsIdBody(unittest.TestCase): + """StorageUnitsIdBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testStorageUnitsIdBody(self): + """Test StorageUnitsIdBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.storage_units_id_body.StorageUnitsIdBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_tag.py b/vendor/elabapi-python/test/test_tag.py new file mode 100644 index 0000000..481901c --- /dev/null +++ b/vendor/elabapi-python/test/test_tag.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.tag import Tag # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestTag(unittest.TestCase): + """Tag unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testTag(self): + """Test Tag""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.tag.Tag() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_tags_api.py b/vendor/elabapi-python/test/test_tags_api.py new file mode 100644 index 0000000..28bfb11 --- /dev/null +++ b/vendor/elabapi-python/test/test_tags_api.py @@ -0,0 +1,68 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.tags_api import TagsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestTagsApi(unittest.TestCase): + """TagsApi unit test stubs""" + + def setUp(self): + self.api = TagsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_tag(self): + """Test case for delete_tag + + Delete all tags. # noqa: E501 + """ + pass + + def test_patch_tag(self): + """Test case for patch_tag + + Actions on a tag (like removing it from the entity). # noqa: E501 + """ + pass + + def test_post_tag(self): + """Test case for post_tag + + Create a tag. # noqa: E501 + """ + pass + + def test_read_tag(self): + """Test case for read_tag + + Read a tag. # noqa: E501 + """ + pass + + def test_read_tags(self): + """Test case for read_tags + + Read all tags of that entity. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_tags_subid_body.py b/vendor/elabapi-python/test/test_tags_subid_body.py new file mode 100644 index 0000000..93efb33 --- /dev/null +++ b/vendor/elabapi-python/test/test_tags_subid_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.tags_subid_body import TagsSubidBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestTagsSubidBody(unittest.TestCase): + """TagsSubidBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testTagsSubidBody(self): + """Test TagsSubidBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.tags_subid_body.TagsSubidBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_tags_subid_body1.py b/vendor/elabapi-python/test/test_tags_subid_body1.py new file mode 100644 index 0000000..a3510eb --- /dev/null +++ b/vendor/elabapi-python/test/test_tags_subid_body1.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.tags_subid_body1 import TagsSubidBody1 # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestTagsSubidBody1(unittest.TestCase): + """TagsSubidBody1 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testTagsSubidBody1(self): + """Test TagsSubidBody1""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.tags_subid_body1.TagsSubidBody1() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_team.py b/vendor/elabapi-python/test/test_team.py new file mode 100644 index 0000000..1bb5ea3 --- /dev/null +++ b/vendor/elabapi-python/test/test_team.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.team import Team # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestTeam(unittest.TestCase): + """Team unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testTeam(self): + """Test Team""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.team.Team() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_team_tags_api.py b/vendor/elabapi-python/test/test_team_tags_api.py new file mode 100644 index 0000000..c516b5c --- /dev/null +++ b/vendor/elabapi-python/test/test_team_tags_api.py @@ -0,0 +1,68 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.team_tags_api import TeamTagsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestTeamTagsApi(unittest.TestCase): + """TeamTagsApi unit test stubs""" + + def setUp(self): + self.api = TeamTagsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_team_tag(self): + """Test case for delete_team_tag + + Delete a tag. # noqa: E501 + """ + pass + + def test_patch_team_tag(self): + """Test case for patch_team_tag + + Actions on a tag. # noqa: E501 + """ + pass + + def test_post_team_tag(self): + """Test case for post_team_tag + + Create a tag in the team. # noqa: E501 + """ + pass + + def test_read_team_tag(self): + """Test case for read_team_tag + + Read a tag. # noqa: E501 + """ + pass + + def test_read_team_tags(self): + """Test case for read_team_tags + + Read all tags for the team. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_teamgroup.py b/vendor/elabapi-python/test/test_teamgroup.py new file mode 100644 index 0000000..4b08bc6 --- /dev/null +++ b/vendor/elabapi-python/test/test_teamgroup.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.teamgroup import Teamgroup # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestTeamgroup(unittest.TestCase): + """Teamgroup unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testTeamgroup(self): + """Test Teamgroup""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.teamgroup.Teamgroup() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_teamgroup_users.py b/vendor/elabapi-python/test/test_teamgroup_users.py new file mode 100644 index 0000000..9b90382 --- /dev/null +++ b/vendor/elabapi-python/test/test_teamgroup_users.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.teamgroup_users import TeamgroupUsers # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestTeamgroupUsers(unittest.TestCase): + """TeamgroupUsers unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testTeamgroupUsers(self): + """Test TeamgroupUsers""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.teamgroup_users.TeamgroupUsers() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_teamgroups_api.py b/vendor/elabapi-python/test/test_teamgroups_api.py new file mode 100644 index 0000000..78df247 --- /dev/null +++ b/vendor/elabapi-python/test/test_teamgroups_api.py @@ -0,0 +1,68 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.teamgroups_api import TeamgroupsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestTeamgroupsApi(unittest.TestCase): + """TeamgroupsApi unit test stubs""" + + def setUp(self): + self.api = TeamgroupsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_teamgroup(self): + """Test case for delete_teamgroup + + Delete a teamgroup. # noqa: E501 + """ + pass + + def test_patch_teamgroup(self): + """Test case for patch_teamgroup + + Modify a teamgroup. # noqa: E501 + """ + pass + + def test_post_teamgroups(self): + """Test case for post_teamgroups + + Create a new teamgroup. # noqa: E501 + """ + pass + + def test_read_team_teamgroups(self): + """Test case for read_team_teamgroups + + Read teamgroups of a team. # noqa: E501 + """ + pass + + def test_read_teamgroup(self): + """Test case for read_teamgroup + + Read a teamgroup. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_teamgroups_subid_body.py b/vendor/elabapi-python/test/test_teamgroups_subid_body.py new file mode 100644 index 0000000..258d112 --- /dev/null +++ b/vendor/elabapi-python/test/test_teamgroups_subid_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.teamgroups_subid_body import TeamgroupsSubidBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestTeamgroupsSubidBody(unittest.TestCase): + """TeamgroupsSubidBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testTeamgroupsSubidBody(self): + """Test TeamgroupsSubidBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.teamgroups_subid_body.TeamgroupsSubidBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_teams_api.py b/vendor/elabapi-python/test/test_teams_api.py new file mode 100644 index 0000000..2506414 --- /dev/null +++ b/vendor/elabapi-python/test/test_teams_api.py @@ -0,0 +1,61 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.teams_api import TeamsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestTeamsApi(unittest.TestCase): + """TeamsApi unit test stubs""" + + def setUp(self): + self.api = TeamsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_patch_team(self): + """Test case for patch_team + + Actions on a team. # noqa: E501 + """ + pass + + def test_post_teams(self): + """Test case for post_teams + + Create a new team. # noqa: E501 + """ + pass + + def test_read_team(self): + """Test case for read_team + + Read a team. Requires Admin permissions. # noqa: E501 + """ + pass + + def test_read_teams(self): + """Test case for read_teams + + Read all teams. Requires Sysadmin permissions. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_teams_body.py b/vendor/elabapi-python/test/test_teams_body.py new file mode 100644 index 0000000..a46af1c --- /dev/null +++ b/vendor/elabapi-python/test/test_teams_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.teams_body import TeamsBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestTeamsBody(unittest.TestCase): + """TeamsBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testTeamsBody(self): + """Test TeamsBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.teams_body.TeamsBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_teams_id_body.py b/vendor/elabapi-python/test/test_teams_id_body.py new file mode 100644 index 0000000..23f820f --- /dev/null +++ b/vendor/elabapi-python/test/test_teams_id_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.teams_id_body import TeamsIdBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestTeamsIdBody(unittest.TestCase): + """TeamsIdBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testTeamsIdBody(self): + """Test TeamsIdBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.teams_id_body.TeamsIdBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_todoitem.py b/vendor/elabapi-python/test/test_todoitem.py new file mode 100644 index 0000000..8610ec8 --- /dev/null +++ b/vendor/elabapi-python/test/test_todoitem.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.todoitem import Todoitem # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestTodoitem(unittest.TestCase): + """Todoitem unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testTodoitem(self): + """Test Todoitem""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.todoitem.Todoitem() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_todolist_api.py b/vendor/elabapi-python/test/test_todolist_api.py new file mode 100644 index 0000000..7f9fde8 --- /dev/null +++ b/vendor/elabapi-python/test/test_todolist_api.py @@ -0,0 +1,68 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.todolist_api import TodolistApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestTodolistApi(unittest.TestCase): + """TodolistApi unit test stubs""" + + def setUp(self): + self.api = TodolistApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_todoitem(self): + """Test case for delete_todoitem + + Delete a todoitem. # noqa: E501 + """ + pass + + def test_patch_todoitem(self): + """Test case for patch_todoitem + + Actions on a todoitem. # noqa: E501 + """ + pass + + def test_post_todolist(self): + """Test case for post_todolist + + Create a todo item # noqa: E501 + """ + pass + + def test_read_todoitem(self): + """Test case for read_todoitem + + Read a todo entry. # noqa: E501 + """ + pass + + def test_read_todolist(self): + """Test case for read_todolist + + Read all todoitems. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_todolist_body.py b/vendor/elabapi-python/test/test_todolist_body.py new file mode 100644 index 0000000..86303fe --- /dev/null +++ b/vendor/elabapi-python/test/test_todolist_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.todolist_body import TodolistBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestTodolistBody(unittest.TestCase): + """TodolistBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testTodolistBody(self): + """Test TodolistBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.todolist_body.TodolistBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_todolist_id_body.py b/vendor/elabapi-python/test/test_todolist_id_body.py new file mode 100644 index 0000000..dcb1586 --- /dev/null +++ b/vendor/elabapi-python/test/test_todolist_id_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.todolist_id_body import TodolistIdBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestTodolistIdBody(unittest.TestCase): + """TodolistIdBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testTodolistIdBody(self): + """Test TodolistIdBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.todolist_id_body.TodolistIdBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_unfinished_step.py b/vendor/elabapi-python/test/test_unfinished_step.py new file mode 100644 index 0000000..974664d --- /dev/null +++ b/vendor/elabapi-python/test/test_unfinished_step.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.unfinished_step import UnfinishedStep # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestUnfinishedStep(unittest.TestCase): + """UnfinishedStep unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testUnfinishedStep(self): + """Test UnfinishedStep""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.unfinished_step.UnfinishedStep() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_unfinished_steps.py b/vendor/elabapi-python/test/test_unfinished_steps.py new file mode 100644 index 0000000..33f6eb8 --- /dev/null +++ b/vendor/elabapi-python/test/test_unfinished_steps.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.unfinished_steps import UnfinishedSteps # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestUnfinishedSteps(unittest.TestCase): + """UnfinishedSteps unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testUnfinishedSteps(self): + """Test UnfinishedSteps""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.unfinished_steps.UnfinishedSteps() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_unfinished_steps_api.py b/vendor/elabapi-python/test/test_unfinished_steps_api.py new file mode 100644 index 0000000..c588e7f --- /dev/null +++ b/vendor/elabapi-python/test/test_unfinished_steps_api.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.unfinished_steps_api import UnfinishedStepsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestUnfinishedStepsApi(unittest.TestCase): + """UnfinishedStepsApi unit test stubs""" + + def setUp(self): + self.api = UnfinishedStepsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_read_unfinished_steps(self): + """Test case for read_unfinished_steps + + Read all unfinished steps. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_upload.py b/vendor/elabapi-python/test/test_upload.py new file mode 100644 index 0000000..3756e19 --- /dev/null +++ b/vendor/elabapi-python/test/test_upload.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.upload import Upload # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestUpload(unittest.TestCase): + """Upload unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testUpload(self): + """Test Upload""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.upload.Upload() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_uploads_api.py b/vendor/elabapi-python/test/test_uploads_api.py new file mode 100644 index 0000000..89db18a --- /dev/null +++ b/vendor/elabapi-python/test/test_uploads_api.py @@ -0,0 +1,75 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.uploads_api import UploadsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestUploadsApi(unittest.TestCase): + """UploadsApi unit test stubs""" + + def setUp(self): + self.api = UploadsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_delete_upload(self): + """Test case for delete_upload + + Delete an upload. # noqa: E501 + """ + pass + + def test_patch_upload(self): + """Test case for patch_upload + + Modify attributes such as \"real_name\", \"comment\" or \"state\" of an upload. # noqa: E501 + """ + pass + + def test_post_upload(self): + """Test case for post_upload + + Create an upload. # noqa: E501 + """ + pass + + def test_post_upload_replace(self): + """Test case for post_upload_replace + + Replace an existing uploaded file. The existing file will be archived and the new one will be added. # noqa: E501 + """ + pass + + def test_read_upload(self): + """Test case for read_upload + + Read an upload. # noqa: E501 + """ + pass + + def test_read_uploads(self): + """Test case for read_uploads + + Read attached files of that entity. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_uploads_subid_body.py b/vendor/elabapi-python/test/test_uploads_subid_body.py new file mode 100644 index 0000000..2df0ae6 --- /dev/null +++ b/vendor/elabapi-python/test/test_uploads_subid_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.uploads_subid_body import UploadsSubidBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestUploadsSubidBody(unittest.TestCase): + """UploadsSubidBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testUploadsSubidBody(self): + """Test UploadsSubidBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.uploads_subid_body.UploadsSubidBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_uploads_subid_body1.py b/vendor/elabapi-python/test/test_uploads_subid_body1.py new file mode 100644 index 0000000..126bbcb --- /dev/null +++ b/vendor/elabapi-python/test/test_uploads_subid_body1.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.uploads_subid_body1 import UploadsSubidBody1 # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestUploadsSubidBody1(unittest.TestCase): + """UploadsSubidBody1 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testUploadsSubidBody1(self): + """Test UploadsSubidBody1""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.uploads_subid_body1.UploadsSubidBody1() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_user_uploads_api.py b/vendor/elabapi-python/test/test_user_uploads_api.py new file mode 100644 index 0000000..37c68f1 --- /dev/null +++ b/vendor/elabapi-python/test/test_user_uploads_api.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.user_uploads_api import UserUploadsApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestUserUploadsApi(unittest.TestCase): + """UserUploadsApi unit test stubs""" + + def setUp(self): + self.api = UserUploadsApi() # noqa: E501 + + def tearDown(self): + pass + + def test_read_user_uploads(self): + """Test case for read_user_uploads + + Read attached files from a user # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_users.py b/vendor/elabapi-python/test/test_users.py new file mode 100644 index 0000000..1daaa3f --- /dev/null +++ b/vendor/elabapi-python/test/test_users.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.users import Users # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestUsers(unittest.TestCase): + """Users unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testUsers(self): + """Test Users""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.users.Users() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_users_api.py b/vendor/elabapi-python/test/test_users_api.py new file mode 100644 index 0000000..7b9f744 --- /dev/null +++ b/vendor/elabapi-python/test/test_users_api.py @@ -0,0 +1,61 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.api.users_api import UsersApi # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestUsersApi(unittest.TestCase): + """UsersApi unit test stubs""" + + def setUp(self): + self.api = UsersApi() # noqa: E501 + + def tearDown(self): + pass + + def test_patch_user(self): + """Test case for patch_user + + Modify a user. # noqa: E501 + """ + pass + + def test_post_user(self): + """Test case for post_user + + Create a new user. # noqa: E501 + """ + pass + + def test_read_user(self): + """Test case for read_user + + Read information of a user. # noqa: E501 + """ + pass + + def test_read_users(self): + """Test case for read_users + + Read users from instance. # noqa: E501 + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_users_body.py b/vendor/elabapi-python/test/test_users_body.py new file mode 100644 index 0000000..48012ae --- /dev/null +++ b/vendor/elabapi-python/test/test_users_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.users_body import UsersBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestUsersBody(unittest.TestCase): + """UsersBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testUsersBody(self): + """Test UsersBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.users_body.UsersBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_users_full.py b/vendor/elabapi-python/test/test_users_full.py new file mode 100644 index 0000000..e9292c6 --- /dev/null +++ b/vendor/elabapi-python/test/test_users_full.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.users_full import UsersFull # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestUsersFull(unittest.TestCase): + """UsersFull unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testUsersFull(self): + """Test UsersFull""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.users_full.UsersFull() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_users_full_teams.py b/vendor/elabapi-python/test/test_users_full_teams.py new file mode 100644 index 0000000..3046d5f --- /dev/null +++ b/vendor/elabapi-python/test/test_users_full_teams.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.users_full_teams import UsersFullTeams # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestUsersFullTeams(unittest.TestCase): + """UsersFullTeams unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testUsersFullTeams(self): + """Test UsersFullTeams""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.users_full_teams.UsersFullTeams() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/vendor/elabapi-python/test/test_users_id_body.py b/vendor/elabapi-python/test/test_users_id_body.py new file mode 100644 index 0000000..0434fdb --- /dev/null +++ b/vendor/elabapi-python/test/test_users_id_body.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + eLabFTW REST API v2 Documentation + + This document describes all available endpoints and methods for eLabFTW's API version 2. # noqa: E501 + + OpenAPI spec version: 2.0.0 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import unittest + +import elabapi_python +from elabapi_python.models.users_id_body import UsersIdBody # noqa: E501 +from elabapi_python.rest import ApiException + + +class TestUsersIdBody(unittest.TestCase): + """UsersIdBody unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testUsersIdBody(self): + """Test UsersIdBody""" + # FIXME: construct object with mandatory attributes with example values + # model = elabapi_python.models.users_id_body.UsersIdBody() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main()