unsiloed-apimatic-sdk 0.0.2__tar.gz

unsiloed_apimatic_sdk-0.0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 APIMatic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

unsiloed_apimatic_sdk-0.0.2/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: unsiloed-apimatic-sdk
+Version: 0.0.2
+Summary: Sample SDKs for Unsiloed by APIMatic
+License-Expression: MIT
+License-File: LICENSE
+Keywords: sdk,api-client,openapi,rest,http,apimatic
+Author: Muhammad Rafay
+Author-email: muhammad.rafay@apimatic.io
+Maintainer: APIMatic
+Maintainer-email: support@apimatic.io
+Requires-Python: >=3.10
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: httpx (>=0.28.1,<1.0.0)
+Requires-Dist: pydantic[email] (>=2.11.0,<3.0.0)
+Requires-Dist: typing-extensions (>=4.13.0,<5.0.0)
+Project-URL: Documentation, https://www.unsiloed.ai/docs
+Description-Content-Type: text/markdown
+
+# Unsiloed AI Document Processing API SDK
+
+[![Built with APIMatic][apimatic-badge]][apimatic-url] [![License: MIT][license-badge]][license-url] [![Python 3.10+][python-badge]][python-url]
+
+The Unsiloed AI Document Processing API SDK for Python provides access to the Unsiloed AI Document Processing API REST APIs from Python applications.
+
+> [!TIP]
+> **Looking for a specific signature, model, enum, or error type?** This SDK ships a generated
+> **[SDK map](sdk-map.md)** -- a lookup index of the SDK's entire Python surface. Consult it before
+> scanning the source tree; details under [SDK map](#sdk-map).
+
+Document parsing, extraction, classification and splitting. Merged from the Unsiloed aggregate spec, the v1 Parser API and the v2 Parser API (presigned large-file upload), and aligned with the official docs at https://docs.unsiloed.ai/docs/. Poll large-file uploads with `GET /parse/{job_id}`.
+
+---
+
+## Installation
+
+Install the Python SDK from PyPI, with whichever package manager your project uses:
+
+```bash
+pip install unsiloed-apimatic-sdk
+```
+
+```bash
+uv add unsiloed-apimatic-sdk
+```
+
+```bash
+poetry add unsiloed-apimatic-sdk
+```
+
+---
+
+## Quick Start
+
+### Synchronous client
+
+Construct `UnsiloedAiDocumentProcessingApiClient` with keyword arguments, and call `close()` when you are done. Every argument is optional; the full list is in the [SDK map](sdk-map.md).
+
+```python
+from unsiloed_ai_document_processing_api import UnsiloedAiDocumentProcessingApiClient
+
+client = UnsiloedAiDocumentProcessingApiClient(api_key_auth="YOUR_API_KEY", environment="production")
+
+# TODO: call endpoints here -- see api-reference.md
+
+client.close()
+```
+
+Alternatively, scope it -- `with UnsiloedAiDocumentProcessingApiClient(...) as client:` closes the pool on exit; see [Best Practices](#best-practices).
+
+`Client` is exported as an alias of `UnsiloedAiDocumentProcessingApiClient`, so `from unsiloed_ai_document_processing_api import Client` also works.
+
+The SDK accepts every model-typed input in two interchangeable spellings, both type-checked: the typed model, or a plain dict with the same keys -- the `OrDict` and `Model | ModelDict` unions in the [SDK map](sdk-map.md). Pick whichever suits the call site: the dict form needs no import, while the model form adds a keyword-checked constructor and editor completion.
+
+### Asynchronous client
+
+`AsyncUnsiloedAiDocumentProcessingApiClient` mirrors `UnsiloedAiDocumentProcessingApiClient` with **identical method names**, and every endpoint method is a coroutine. It takes the same arguments, with some differences -- for example, the transport argument is `custom_async_http_client`.
+
+```python
+from asyncio import run
+
+from unsiloed_ai_document_processing_api import AsyncUnsiloedAiDocumentProcessingApiClient
+
+
+async def main() -> None:
+    client = AsyncUnsiloedAiDocumentProcessingApiClient(api_key_auth="YOUR_API_KEY", environment="production")
+    # TODO: call endpoints here, awaiting each -- see api-reference.md
+    await client.aclose()
+
+
+run(main())
+```
+
+Alternatively, scope it -- `async with AsyncUnsiloedAiDocumentProcessingApiClient(...) as client:` closes the pool on exit. Only the async spelling is `aclose`, matching httpx; see [Best Practices](#best-practices).
+
+`AsyncClient` is the exported alias. Each client accepts **only** its own transport argument; passing the other's is a `TypeError` at runtime and an error under mypy.
+
+---
+
+## Usage
+
+Two generated references cover the SDK; each answers a different question:
+
+| Reference | For |
+| --- | --- |
+| **[API Reference](api-reference.md)** | Usage guidance for a single **parsed** operation: `client.<group>.<operation>(...)` returns the typed payload and raises `ApiError` on any non-2xx, with `.error` the typed error body, or `RawError` for a status the operation does not document. |
+| **[Raw API Reference](raw-api-reference.md)** | The same for the **raw** variant: `client.<group>.with_raw_response.<operation>(...)` returns `ApiResult[T, E]` and never raises for an API error. |
+
+Both API references carry every one of the 12 operations, with a sync and an async sample and a parameter table each.
+
+## SDK map
+
+This SDK ships a generated **SDK map** -- [`sdk-map.md`](sdk-map.md) -- a deterministic, lookup-oriented table of contents of the SDK's Python surface, generated by APIMatic alongside this SDK.
+
+Consult the map before scanning or grepping the source: it answers call-level contract questions by lookup, and for anything it does not carry -- model shapes, enum values, an endpoint's route or behavioural prose -- it names the one source file to read. How to read the map itself, including the SDK-wide defaults its rows rely on, is stated at the top of [`sdk-map.md`](sdk-map.md).
+
+## Best Practices
+
+> [!TIP]
+> Use a **single `UnsiloedAiDocumentProcessingApiClient` instance** for the lifetime of your application and reuse it across
+> all requests. Each instance owns its own connection pool, so an instance per request forfeits
+> connection reuse and leaks pools that are never closed.
+
+Match the disposal to the client's lifetime: an application-lifetime client is closed once at shutdown with `close()` / `aclose()`; where the lifetime fits a block, `with UnsiloedAiDocumentProcessingApiClient() as client:` / `async with AsyncUnsiloedAiDocumentProcessingApiClient() as client:` releases it automatically. Both are idempotent, but a closed client is not reusable: the next call raises. The client closes **whatever transport it holds**, including one you supplied via `custom_http_client` / `custom_async_http_client`; if you intend to reuse your own transport across clients, don't hand its lifetime to a `with` block.
+
+## License
+
+This SDK is distributed under the [MIT License][license-url].
+
+---
+
+## Support
+
+Refer to the [API reference](api-reference.md) for detailed information on available operations with code samples.
+
+For further assistance, please contact support at hello@unsiloed.com.
+
+---
+
+[license-url]: LICENSE
+[license-badge]: https://img.shields.io/badge/License-MIT-blue.svg
+[apimatic-url]: https://www.apimatic.io
+[apimatic-badge]: https://www.apimatic.io/hubfs/Built-with-APIMatic-badge.svg
+[python-url]: https://www.python.org/downloads/
+[python-badge]: https://img.shields.io/badge/python-3.10%2B-blue.svg
+

unsiloed_apimatic_sdk-0.0.2/README.md

@@ -0,0 +1,126 @@
+# Unsiloed AI Document Processing API SDK
+
+[![Built with APIMatic][apimatic-badge]][apimatic-url] [![License: MIT][license-badge]][license-url] [![Python 3.10+][python-badge]][python-url]
+
+The Unsiloed AI Document Processing API SDK for Python provides access to the Unsiloed AI Document Processing API REST APIs from Python applications.
+
+> [!TIP]
+> **Looking for a specific signature, model, enum, or error type?** This SDK ships a generated
+> **[SDK map](sdk-map.md)** -- a lookup index of the SDK's entire Python surface. Consult it before
+> scanning the source tree; details under [SDK map](#sdk-map).
+
+Document parsing, extraction, classification and splitting. Merged from the Unsiloed aggregate spec, the v1 Parser API and the v2 Parser API (presigned large-file upload), and aligned with the official docs at https://docs.unsiloed.ai/docs/. Poll large-file uploads with `GET /parse/{job_id}`.
+
+---
+
+## Installation
+
+Install the Python SDK from PyPI, with whichever package manager your project uses:
+
+```bash
+pip install unsiloed-apimatic-sdk
+```
+
+```bash
+uv add unsiloed-apimatic-sdk
+```
+
+```bash
+poetry add unsiloed-apimatic-sdk
+```
+
+---
+
+## Quick Start
+
+### Synchronous client
+
+Construct `UnsiloedAiDocumentProcessingApiClient` with keyword arguments, and call `close()` when you are done. Every argument is optional; the full list is in the [SDK map](sdk-map.md).
+
+```python
+from unsiloed_ai_document_processing_api import UnsiloedAiDocumentProcessingApiClient
+
+client = UnsiloedAiDocumentProcessingApiClient(api_key_auth="YOUR_API_KEY", environment="production")
+
+# TODO: call endpoints here -- see api-reference.md
+
+client.close()
+```
+
+Alternatively, scope it -- `with UnsiloedAiDocumentProcessingApiClient(...) as client:` closes the pool on exit; see [Best Practices](#best-practices).
+
+`Client` is exported as an alias of `UnsiloedAiDocumentProcessingApiClient`, so `from unsiloed_ai_document_processing_api import Client` also works.
+
+The SDK accepts every model-typed input in two interchangeable spellings, both type-checked: the typed model, or a plain dict with the same keys -- the `OrDict` and `Model | ModelDict` unions in the [SDK map](sdk-map.md). Pick whichever suits the call site: the dict form needs no import, while the model form adds a keyword-checked constructor and editor completion.
+
+### Asynchronous client
+
+`AsyncUnsiloedAiDocumentProcessingApiClient` mirrors `UnsiloedAiDocumentProcessingApiClient` with **identical method names**, and every endpoint method is a coroutine. It takes the same arguments, with some differences -- for example, the transport argument is `custom_async_http_client`.
+
+```python
+from asyncio import run
+
+from unsiloed_ai_document_processing_api import AsyncUnsiloedAiDocumentProcessingApiClient
+
+
+async def main() -> None:
+    client = AsyncUnsiloedAiDocumentProcessingApiClient(api_key_auth="YOUR_API_KEY", environment="production")
+    # TODO: call endpoints here, awaiting each -- see api-reference.md
+    await client.aclose()
+
+
+run(main())
+```
+
+Alternatively, scope it -- `async with AsyncUnsiloedAiDocumentProcessingApiClient(...) as client:` closes the pool on exit. Only the async spelling is `aclose`, matching httpx; see [Best Practices](#best-practices).
+
+`AsyncClient` is the exported alias. Each client accepts **only** its own transport argument; passing the other's is a `TypeError` at runtime and an error under mypy.
+
+---
+
+## Usage
+
+Two generated references cover the SDK; each answers a different question:
+
+| Reference | For |
+| --- | --- |
+| **[API Reference](api-reference.md)** | Usage guidance for a single **parsed** operation: `client.<group>.<operation>(...)` returns the typed payload and raises `ApiError` on any non-2xx, with `.error` the typed error body, or `RawError` for a status the operation does not document. |
+| **[Raw API Reference](raw-api-reference.md)** | The same for the **raw** variant: `client.<group>.with_raw_response.<operation>(...)` returns `ApiResult[T, E]` and never raises for an API error. |
+
+Both API references carry every one of the 12 operations, with a sync and an async sample and a parameter table each.
+
+## SDK map
+
+This SDK ships a generated **SDK map** -- [`sdk-map.md`](sdk-map.md) -- a deterministic, lookup-oriented table of contents of the SDK's Python surface, generated by APIMatic alongside this SDK.
+
+Consult the map before scanning or grepping the source: it answers call-level contract questions by lookup, and for anything it does not carry -- model shapes, enum values, an endpoint's route or behavioural prose -- it names the one source file to read. How to read the map itself, including the SDK-wide defaults its rows rely on, is stated at the top of [`sdk-map.md`](sdk-map.md).
+
+## Best Practices
+
+> [!TIP]
+> Use a **single `UnsiloedAiDocumentProcessingApiClient` instance** for the lifetime of your application and reuse it across
+> all requests. Each instance owns its own connection pool, so an instance per request forfeits
+> connection reuse and leaks pools that are never closed.
+
+Match the disposal to the client's lifetime: an application-lifetime client is closed once at shutdown with `close()` / `aclose()`; where the lifetime fits a block, `with UnsiloedAiDocumentProcessingApiClient() as client:` / `async with AsyncUnsiloedAiDocumentProcessingApiClient() as client:` releases it automatically. Both are idempotent, but a closed client is not reusable: the next call raises. The client closes **whatever transport it holds**, including one you supplied via `custom_http_client` / `custom_async_http_client`; if you intend to reuse your own transport across clients, don't hand its lifetime to a `with` block.
+
+## License
+
+This SDK is distributed under the [MIT License][license-url].
+
+---
+
+## Support
+
+Refer to the [API reference](api-reference.md) for detailed information on available operations with code samples.
+
+For further assistance, please contact support at hello@unsiloed.com.
+
+---
+
+[license-url]: LICENSE
+[license-badge]: https://img.shields.io/badge/License-MIT-blue.svg
+[apimatic-url]: https://www.apimatic.io
+[apimatic-badge]: https://www.apimatic.io/hubfs/Built-with-APIMatic-badge.svg
+[python-url]: https://www.python.org/downloads/
+[python-badge]: https://img.shields.io/badge/python-3.10%2B-blue.svg

unsiloed_apimatic_sdk-0.0.2/pyproject.toml

@@ -0,0 +1,95 @@
+[project]
+name = "unsiloed-apimatic-sdk"
+version = "0.0.2"
+description = "Sample SDKs for Unsiloed by APIMatic"
+authors = [
+    { name = "Muhammad Rafay", email = "muhammad.rafay@apimatic.io" },
+]
+maintainers = [
+    { name = "APIMatic", email = "support@apimatic.io" },
+]
+keywords = ["sdk", "api-client", "openapi", "rest", "http", "apimatic"]
+license = "MIT"                 # SPDX expression (PEP 639); poetry-core bundles the root LICENSE
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "httpx (>=0.28.1,<1.0.0)",
+    # 2.11 added the alias-control `model_config` keys core/models.py names --
+    # validate_by_name, validate_by_alias and serialize_by_alias. No 2.12-only pydantic API
+    # is used anywhere.
+    "pydantic[email] (>=2.11.0,<3.0.0)",
+    # NotRequired / TypedDict backport for the 3.10 floor (both live in `typing` from 3.11),
+    # used by the model input companions; and TypeForm (PEP 747, added in 4.13.0), which
+    # core/ uses to type the runtime type expressions its factories accept. PEP 747 is Final
+    # and TypeForm reaches `typing` in 3.15, so both move when the floor does.
+    "typing-extensions (>=4.13.0,<5.0.0)",
+]
+
+classifiers = [
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Typing :: Typed",
+    "Operating System :: OS Independent",
+    "Topic :: Internet :: WWW/HTTP",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+# Must stay below every bare [project] key -- a sub-table header captures whatever follows it.
+[project.urls]
+Documentation = "https://www.unsiloed.ai/docs"
+
+[dependency-groups]
+dev = [
+    # 2.2 is where PEP 747 TypeForm became default-on; below it, core/'s signatures need an
+    # --enable-incomplete-feature flag.
+    "mypy (>=2.2.0,<3.0.0)",
+    "ruff (>=0.14.14,<0.15.0)",
+]
+
+
+[build-system]
+# 2.2.0 is the first release that understands PEP 639 -- below it the backend emits the
+# deprecated `License:` field, re-adds the license classifier and drops `:: 3.14`.
+requires = ["poetry-core>=2.2.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+
+[tool.poetry]
+packages = [{ include = "unsiloed_ai_document_processing_api" }]
+
+
+[tool.ruff]
+# target-version is inferred from requires-python -- the floor is single-sourced there
+line-length = 120
+
+[tool.ruff.lint]
+select = ["E", "W", "F", "I", "UP", "B", "RUF"]
+# Deliberately excluded:
+#   TC  - would move pydantic-validated imports under TYPE_CHECKING, breaking the
+#         runtime annotation resolution that pydantic depends on
+#   Q   - the CI-gated formatter normalizes quotes everywhere it runs
+ignore = [
+    # Typographic punctuation flagged as confusable. Every docstring here is the spec
+    # author's own description, copied verbatim -- normalizing their apostrophes and
+    # dashes would silently alter the API's documentation.
+    "RUF001", "RUF002", "RUF003",
+]
+
+[tool.ruff.lint.per-file-ignores]
+"**/__init__.py" = ["RUF022"]   # curated, grouped __all__
+
+[tool.mypy]
+python_version = "3.10"         # the supported floor, not whichever interpreter is local
+files = ["unsiloed_ai_document_processing_api"]
+strict = true
+warn_unreachable = true
+enable_error_code = ["redundant-expr", "truthy-bool", "ignore-without-code", "possibly-undefined"]
+# already inside `strict` at mypy 2.3, pinned deliberately: `strict`'s flag set is versioned
+# and the dev floor spans >=2.2.0,<3.0.0
+warn_return_any = true
+pretty = true

unsiloed_apimatic_sdk-0.0.2/unsiloed_ai_document_processing_api/__init__.py

@@ -0,0 +1,14 @@
+from . import models
+from .async_client import AsyncClient, AsyncUnsiloedAiDocumentProcessingApiClient
+from .client import Client, UnsiloedAiDocumentProcessingApiClient
+from .server import Environment, ServerConfig
+
+__all__ = [
+    "models",
+    "AsyncClient",
+    "AsyncUnsiloedAiDocumentProcessingApiClient",
+    "Client",
+    "Environment",
+    "ServerConfig",
+    "UnsiloedAiDocumentProcessingApiClient",
+]

unsiloed_apimatic_sdk-0.0.2/unsiloed_ai_document_processing_api/apis/__init__.py

@@ -0,0 +1,24 @@
+from .classify import AsyncClassify, Classify
+from .extract import AsyncExtract, Extract
+from .health import AsyncHealth, Health
+from .organization import AsyncOrganization, Organization
+from .parse_v2_presigned_upload import AsyncParseV2PresignedUpload, ParseV2PresignedUpload
+from .parse_vision_api_compatible import AsyncParseVisionApiCompatible, ParseVisionApiCompatible
+from .split import AsyncSplit, Split
+
+__all__ = [
+    "AsyncClassify",
+    "AsyncExtract",
+    "AsyncHealth",
+    "AsyncOrganization",
+    "AsyncParseV2PresignedUpload",
+    "AsyncParseVisionApiCompatible",
+    "AsyncSplit",
+    "Classify",
+    "Extract",
+    "Health",
+    "Organization",
+    "ParseV2PresignedUpload",
+    "ParseVisionApiCompatible",
+    "Split",
+]