videogen-apimatic 1.0.0__tar.gz

videogen_apimatic-1.0.0/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.

videogen_apimatic-1.0.0/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.4
+Name: videogen-apimatic
+Version: 1.0.0
+Summary: 
+License-Expression: MIT
+License-File: LICENSE
+Keywords: sdk,api-client,openapi,rest,http,apimatic
+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)
+Description-Content-Type: text/markdown
+
+# Videogen SDK
+
+[![Built with APIMatic][apimatic-badge]][apimatic-url] [![License: MIT][license-badge]][license-url] [![Python 3.10+][python-badge]][python-url]
+
+The Videogen SDK for Python provides access to the Videogen 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).
+
+---
+
+## Installation
+
+Install the Python SDK from PyPI, with whichever package manager your project uses:
+
+```bash
+pip install videogen-apimatic
+```
+
+```bash
+uv add videogen-apimatic
+```
+
+```bash
+poetry add videogen-apimatic
+```
+
+---
+
+## Quick Start
+
+### Synchronous client
+
+Construct `VideogenClient` 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 videogen import VideogenClient
+
+client = VideogenClient(bearer_auth="YOUR_BEARER_TOKEN")
+
+# TODO: call endpoints here -- see api-reference.md
+
+client.close()
+```
+
+Alternatively, scope it -- `with VideogenClient(...) as client:` closes the pool on exit; see [Best Practices](#best-practices).
+
+`Client` is exported as an alias of `VideogenClient`, so `from videogen 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
+
+`AsyncVideogenClient` mirrors `VideogenClient` 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 videogen import AsyncVideogenClient
+
+
+async def main() -> None:
+    client = AsyncVideogenClient(bearer_auth="YOUR_BEARER_TOKEN")
+    # TODO: call endpoints here, awaiting each -- see api-reference.md
+    await client.aclose()
+
+
+run(main())
+```
+
+Alternatively, scope it -- `async with AsyncVideogenClient(...) 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 59 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 `VideogenClient` 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 VideogenClient() as client:` / `async with AsyncVideogenClient() 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.
+
+---
+
+[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
+

videogen_apimatic-1.0.0/README.md

@@ -0,0 +1,122 @@
+# Videogen SDK
+
+[![Built with APIMatic][apimatic-badge]][apimatic-url] [![License: MIT][license-badge]][license-url] [![Python 3.10+][python-badge]][python-url]
+
+The Videogen SDK for Python provides access to the Videogen 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).
+
+---
+
+## Installation
+
+Install the Python SDK from PyPI, with whichever package manager your project uses:
+
+```bash
+pip install videogen-apimatic
+```
+
+```bash
+uv add videogen-apimatic
+```
+
+```bash
+poetry add videogen-apimatic
+```
+
+---
+
+## Quick Start
+
+### Synchronous client
+
+Construct `VideogenClient` 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 videogen import VideogenClient
+
+client = VideogenClient(bearer_auth="YOUR_BEARER_TOKEN")
+
+# TODO: call endpoints here -- see api-reference.md
+
+client.close()
+```
+
+Alternatively, scope it -- `with VideogenClient(...) as client:` closes the pool on exit; see [Best Practices](#best-practices).
+
+`Client` is exported as an alias of `VideogenClient`, so `from videogen 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
+
+`AsyncVideogenClient` mirrors `VideogenClient` 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 videogen import AsyncVideogenClient
+
+
+async def main() -> None:
+    client = AsyncVideogenClient(bearer_auth="YOUR_BEARER_TOKEN")
+    # TODO: call endpoints here, awaiting each -- see api-reference.md
+    await client.aclose()
+
+
+run(main())
+```
+
+Alternatively, scope it -- `async with AsyncVideogenClient(...) 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 59 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 `VideogenClient` 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 VideogenClient() as client:` / `async with AsyncVideogenClient() 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.
+
+---
+
+[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

videogen_apimatic-1.0.0/pyproject.toml

@@ -0,0 +1,88 @@
+[project]
+name = "videogen-apimatic"
+version = "1.0.0"
+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",
+]
+
+[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]
+# The distribution is `videogen-apimatic` but the import package stays `videogen`,
+# so masonry cannot derive the package directory from the name -- state it.
+packages = [{ include = "videogen" }]
+
+
+[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 = ["videogen"]
+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

videogen_apimatic-1.0.0/videogen/__init__.py

@@ -0,0 +1,6 @@
+from . import models
+from .async_client import AsyncClient, AsyncVideogenClient
+from .client import Client, VideogenClient
+from .server import ServerConfig
+
+__all__ = ["models", "AsyncClient", "AsyncVideogenClient", "Client", "ServerConfig", "VideogenClient"]

videogen_apimatic-1.0.0/videogen/apis/__init__.py

@@ -0,0 +1,33 @@
+from .account import Account, AsyncAccount
+from .assistant import Assistant, AsyncAssistant
+from .entities import AsyncEntities, Entities
+from .files import AsyncFiles, Files
+from .projects import AsyncProjects, Projects
+from .resources import AsyncResources, Resources
+from .text import AsyncText, Text
+from .tools import AsyncTools, Tools
+from .webhooks import AsyncWebhooks, Webhooks
+from .workflows import AsyncWorkflows, Workflows
+
+__all__ = [
+    "Account",
+    "Assistant",
+    "AsyncAccount",
+    "AsyncAssistant",
+    "AsyncEntities",
+    "AsyncFiles",
+    "AsyncProjects",
+    "AsyncResources",
+    "AsyncText",
+    "AsyncTools",
+    "AsyncWebhooks",
+    "AsyncWorkflows",
+    "Entities",
+    "Files",
+    "Projects",
+    "Resources",
+    "Text",
+    "Tools",
+    "Webhooks",
+    "Workflows",
+]

videogen_apimatic-1.0.0/videogen/apis/account.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from ..auth import AsyncAuthSchemes, AuthSchemes
+from ..core import (
+    ApiResult,
+    AsyncRawClient,
+    RawClient,
+    RawError,
+    RequestOptionsOrDict,
+    SecuredRawResponse,
+    json_decoder,
+    raw_error_response,
+)
+from ..models.me_response import MeResponse
+from ..server.server import Server
+
+
+class Account:
+    def __init__(self, client: RawClient, server: Server, auth: AuthSchemes) -> None:
+        self._with_raw_response = AccountWithRawResponse(client, server, auth)
+
+    def get_me(self, *, request_options: RequestOptionsOrDict | None = None) -> MeResponse:
+        """Return the account and team behind the API key making the request. Takes no parameters. Call it as a
+        connection test to confirm a key is valid and to discover the ``teamId`` and account ``email`` a key belongs to.
+
+        Args:
+            request_options: Per-call overrides for this one request, such as a timeout or extra headers.
+
+        Returns:
+            The account and team for the authenticated API key.
+
+        Raises:
+            ApiError: If the API responds with an error status code. ``error`` is ``RawError``."""
+        return self._with_raw_response.get_me(request_options=request_options).unwrap()
+
+    @property
+    def with_raw_response(self) -> AccountWithRawResponse:
+        return self._with_raw_response
+
+
+class AsyncAccount:
+    def __init__(self, client: AsyncRawClient, server: Server, auth: AsyncAuthSchemes) -> None:
+        self._with_raw_response = AsyncAccountWithRawResponse(client, server, auth)
+
+    async def get_me(self, *, request_options: RequestOptionsOrDict | None = None) -> MeResponse:
+        """Return the account and team behind the API key making the request. Takes no parameters. Call it as a
+        connection test to confirm a key is valid and to discover the ``teamId`` and account ``email`` a key belongs to.
+
+        Args:
+            request_options: Per-call overrides for this one request, such as a timeout or extra headers.
+
+        Returns:
+            The account and team for the authenticated API key.
+
+        Raises:
+            ApiError: If the API responds with an error status code. ``error`` is ``RawError``."""
+        return (await self._with_raw_response.get_me(request_options=request_options)).unwrap()
+
+    @property
+    def with_raw_response(self) -> AsyncAccountWithRawResponse:
+        return self._with_raw_response
+
+
+class AccountWithRawResponse(SecuredRawResponse[RawClient, Server, AuthSchemes]):
+    def get_me(self, *, request_options: RequestOptionsOrDict | None = None) -> ApiResult[MeResponse, RawError]:
+        """Return the account and team behind the API key making the request. Takes no parameters. Call it as a
+        connection test to confirm a key is valid and to discover the ``teamId`` and account ``email`` a key belongs to.
+
+        Args:
+            request_options: Per-call overrides for this one request, such as a timeout or extra headers.
+
+        Returns:
+            An ``ApiResult`` holding the deserialized response or the error body."""
+        return self._client.execute(
+            http_method="GET",
+            url_template=self._server.default("/v1/me"),
+            auth_scheme=self._auth.bearer_auth,
+            decoder=json_decoder[MeResponse],
+            error_mapper=raw_error_response,
+            request_options=request_options,
+        )
+
+
+class AsyncAccountWithRawResponse(SecuredRawResponse[AsyncRawClient, Server, AsyncAuthSchemes]):
+    async def get_me(self, *, request_options: RequestOptionsOrDict | None = None) -> ApiResult[MeResponse, RawError]:
+        """Return the account and team behind the API key making the request. Takes no parameters. Call it as a
+        connection test to confirm a key is valid and to discover the ``teamId`` and account ``email`` a key belongs to.
+
+        Args:
+            request_options: Per-call overrides for this one request, such as a timeout or extra headers.
+
+        Returns:
+            An ``ApiResult`` holding the deserialized response or the error body."""
+        return await self._client.execute(
+            http_method="GET",
+            url_template=self._server.default("/v1/me"),
+            auth_scheme=self._auth.bearer_auth,
+            decoder=json_decoder[MeResponse],
+            error_mapper=raw_error_response,
+            request_options=request_options,
+        )