python-openarch-api 0.1.0__py3-none-any.whl

python_openarch_api/_sync/client.py

@@ -0,0 +1,660 @@
+"""The OpenArch REST client (sync). GENERATED from ``_async/client.py`` by ``scripts/unasync.py``
+-- do not edit; change the async client and regenerate.
+
+Every operation of ``docs/openapi/openarch-api.yaml`` has a method here, named after its operationId in
+snake case (a few shortened: ``get_document_by_id`` -> ``get_document``). Request bodies take a
+model or a plain dict; responses come back as models (``OpenArchDocument`` for documents).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import Any, TypeVar
+from urllib.parse import quote
+
+import httpx
+from pydantic import BaseModel, TypeAdapter
+
+from .._version import __version__
+from ..auth import TokenSource, build_auth
+from ..errors import OpenArchError
+from ..models.document import OpenArchDocument, OpenArchQueryResult
+from ..models.generated import (
+    AdvancedQuery,
+    CopyCommand,
+    DocumentAncestors,
+    Embedding,
+    ExternalUserRelationsSecurityPolicyRelations,
+    Group,
+    ListEffectiveACLDTO,
+    ListEffectivePermissionsDTO,
+    Model,
+    MoveCommand,
+    NamedQuery,
+    NamedQueryDefinition,
+    Query,
+    QuerySyntax,
+    SecurityPolicies,
+    TermsAggregationsQuery,
+    Upload,
+    UploadFileInfo,
+    User,
+    VectorQuery,
+    VectorSearchResult,
+    Vocabulary,
+    VocabularyEntry,
+    VocabularyEntryRequest,
+    VocabularyId,
+)
+
+T = TypeVar("T")
+
+REPOSITORY_HEADER = "HXCS-REPOSITORY"
+# Hyland's hosted Content REST API requires a "[product]/[version]" User-Agent; override it with
+# headers={"User-Agent": "MyProduct/1.0"}.
+USER_AGENT = f"python-openarch-api/{__version__}"
+JSON_PATCH = "application/json-patch+json"
+
+Body = BaseModel | Mapping[str, Any]
+JsonPatch = Sequence[Mapping[str, Any]]
+
+
+def _seg(value: str) -> str:
+    """One path segment (an id): every reserved character escaped."""
+    return quote(str(value), safe="")
+
+
+def _doc_path(path: str) -> str:
+    """A repository path in the URL: its slashes stay unescaped (OpenArch reads them as the path)."""
+    return quote(str(path).lstrip("/"), safe="/")
+
+
+def _body(value: Body | None) -> Any:
+    if isinstance(value, BaseModel):
+        return value.model_dump(mode="json", by_alias=True, exclude_none=True)
+    return value
+
+
+def _params(**kw: Any) -> dict[str, Any]:
+    return {k: (str(v).lower() if isinstance(v, bool) else v) for k, v in kw.items() if v is not None}
+
+
+def _write_params(
+    condition: str | None = None, if_: str | None = None, upsert: bool | None = None,
+    user_change: bool | None = None,
+) -> dict[str, Any]:
+    """The query parameters of a document write. ``condition`` (an HXQL predicate) and ``if_`` (an
+    expression, e.g. ``content.sys_title == "foo"``) are mutually exclusive; ``user_change=False``
+    marks a technical update (``sys_ugen`` is not incremented)."""
+    return _params(condition=condition, upsert=upsert, userChange=user_change, **{"if": if_})
+
+
+class OpenArchClient:
+    """Client for the OpenArch (Hyland repository) REST API.
+
+    Authenticate with ``username`` + ``password`` (Basic, a local OpenArch), a bearer ``token``
+    (a string, or a callable returning the current token), or any ``httpx.Auth``. ``repository``
+    is sent as the ``HXCS-REPOSITORY`` header; the per-call ``repository`` argument overrides it.
+    ``http_client`` replaces the client built here; ``transport`` plugs into it (proxies, tests).
+    """
+
+    def __init__(
+        self,
+        base_url: str = "http://localhost:8080",
+        *,
+        repository: str | None = "default",
+        username: str | None = None,
+        password: str | None = None,
+        token: TokenSource | None = None,
+        auth: httpx.Auth | None = None,
+        timeout: float | httpx.Timeout = 30.0,
+        http_client: httpx.Client | None = None,
+        transport: httpx.BaseTransport | None = None,
+        headers: Mapping[str, str] | None = None,
+    ):
+        self.repository = repository
+        self._owns_client = http_client is None
+        self._http = http_client or httpx.Client(
+            base_url=base_url.rstrip("/"),
+            auth=build_auth(username=username, password=password, token=token, auth=auth),
+            timeout=timeout,
+            transport=transport,
+            headers={"Accept": "application/json", "User-Agent": USER_AGENT, **dict(headers or {})},
+        )
+
+    def __enter__(self) -> OpenArchClient:
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        self.close()
+
+    def close(self) -> None:
+        if self._owns_client:
+            self._http.close()
+
+    # ── plumbing ──────────────────────────────────────────────────────────────────────────
+
+    def _send(
+        self,
+        method: str,
+        url: str,
+        *,
+        params: Mapping[str, Any] | None = None,
+        json: Any = None,
+        content: Any = None,
+        files: Any = None,
+        data: Any = None,
+        content_type: str | None = None,
+        repository: str | None = None,
+        accept: str | None = None,
+    ) -> httpx.Response:
+        headers: dict[str, str] = {}
+        repo = repository if repository is not None else self.repository
+        if repo:
+            headers[REPOSITORY_HEADER] = repo
+        if content_type:
+            headers["Content-Type"] = content_type
+        if accept:
+            headers["Accept"] = accept
+        if json is not None and content_type:
+            import json as _json
+
+            content, json = _json.dumps(json), None
+        response = self._http.request(
+            method, url, params=params, json=json, content=content, files=files, data=data, headers=headers
+        )
+        if response.is_error:
+            response.read()
+            raise OpenArchError.from_response(response)
+        return response
+
+    @staticmethod
+    def _parse(response: httpx.Response, model: type[T]) -> T:
+        return TypeAdapter(model).validate_python(response.json())
+
+    @staticmethod
+    def _json(response: httpx.Response) -> Any:
+        return response.json() if response.content else None
+
+    # ── Documents: by id ──────────────────────────────────────────────────────────────────
+
+    def get_document(self, doc_id: str, *, repository: str | None = None) -> OpenArchDocument:
+        r = self._send("GET", f"/api/documents/{_seg(doc_id)}", repository=repository)
+        return self._parse(r, OpenArchDocument)
+
+    def create_document(
+        self,
+        parent_id: str,
+        document: Body,
+        *,
+        enforce_sys_name: bool | None = None,
+        files: Mapping[str, Any] | None = None,
+        repository: str | None = None,
+    ) -> OpenArchDocument:
+        """Create ``document`` under the folder ``parent_id``.
+
+        ``files`` (part name -> an httpx file value) sends binary content in the same request: the
+        part name is free, and a blob property of the document points at it, e.g.
+        ``{"sysfile_blob": {"uploadId": "f1"}}`` with ``files={"f1": ("a.txt", data, "text/plain")}``.
+        The id of an earlier :meth:`upload` works the same way, without ``files``."""
+        return self._write_document(
+            "POST", f"/api/documents/{_seg(parent_id)}", document, files,
+            _params(enforceSysName=enforce_sys_name), repository,
+        )
+
+    def update_document(
+        self,
+        doc_id: str,
+        document: Body,
+        *,
+        condition: str | None = None,
+        if_: str | None = None,
+        upsert: bool | None = None,
+        user_change: bool | None = None,
+        files: Mapping[str, Any] | None = None,
+        repository: str | None = None,
+    ) -> OpenArchDocument:
+        """Replace the document's properties. ``condition`` / ``if_``: a predicate it must match;
+        ``upsert=True`` creates it when it does not exist (HTTP 201)."""
+        return self._write_document(
+            "PUT", f"/api/documents/{_seg(doc_id)}", document, files,
+            _write_params(condition, if_, upsert, user_change), repository,
+        )
+
+    def patch_document(
+        self, doc_id: str, patch: JsonPatch, *, condition: str | None = None, if_: str | None = None,
+        user_change: bool | None = None, repository: str | None = None,
+    ) -> OpenArchDocument:
+        """Apply a JSON Patch (``[{"op": "replace", "path": "/sys_title", "value": "x"}]``)."""
+        r = self._send(
+            "PATCH", f"/api/documents/{_seg(doc_id)}", json=list(patch), content_type=JSON_PATCH,
+            params=_write_params(condition, if_, None, user_change), repository=repository,
+        )
+        return self._parse(r, OpenArchDocument)
+
+    def delete_document(self, doc_id: str, *, repository: str | None = None) -> None:
+        self._send("DELETE", f"/api/documents/{_seg(doc_id)}", repository=repository)
+
+    # ── Documents: by path ────────────────────────────────────────────────────────────────
+
+    def get_document_by_path(self, path: str, *, repository: str | None = None) -> OpenArchDocument:
+        r = self._send("GET", f"/api/documents/path/{_doc_path(path)}", repository=repository)
+        return self._parse(r, OpenArchDocument)
+
+    def create_document_by_path(
+        self,
+        parent_path: str,
+        document: Body,
+        *,
+        enforce_sys_name: bool | None = None,
+        files: Mapping[str, Any] | None = None,
+        repository: str | None = None,
+    ) -> OpenArchDocument:
+        return self._write_document(
+            "POST", f"/api/documents/path/{_doc_path(parent_path)}", document, files,
+            _params(enforceSysName=enforce_sys_name), repository,
+        )
+
+    def update_document_by_path(
+        self,
+        path: str,
+        document: Body,
+        *,
+        condition: str | None = None,
+        if_: str | None = None,
+        upsert: bool | None = None,
+        user_change: bool | None = None,
+        files: Mapping[str, Any] | None = None,
+        repository: str | None = None,
+    ) -> OpenArchDocument:
+        return self._write_document(
+            "PUT", f"/api/documents/path/{_doc_path(path)}", document, files,
+            _write_params(condition, if_, upsert, user_change), repository,
+        )
+
+    def patch_document_by_path(
+        self, path: str, patch: JsonPatch, *, condition: str | None = None, if_: str | None = None,
+        user_change: bool | None = None, repository: str | None = None,
+    ) -> OpenArchDocument:
+        r = self._send(
+            "PATCH", f"/api/documents/path/{_doc_path(path)}", json=list(patch), content_type=JSON_PATCH,
+            params=_write_params(condition, if_, None, user_change), repository=repository,
+        )
+        return self._parse(r, OpenArchDocument)
+
+    def delete_document_by_path(self, path: str, *, repository: str | None = None) -> None:
+        self._send("DELETE", f"/api/documents/path/{_doc_path(path)}", repository=repository)
+
+    def exists_by_path(self, path: str, *, repository: str | None = None) -> bool:
+        from ..errors import OpenArchNotFoundError
+
+        try:
+            self.get_document_by_path(path, repository=repository)
+            return True
+        except OpenArchNotFoundError:
+            return False
+
+    def _write_document(
+        self, method: str, url: str, document: Body, files: Mapping[str, Any] | None,
+        params: dict[str, Any], repository: str | None,
+    ) -> OpenArchDocument:
+        if files:
+            import json as _json
+
+            parts = {"main": (None, _json.dumps(_body(document)), "application/json"), **dict(files)}
+            r = self._send(method, url, files=parts, params=params, repository=repository)
+        else:
+            r = self._send(method, url, json=_body(document), params=params, repository=repository)
+        return self._parse(r, OpenArchDocument)
+
+    # ── Documents: other operations ───────────────────────────────────────────────────────
+
+    def get_ancestors(self, doc_id: str, *, repository: str | None = None) -> DocumentAncestors:
+        r = self._send("GET", f"/api/documents/{_seg(doc_id)}/ancestors", repository=repository)
+        return self._parse(r, DocumentAncestors)
+
+    def checkin(
+        self, doc_id: str, *, minor: bool | None = None, user_change: bool | None = None,
+        repository: str | None = None,
+    ) -> OpenArchDocument:
+        r = self._send(
+            "POST", f"/api/documents/{_seg(doc_id)}/checkin", params=_params(minor=minor, userChange=user_change),
+            repository=repository,
+        )
+        return self._parse(r, OpenArchDocument)
+
+    def copy(self, doc_id: str, command: CopyCommand | Body, *, repository: str | None = None) -> OpenArchDocument:
+        r = self._send("POST", f"/api/documents/{_seg(doc_id)}/copy", json=_body(command), repository=repository)
+        return self._parse(r, OpenArchDocument)
+
+    def move(
+        self, doc_id: str, command: MoveCommand | Body, *, condition: str | None = None, if_: str | None = None,
+        user_change: bool | None = None, repository: str | None = None,
+    ) -> OpenArchDocument:
+        r = self._send(
+            "POST", f"/api/documents/{_seg(doc_id)}/move", json=_body(command),
+            params=_write_params(condition, if_, None, user_change), repository=repository,
+        )
+        return self._parse(r, OpenArchDocument)
+
+    def restore_version(
+        self, version_id: str, *, user_change: bool | None = None, repository: str | None = None
+    ) -> OpenArchDocument:
+        r = self._send(
+            "POST", f"/api/documents/{_seg(version_id)}/restore", params=_params(userChange=user_change),
+            repository=repository,
+        )
+        return self._parse(r, OpenArchDocument)
+
+    def get_embedding(self, doc_id: str, embedding_id: str, *, repository: str | None = None) -> Embedding:
+        r = self._send(
+            "GET", f"/api/documents/{_seg(doc_id)}/embedding/{_seg(embedding_id)}", repository=repository
+        )
+        return self._parse(r, Embedding)
+
+    def get_full_effective_acl(
+        self, doc_id: str, usernames: Sequence[str] | None = None, *, repository: str | None = None
+    ) -> ListEffectiveACLDTO:
+        r = self._send(
+            "GET", f"/api/documents/{_seg(doc_id)}/fulleffectiveacl",
+            params=_params(usernames=list(usernames) if usernames else None), repository=repository,
+        )
+        return self._parse(r, ListEffectiveACLDTO)
+
+    def get_full_effective_permissions(
+        self, doc_id: str, usernames: Sequence[str] | None = None, *, repository: str | None = None
+    ) -> ListEffectivePermissionsDTO:
+        r = self._send(
+            "GET", f"/api/documents/{_seg(doc_id)}/fulleffectivepermissions",
+            params=_params(usernames=list(usernames) if usernames else None), repository=repository,
+        )
+        return self._parse(r, ListEffectivePermissionsDTO)
+
+    # ── Download ──────────────────────────────────────────────────────────────────────────
+
+    def download(
+        self, doc_id: str, property_xpath_and_filename: str, *, inline: bool | None = None,
+        repository: str | None = None,
+    ) -> bytes:
+        """The blob at ``property_xpath_and_filename`` (e.g. ``file:content/report.pdf``)."""
+        r = self._send(
+            "GET", f"/api/download/{_seg(doc_id)}/{_doc_path(property_xpath_and_filename)}",
+            params=_params(inline=inline), repository=repository, accept="*/*",
+        )
+        return r.content
+
+    def download_info(
+        self, doc_id: str, property_xpath_and_filename: str, *, repository: str | None = None
+    ) -> httpx.Headers:
+        r = self._send(
+            "HEAD", f"/api/download/{_seg(doc_id)}/{_doc_path(property_xpath_and_filename)}",
+            repository=repository, accept="*/*",
+        )
+        return r.headers
+
+    def download_url(
+        self, doc_id: str, property_xpath_and_filename: str, *, expiration: int | None = None,
+        inline: bool | None = None, repository: str | None = None,
+    ) -> str:
+        """A pre-signed URL for the blob (``expiration`` in seconds)."""
+        r = self._send(
+            "GET", f"/api/download/url/{_seg(doc_id)}/{_doc_path(property_xpath_and_filename)}",
+            params=_params(expiration=expiration, inline=inline), repository=repository, accept="*/*",
+        )
+        return r.text
+
+    # ── Query ─────────────────────────────────────────────────────────────────────────────
+
+    def query(
+        self,
+        query: str | Query | Body,
+        *,
+        limit: int | None = None,
+        offset: int | None = None,
+        sort: Sequence[str] | None = None,
+        track_total_count: bool | None = None,
+        syntax: QuerySyntax | str | None = None,
+        search_after: str | None = None,
+        sync: bool | None = None,
+    ) -> OpenArchQueryResult:
+        """Run an HXQL query (``"SELECT * FROM SysContent WHERE ..."``) or a ``Query``.
+
+        ``syntax="expr"`` for an expression query; ``search_after`` is the ``next_search_after`` of
+        the previous page (``offset`` is then ignored). ``limit`` defaults to the server's 10."""
+        if isinstance(query, str):
+            fields = dict(
+                limit=limit, offset=offset, sort=list(sort) if sort else None, track_total_count=track_total_count,
+                syntax=QuerySyntax(syntax) if syntax else None, search_after=search_after,
+            )
+            query = Query(
+                query=query,
+                repository_id=self.repository or "default",
+                **{k: v for k, v in fields.items() if v is not None},
+            )
+        r = self._send("POST", "/api/query", json=_body(query), params=_params(sync=sync))
+        return self._parse(r, OpenArchQueryResult)
+
+    def advanced_query(self, query: AdvancedQuery | Body, *, sync: bool | None = None) -> OpenArchQueryResult:
+        r = self._send("POST", "/api/query/advanced", json=_body(query), params=_params(sync=sync))
+        return self._parse(r, OpenArchQueryResult)
+
+    def named_query(self, query: NamedQuery | Body, *, sync: bool | None = None) -> OpenArchQueryResult:
+        r = self._send("POST", "/api/query/named", json=_body(query), params=_params(sync=sync))
+        return self._parse(r, OpenArchQueryResult)
+
+    def list_named_queries(self) -> Any:
+        return self._json(self._send("GET", "/api/query/named"))
+
+    def get_named_query(self, name: str) -> NamedQueryDefinition:
+        r = self._send("GET", f"/api/query/named/{_seg(name)}")
+        return self._parse(r, NamedQueryDefinition)
+
+    def terms_aggregation(self, query: TermsAggregationsQuery | Body) -> OpenArchQueryResult:
+        """Counts per term, in the result's ``aggregations_buckets``."""
+        r = self._send("POST", "/api/query/termsAggregation", json=_body(query))
+        return self._parse(r, OpenArchQueryResult)
+
+    def vector_search(self, query: VectorQuery | Body) -> VectorSearchResult:
+        """Nearest embeddings to a vector (``/api/query/embeddings``)."""
+        r = self._send("POST", "/api/query/embeddings", json=_body(query))
+        return self._parse(r, VectorSearchResult)
+
+    def wait_for_indexing(
+        self, *, refresh: bool | None = None, timeout: int | None = None, wait_for_audit: bool | None = None,
+        repository: str | None = None,
+    ) -> Any:
+        """Block until full-text indexing has caught up (tests, read-after-write)."""
+        return self._json(self._send(
+            "GET", "/api/query/waitForFullTextSearchIndexing",
+            params=_params(refresh=refresh, timeout=timeout, waitForAudit=wait_for_audit), repository=repository,
+        ))
+
+    # ── Users, groups ─────────────────────────────────────────────────────────────────────
+
+    def search_users(self, name: str) -> list[User]:
+        r = self._send("GET", "/api/user", params={"name": name})
+        return self._parse(r, list[User])
+
+    def get_user(self, user_id: str) -> User:
+        return self._parse(self._send("GET", f"/api/user/{_seg(user_id)}"), User)
+
+    def search_groups(self, name: str) -> list[Group]:
+        r = self._send("GET", "/api/group", params={"name": name})
+        return self._parse(r, list[Group])
+
+    def get_group(self, group_id: str) -> Group:
+        return self._parse(self._send("GET", f"/api/group/{_seg(group_id)}"), Group)
+
+    def hello(self, *, protected: bool = False) -> str:
+        """Connectivity check; ``protected=True`` also checks the credentials."""
+        r = self._send("GET", "/hello/protected" if protected else "/hello", accept="text/plain")
+        return r.text
+
+    # ── Repository model, security policies ───────────────────────────────────────────────
+    #
+    # The v1 methods send and return the model / policies alone. The ``_v2`` methods carry a
+    # ``version`` for optimistic locking: read it with get_*_v2 and send it back with set_*_v2.
+
+    def get_model(self, *, project_id: str | None = None, repository: str | None = None) -> Model:
+        url = "/api/repository/model" + (f"/project/{_seg(project_id)}" if project_id else "")
+        return self._parse(self._send("GET", url, repository=repository), Model)
+
+    def set_model(
+        self, model: Model | Body, *, project_id: str | None = None, validate_only: bool | None = None,
+        repository: str | None = None,
+    ) -> Model | None:
+        url = "/api/repository/model" + (f"/project/{_seg(project_id)}" if project_id else "")
+        r = self._send("PUT", url, json=_body(model), params=_params(validateOnly=validate_only), repository=repository)
+        return self._parse(r, Model) if r.content else None
+
+    def patch_model(
+        self, patch: JsonPatch, *, validate_only: bool | None = None, repository: str | None = None
+    ) -> Model | None:
+        r = self._send(
+            "PATCH", "/api/repository/model", json=list(patch), content_type=JSON_PATCH,
+            params=_params(validateOnly=validate_only), repository=repository,
+        )
+        return self._parse(r, Model) if r.content else None
+
+    def get_model_v2(self, *, project_id: str | None = None, repository: str | None = None) -> Model:
+        url = "/api/v2/repository/model" + (f"/project/{_seg(project_id)}" if project_id else "")
+        return self._parse(self._send("GET", url, repository=repository), Model)
+
+    def set_model_v2(
+        self, model: Model | Body, *, project_id: str | None = None, validate_only: bool | None = None,
+        repository: str | None = None,
+    ) -> Model | None:
+        url = "/api/v2/repository/model" + (f"/project/{_seg(project_id)}" if project_id else "")
+        r = self._send("PUT", url, json=_body(model), params=_params(validateOnly=validate_only), repository=repository)
+        return self._parse(r, Model) if r.content else None
+
+    def get_security_policies(self, *, repository: str | None = None) -> Any:
+        return self._json(self._send("GET", "/api/repository/security/policies", repository=repository))
+
+    def set_security_policies(
+        self, policies: Body, *, project_id: str | None = None, validate_only: bool | None = None,
+        repository: str | None = None,
+    ) -> Any:
+        url = "/api/repository/security/policies" + (f"/project/{_seg(project_id)}" if project_id else "")
+        return self._json(self._send(
+            "PUT", url, json=_body(policies), params=_params(validateOnly=validate_only), repository=repository
+        ))
+
+    def patch_security_policies(
+        self, patch: JsonPatch, *, validate_only: bool | None = None, repository: str | None = None
+    ) -> Any:
+        return self._json(self._send(
+            "PATCH", "/api/repository/security/policies", json=list(patch), content_type=JSON_PATCH,
+            params=_params(validateOnly=validate_only), repository=repository,
+        ))
+
+    def get_security_policies_v2(self, *, repository: str | None = None) -> SecurityPolicies:
+        r = self._send("GET", "/api/v2/repository/security/policies", repository=repository)
+        return self._parse(r, SecurityPolicies)
+
+    def set_security_policies_v2(
+        self, policies: SecurityPolicies | Body, *, project_id: str | None = None,
+        validate_only: bool | None = None, repository: str | None = None,
+    ) -> SecurityPolicies | None:
+        url = "/api/v2/repository/security/policies" + (f"/project/{_seg(project_id)}" if project_id else "")
+        r = self._send("PUT", url, json=_body(policies), params=_params(validateOnly=validate_only), repository=repository)
+        return self._parse(r, SecurityPolicies) if r.content else None
+
+    def get_external_user_relations(
+        self, policy_name: str, *, repository: str | None = None
+    ) -> ExternalUserRelationsSecurityPolicyRelations:
+        r = self._send(
+            "GET", f"/api/repository/security/policies/{_seg(policy_name)}/externaluserrelations", repository=repository
+        )
+        return self._parse(r, ExternalUserRelationsSecurityPolicyRelations)
+
+    def set_external_user_relations(
+        self, policy_name: str, relations: ExternalUserRelationsSecurityPolicyRelations | Body, *,
+        repository: str | None = None,
+    ) -> None:
+        self._send(
+            "PUT", f"/api/repository/security/policies/{_seg(policy_name)}/externaluserrelations",
+            json=_body(relations), repository=repository,
+        )
+
+    def get_external_user_relations_status(self, policy_name: str, *, repository: str | None = None) -> Any:
+        return self._json(self._send(
+            "GET", f"/api/repository/security/policies/{_seg(policy_name)}/externaluserrelations/status",
+            repository=repository,
+        ))
+
+    # ── Vocabularies ──────────────────────────────────────────────────────────────────────
+
+    def list_vocabularies(self, *, repository: str | None = None) -> list[VocabularyId]:
+        return self._parse(self._send("GET", "/api/vocabularies", repository=repository), list[VocabularyId])
+
+    def create_vocabulary(self, vocabulary: Vocabulary | Body, *, repository: str | None = None) -> Vocabulary:
+        r = self._send("POST", "/api/vocabularies", json=_body(vocabulary), repository=repository)
+        return self._parse(r, Vocabulary)
+
+    def delete_vocabulary(self, vocabulary_id: str, *, repository: str | None = None) -> None:
+        self._send("DELETE", f"/api/vocabularies/{_seg(vocabulary_id)}", repository=repository)
+
+    def get_vocabulary_entries(self, vocabulary_id: str, *, repository: str | None = None) -> list[VocabularyEntry]:
+        r = self._send("GET", f"/api/vocabularies/{_seg(vocabulary_id)}", repository=repository)
+        return self._parse(r, list[VocabularyEntry])
+
+    def create_vocabulary_entry(
+        self, vocabulary_id: str, entry: VocabularyEntryRequest | Body, *, repository: str | None = None
+    ) -> VocabularyEntry:
+        r = self._send("POST", f"/api/vocabularies/{_seg(vocabulary_id)}", json=_body(entry), repository=repository)
+        return self._parse(r, VocabularyEntry)
+
+    def update_vocabulary_entry(
+        self, vocabulary_id: str, entry: VocabularyEntryRequest | Body, *, repository: str | None = None
+    ) -> VocabularyEntry:
+        r = self._send("PUT", f"/api/vocabularies/{_seg(vocabulary_id)}", json=_body(entry), repository=repository)
+        return self._parse(r, VocabularyEntry)
+
+    def get_vocabulary_entry(self, vocabulary_id: str, key: str, *, repository: str | None = None) -> VocabularyEntry:
+        r = self._send("GET", f"/api/vocabularies/{_seg(vocabulary_id)}/{_seg(key)}", repository=repository)
+        return self._parse(r, VocabularyEntry)
+
+    def delete_vocabulary_entry(self, vocabulary_id: str, key: str, *, repository: str | None = None) -> None:
+        self._send("DELETE", f"/api/vocabularies/{_seg(vocabulary_id)}/{_seg(key)}", repository=repository)
+
+    # ── Upload ────────────────────────────────────────────────────────────────────────────
+
+    def create_upload(self) -> Upload:
+        return self._parse(self._send("POST", "/api/upload/create"), Upload)
+
+    def upload(
+        self,
+        data: bytes,
+        *,
+        file_name: str | None = None,
+        mime_type: str | None = None,
+        upload_id: str | None = None,
+        chunked: bool | None = None,
+        chunk_index: int | None = None,
+        chunk_count: int | None = None,
+        encoding: str | None = None,
+        body_encoding: str | None = None,
+    ) -> Upload:
+        """Upload a binary (whole, or one chunk of ``upload_id``)."""
+        r = self._send(
+            "POST", "/api/upload", content=data, content_type="application/octet-stream",
+            params=_params(
+                fileName=file_name, mimeType=mime_type, id=upload_id, chunked=chunked, chunkIndex=chunk_index,
+                chunkCount=chunk_count, encoding=encoding, bodyEncoding=body_encoding,
+            ),
+        )
+        return self._parse(r, Upload)
+
+    def get_upload(self, upload_id: str) -> Upload | None:
+        r = self._send("GET", f"/api/upload/{_seg(upload_id)}")
+        return self._parse(r, Upload) if r.content else None
+
+    def complete_upload(self, upload_id: str, info: UploadFileInfo | Body) -> None:
+        self._send("POST", f"/api/upload/{_seg(upload_id)}/complete", json=_body(info))
+
+    def renew_upload_credentials(self, upload_id: str) -> Any:
+        return self._json(self._send("POST", f"/api/upload/{_seg(upload_id)}/renewCredentials"))
+
+    def delete_upload(self, upload_id: str) -> None:
+        self._send("DELETE", f"/api/upload/{_seg(upload_id)}")

python_openarch_api/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"