autoassembler 0.3.1__py3-none-any.whl

autoassembler/base_client.py

@@ -0,0 +1,328 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from __future__ import annotations
+
+import typing
+
+import httpx
+from .core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from .core.logging import LogConfig, Logger
+from .environment import AutoAssemblerEnvironment
+
+if typing.TYPE_CHECKING:
+    from .alpha.client import AlphaClient, AsyncAlphaClient
+    from .assemblies.client import AssembliesClient, AsyncAssembliesClient
+    from .auth.client import AsyncAuthClient, AuthClient
+    from .operations.client import AsyncOperationsClient, OperationsClient
+    from .planning.client import AsyncPlanningClient, PlanningClient
+    from .sessions.client import AsyncSessionsClient, SessionsClient
+
+
+class BaseAutoAssembler:
+    """
+    Use this class to access the different functions within the SDK. You can instantiate any number of clients with different configuration that will propagate to these functions.
+
+    Parameters
+    ----------
+    base_url : typing.Optional[str]
+        The base url to use for requests from the client.
+
+    environment : AutoAssemblerEnvironment
+        The environment to use for requests from the client. from .environment import AutoAssemblerEnvironment
+
+
+
+        Defaults to AutoAssemblerEnvironment.PRODUCTION
+
+
+
+    token : typing.Optional[typing.Union[str, typing.Callable[[], str]]]
+    headers : typing.Optional[typing.Dict[str, str]]
+        Additional headers to send with every request.
+
+    timeout : typing.Optional[float]
+        The timeout to be used, in seconds, for requests. By default the timeout is 60 seconds, unless a custom httpx client is used, in which case this default is not enforced.
+
+    max_retries : typing.Optional[int]
+        The default maximum number of retries for failed requests. Defaults to 2. Per-request `max_retries` in `request_options` takes precedence over this value.
+
+    stream_reconnection_enabled : typing.Optional[bool]
+        Whether to automatically reconnect on stream disconnection for resumable streaming endpoints. Defaults to True. Per-request `stream_reconnection_enabled` in `request_options` takes precedence over this value.
+
+    max_stream_reconnection_attempts : typing.Optional[int]
+        The maximum number of reconnection attempts for resumable streaming endpoints. Defaults to no limit. Per-request `max_stream_reconnection_attempts` in `request_options` takes precedence over this value.
+
+    follow_redirects : typing.Optional[bool]
+        Whether the default httpx client follows redirects or not, this is irrelevant if a custom httpx client is passed in.
+
+    httpx_client : typing.Optional[httpx.Client]
+        The httpx client to use for making requests, a preconfigured client is used by default, however this is useful should you want to pass in any custom httpx configuration.
+
+    logging : typing.Optional[typing.Union[LogConfig, Logger]]
+        Configure logging for the SDK. Accepts a LogConfig dict with 'level' (debug/info/warn/error), 'logger' (custom logger implementation), and 'silent' (boolean, defaults to True) fields. You can also pass a pre-configured Logger instance.
+
+    Examples
+    --------
+    from autoassembler import AutoAssembler
+
+    client = AutoAssembler(
+        token="YOUR_TOKEN",
+    )
+    """
+
+    def __init__(
+        self,
+        *,
+        base_url: typing.Optional[str] = None,
+        environment: AutoAssemblerEnvironment = AutoAssemblerEnvironment.PRODUCTION,
+        token: typing.Optional[typing.Union[str, typing.Callable[[], str]]] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        timeout: typing.Optional[float] = None,
+        max_retries: typing.Optional[int] = None,
+        stream_reconnection_enabled: typing.Optional[bool] = None,
+        max_stream_reconnection_attempts: typing.Optional[int] = None,
+        follow_redirects: typing.Optional[bool] = True,
+        httpx_client: typing.Optional[httpx.Client] = None,
+        logging: typing.Optional[typing.Union[LogConfig, Logger]] = None,
+    ):
+        _defaulted_timeout = timeout if timeout is not None else 60 if httpx_client is None else None
+        _defaulted_max_retries = max_retries if max_retries is not None else 2
+        self._client_wrapper = SyncClientWrapper(
+            base_url=_get_base_url(base_url=base_url, environment=environment),
+            token=token,
+            headers=headers,
+            httpx_client=httpx_client
+            if httpx_client is not None
+            else httpx.Client(timeout=_defaulted_timeout, follow_redirects=follow_redirects)
+            if follow_redirects is not None
+            else httpx.Client(timeout=_defaulted_timeout),
+            timeout=_defaulted_timeout,
+            max_retries=_defaulted_max_retries,
+            stream_reconnection_enabled=stream_reconnection_enabled,
+            max_stream_reconnection_attempts=max_stream_reconnection_attempts,
+            logging=logging,
+        )
+        self._auth: typing.Optional[AuthClient] = None
+        self._sessions: typing.Optional[SessionsClient] = None
+        self._assemblies: typing.Optional[AssembliesClient] = None
+        self._operations: typing.Optional[OperationsClient] = None
+        self._planning: typing.Optional[PlanningClient] = None
+        self._alpha: typing.Optional[AlphaClient] = None
+
+    @property
+    def auth(self):
+        if self._auth is None:
+            from .auth.client import AuthClient  # noqa: E402
+
+            self._auth = AuthClient(client_wrapper=self._client_wrapper)
+        return self._auth
+
+    @property
+    def sessions(self):
+        if self._sessions is None:
+            from .sessions.client import SessionsClient  # noqa: E402
+
+            self._sessions = SessionsClient(client_wrapper=self._client_wrapper)
+        return self._sessions
+
+    @property
+    def assemblies(self):
+        if self._assemblies is None:
+            from .assemblies.client import AssembliesClient  # noqa: E402
+
+            self._assemblies = AssembliesClient(client_wrapper=self._client_wrapper)
+        return self._assemblies
+
+    @property
+    def operations(self):
+        if self._operations is None:
+            from .operations.client import OperationsClient  # noqa: E402
+
+            self._operations = OperationsClient(client_wrapper=self._client_wrapper)
+        return self._operations
+
+    @property
+    def planning(self):
+        if self._planning is None:
+            from .planning.client import PlanningClient  # noqa: E402
+
+            self._planning = PlanningClient(client_wrapper=self._client_wrapper)
+        return self._planning
+
+    @property
+    def alpha(self):
+        if self._alpha is None:
+            from .alpha.client import AlphaClient  # noqa: E402
+
+            self._alpha = AlphaClient(client_wrapper=self._client_wrapper)
+        return self._alpha
+
+
+def _make_default_async_client(
+    timeout: typing.Optional[float],
+    follow_redirects: typing.Optional[bool],
+) -> httpx.AsyncClient:
+    try:
+        import httpx_aiohttp  # type: ignore[import-not-found]
+    except ImportError:
+        pass
+    else:
+        if follow_redirects is not None:
+            return httpx_aiohttp.HttpxAiohttpClient(timeout=timeout, follow_redirects=follow_redirects)
+        return httpx_aiohttp.HttpxAiohttpClient(timeout=timeout)
+
+    if follow_redirects is not None:
+        return httpx.AsyncClient(timeout=timeout, follow_redirects=follow_redirects)
+    return httpx.AsyncClient(timeout=timeout)
+
+
+class AsyncBaseAutoAssembler:
+    """
+    Use this class to access the different functions within the SDK. You can instantiate any number of clients with different configuration that will propagate to these functions.
+
+    Parameters
+    ----------
+    base_url : typing.Optional[str]
+        The base url to use for requests from the client.
+
+    environment : AutoAssemblerEnvironment
+        The environment to use for requests from the client. from .environment import AutoAssemblerEnvironment
+
+
+
+        Defaults to AutoAssemblerEnvironment.PRODUCTION
+
+
+
+    token : typing.Optional[typing.Union[str, typing.Callable[[], str]]]
+    headers : typing.Optional[typing.Dict[str, str]]
+        Additional headers to send with every request.
+
+    async_token : typing.Optional[typing.Callable[[], typing.Awaitable[str]]]
+        An async callable that returns a bearer token. Use this when token acquisition involves async I/O (e.g., refreshing tokens via an async HTTP client). When provided, this is used instead of the synchronous token for async requests.
+
+    timeout : typing.Optional[float]
+        The timeout to be used, in seconds, for requests. By default the timeout is 60 seconds, unless a custom httpx client is used, in which case this default is not enforced.
+
+    max_retries : typing.Optional[int]
+        The default maximum number of retries for failed requests. Defaults to 2. Per-request `max_retries` in `request_options` takes precedence over this value.
+
+    stream_reconnection_enabled : typing.Optional[bool]
+        Whether to automatically reconnect on stream disconnection for resumable streaming endpoints. Defaults to True. Per-request `stream_reconnection_enabled` in `request_options` takes precedence over this value.
+
+    max_stream_reconnection_attempts : typing.Optional[int]
+        The maximum number of reconnection attempts for resumable streaming endpoints. Defaults to no limit. Per-request `max_stream_reconnection_attempts` in `request_options` takes precedence over this value.
+
+    follow_redirects : typing.Optional[bool]
+        Whether the default httpx client follows redirects or not, this is irrelevant if a custom httpx client is passed in.
+
+    httpx_client : typing.Optional[httpx.AsyncClient]
+        The httpx client to use for making requests, a preconfigured client is used by default, however this is useful should you want to pass in any custom httpx configuration.
+
+    logging : typing.Optional[typing.Union[LogConfig, Logger]]
+        Configure logging for the SDK. Accepts a LogConfig dict with 'level' (debug/info/warn/error), 'logger' (custom logger implementation), and 'silent' (boolean, defaults to True) fields. You can also pass a pre-configured Logger instance.
+
+    Examples
+    --------
+    from autoassembler import AsyncAutoAssembler
+
+    client = AsyncAutoAssembler(
+        token="YOUR_TOKEN",
+    )
+    """
+
+    def __init__(
+        self,
+        *,
+        base_url: typing.Optional[str] = None,
+        environment: AutoAssemblerEnvironment = AutoAssemblerEnvironment.PRODUCTION,
+        token: typing.Optional[typing.Union[str, typing.Callable[[], str]]] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        async_token: typing.Optional[typing.Callable[[], typing.Awaitable[str]]] = None,
+        timeout: typing.Optional[float] = None,
+        max_retries: typing.Optional[int] = None,
+        stream_reconnection_enabled: typing.Optional[bool] = None,
+        max_stream_reconnection_attempts: typing.Optional[int] = None,
+        follow_redirects: typing.Optional[bool] = True,
+        httpx_client: typing.Optional[httpx.AsyncClient] = None,
+        logging: typing.Optional[typing.Union[LogConfig, Logger]] = None,
+    ):
+        _defaulted_timeout = timeout if timeout is not None else 60 if httpx_client is None else None
+        _defaulted_max_retries = max_retries if max_retries is not None else 2
+        self._client_wrapper = AsyncClientWrapper(
+            base_url=_get_base_url(base_url=base_url, environment=environment),
+            token=token,
+            headers=headers,
+            async_token=async_token,
+            httpx_client=httpx_client
+            if httpx_client is not None
+            else _make_default_async_client(timeout=_defaulted_timeout, follow_redirects=follow_redirects),
+            timeout=_defaulted_timeout,
+            max_retries=_defaulted_max_retries,
+            stream_reconnection_enabled=stream_reconnection_enabled,
+            max_stream_reconnection_attempts=max_stream_reconnection_attempts,
+            logging=logging,
+        )
+        self._auth: typing.Optional[AsyncAuthClient] = None
+        self._sessions: typing.Optional[AsyncSessionsClient] = None
+        self._assemblies: typing.Optional[AsyncAssembliesClient] = None
+        self._operations: typing.Optional[AsyncOperationsClient] = None
+        self._planning: typing.Optional[AsyncPlanningClient] = None
+        self._alpha: typing.Optional[AsyncAlphaClient] = None
+
+    @property
+    def auth(self):
+        if self._auth is None:
+            from .auth.client import AsyncAuthClient  # noqa: E402
+
+            self._auth = AsyncAuthClient(client_wrapper=self._client_wrapper)
+        return self._auth
+
+    @property
+    def sessions(self):
+        if self._sessions is None:
+            from .sessions.client import AsyncSessionsClient  # noqa: E402
+
+            self._sessions = AsyncSessionsClient(client_wrapper=self._client_wrapper)
+        return self._sessions
+
+    @property
+    def assemblies(self):
+        if self._assemblies is None:
+            from .assemblies.client import AsyncAssembliesClient  # noqa: E402
+
+            self._assemblies = AsyncAssembliesClient(client_wrapper=self._client_wrapper)
+        return self._assemblies
+
+    @property
+    def operations(self):
+        if self._operations is None:
+            from .operations.client import AsyncOperationsClient  # noqa: E402
+
+            self._operations = AsyncOperationsClient(client_wrapper=self._client_wrapper)
+        return self._operations
+
+    @property
+    def planning(self):
+        if self._planning is None:
+            from .planning.client import AsyncPlanningClient  # noqa: E402
+
+            self._planning = AsyncPlanningClient(client_wrapper=self._client_wrapper)
+        return self._planning
+
+    @property
+    def alpha(self):
+        if self._alpha is None:
+            from .alpha.client import AsyncAlphaClient  # noqa: E402
+
+            self._alpha = AsyncAlphaClient(client_wrapper=self._client_wrapper)
+        return self._alpha
+
+
+def _get_base_url(*, base_url: typing.Optional[str] = None, environment: AutoAssemblerEnvironment) -> str:
+    if base_url is not None:
+        return base_url
+    elif environment is not None:
+        return environment.value
+    else:
+        raise Exception("Please pass in either base_url or environment to construct the client")

autoassembler/client.py

@@ -0,0 +1,262 @@
+"""Public client — hand-written, protected via `.fernignore`.
+
+Two layers, one attribute apart:
+
+* **The curated surface.** ``client.assemblies`` and ``client.planning`` are
+  hand-written namespaces that speak the domain's vocabulary (`Assembly`,
+  `ProcessPlan`, `Station`; ``upload``, ``diff``, ``plan``, ``validate``,
+  ``evaluate_dfa``) and return `Operation` handles for anything long-running.
+  ``client.operations`` wraps any operation, or the name of one, in an `Operation`.
+* **The generated client**, every namespace and every operation of the API as Fern
+  generated it, at ``client.api`` (``client.api.assemblies.get_status(...)``,
+  ``client.api.alpha.planning.apply_ops(...)``). The curated layer is built on it, and it
+  is the escape hatch when the vocabulary above does not cover what you need. Its
+  ``planning.plan`` / ``validate`` / ``evaluate_dfa`` / ``adapt`` and
+  ``assemblies.diff(async_=True)`` return an `Operation` too.
+
+Namespaces the curated layer has nothing to add to yet (``auth``, ``sessions``) are the
+generated ones, inherited from `BaseAutoAssembler`. So is ``alpha``: the operations the API
+offers before they are stable (``client.alpha.jobs``, ``client.alpha.planning.apply_ops``),
+which may change or go away in any release.
+
+`AsyncAutoAssembler` ships **sync-first**: it offers ``api`` and ``operations``; the
+curated ``assemblies`` / ``planning`` arrive in a later release with the same names,
+so code written against ``client.api`` keeps working.
+"""
+
+import typing
+from functools import cached_property
+
+from ._custom.assemblies import Assemblies
+from ._custom.assemblies_api import AssembliesApi, AsyncAssembliesApi
+from ._custom.credentials import resolve_token
+from ._custom.operations import AsyncOperations, Operations
+from ._custom.planning import Planning
+from ._custom.planning_api import AsyncPlanningApi, PlanningApi
+from ._version import __version__
+from .base_client import AsyncBaseAutoAssembler, BaseAutoAssembler, _get_base_url
+from .environment import AutoAssemblerEnvironment
+
+if typing.TYPE_CHECKING:
+    from .alpha.client import AlphaClient, AsyncAlphaClient
+    from .auth.client import AsyncAuthClient, AuthClient
+    from .core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+    from .sessions.client import AsyncSessionsClient, SessionsClient
+
+USER_AGENT = f"autoassembler-python/{__version__}"
+
+
+def _with_user_agent(headers: dict[str, str] | None) -> dict[str, str]:
+    # A caller-supplied User-Agent wins.
+    return {"User-Agent": USER_AGENT, **(headers or {})}
+
+
+class Api:
+    """The generated client: every namespace, every operation, exactly as the spec says.
+
+    Reached as ``client.api``. Each namespace is the Fern-generated sub-client
+    (``reference.md`` documents them all).
+    """
+
+    def __init__(self, client_wrapper: "SyncClientWrapper"):
+        self._client_wrapper = client_wrapper
+
+    @cached_property
+    def alpha(self) -> "AlphaClient":
+        from .alpha.client import AlphaClient
+
+        return AlphaClient(client_wrapper=self._client_wrapper)
+
+    @cached_property
+    def assemblies(self) -> AssembliesApi:
+        return AssembliesApi(client_wrapper=self._client_wrapper, operations=self.operations)
+
+    @cached_property
+    def auth(self) -> "AuthClient":
+        from .auth.client import AuthClient
+
+        return AuthClient(client_wrapper=self._client_wrapper)
+
+    @cached_property
+    def operations(self) -> Operations:
+        return Operations(client_wrapper=self._client_wrapper)
+
+    @cached_property
+    def planning(self) -> PlanningApi:
+        return PlanningApi(client_wrapper=self._client_wrapper, operations=self.operations)
+
+    @cached_property
+    def sessions(self) -> "SessionsClient":
+        from .sessions.client import SessionsClient
+
+        return SessionsClient(client_wrapper=self._client_wrapper)
+
+
+class AsyncApi:
+    """The generated async client, reached as ``client.api`` on `AsyncAutoAssembler`."""
+
+    def __init__(self, client_wrapper: "AsyncClientWrapper"):
+        self._client_wrapper = client_wrapper
+
+    @cached_property
+    def alpha(self) -> "AsyncAlphaClient":
+        from .alpha.client import AsyncAlphaClient
+
+        return AsyncAlphaClient(client_wrapper=self._client_wrapper)
+
+    @cached_property
+    def assemblies(self) -> AsyncAssembliesApi:
+        return AsyncAssembliesApi(client_wrapper=self._client_wrapper, operations=self.operations)
+
+    @cached_property
+    def auth(self) -> "AsyncAuthClient":
+        from .auth.client import AsyncAuthClient
+
+        return AsyncAuthClient(client_wrapper=self._client_wrapper)
+
+    @cached_property
+    def operations(self) -> AsyncOperations:
+        return AsyncOperations(client_wrapper=self._client_wrapper)
+
+    @cached_property
+    def planning(self) -> AsyncPlanningApi:
+        return AsyncPlanningApi(client_wrapper=self._client_wrapper, operations=self.operations)
+
+    @cached_property
+    def sessions(self) -> "AsyncSessionsClient":
+        from .sessions.client import AsyncSessionsClient
+
+        return AsyncSessionsClient(client_wrapper=self._client_wrapper)
+
+
+class AutoAssembler(BaseAutoAssembler):
+    """AutoAssembler API client: the curated surface, with the generated client at ``.api``."""
+
+    # Runtime-only, so type checkers and IDEs keep the generated constructor's signature.
+    # With no `token`, one is resolved: AA_TOKEN, then the store `autoassembler.login()` writes.
+    if not typing.TYPE_CHECKING:
+
+        def __init__(
+            self,
+            *args,
+            token=None,
+            base_url=None,
+            environment=AutoAssemblerEnvironment.PRODUCTION,
+            headers=None,
+            **kwargs,
+        ):
+            if token is None:
+                token = resolve_token(_get_base_url(base_url=base_url, environment=environment))
+            super().__init__(
+                *args,
+                token=token,
+                base_url=base_url,
+                environment=environment,
+                headers=_with_user_agent(headers),
+                **kwargs,
+            )
+
+    @property
+    def base_url(self) -> str:
+        """The API origin requests go to (no trailing slash)."""
+        return self._client_wrapper.get_base_url().rstrip("/")
+
+    @cached_property
+    def api(self) -> Api:
+        """The generated client: every operation of the API, one attribute away."""
+        return Api(self._client_wrapper)
+
+    @cached_property
+    def assemblies(self) -> Assemblies:  # pyright: ignore[reportIncompatibleMethodOverride]
+        """CAD files in, `Assembly` handles and diff reports out."""
+        return Assemblies(self)
+
+    @cached_property
+    def planning(self) -> Planning:  # pyright: ignore[reportIncompatibleMethodOverride]
+        """Process plans: create, author a station, plan, validate, score."""
+        return Planning(self)
+
+    @property
+    def operations(self) -> Operations:  # pyright: ignore[reportIncompatibleMethodOverride]
+        """Long-running operations: ``handle(operation_or_name)`` to wait on one."""
+        return self.api.operations
+
+    # Plain construction works and is what the examples use; `with` additionally closes
+    # the underlying connection pool when the block ends (as httpx's own clients do).
+    def close(self) -> None:
+        """Close the underlying HTTP connection pool."""
+        self._client_wrapper.httpx_client.httpx_client.close()
+
+    def __enter__(self) -> "AutoAssembler":
+        return self
+
+    def __exit__(self, *exc_info: object) -> None:
+        self.close()
+
+
+class AsyncAutoAssembler(AsyncBaseAutoAssembler):
+    """Async client: ``api`` and ``operations`` today; the curated namespaces come next."""
+
+    # Runtime-only, so type checkers and IDEs keep the generated constructor's signature.
+    # With no `token`, one is resolved: AA_TOKEN, then the store `autoassembler.login()` writes.
+    if not typing.TYPE_CHECKING:
+
+        def __init__(
+            self,
+            *args,
+            token=None,
+            base_url=None,
+            environment=AutoAssemblerEnvironment.PRODUCTION,
+            headers=None,
+            **kwargs,
+        ):
+            if token is None:
+                token = resolve_token(_get_base_url(base_url=base_url, environment=environment))
+            super().__init__(
+                *args,
+                token=token,
+                base_url=base_url,
+                environment=environment,
+                headers=_with_user_agent(headers),
+                **kwargs,
+            )
+
+    @property
+    def base_url(self) -> str:
+        """The API origin requests go to (no trailing slash)."""
+        return self._client_wrapper.get_base_url().rstrip("/")
+
+    @cached_property
+    def api(self) -> AsyncApi:
+        """The generated async client: every operation of the API, one attribute away."""
+        return AsyncApi(self._client_wrapper)
+
+    @property
+    def operations(self) -> AsyncOperations:  # pyright: ignore[reportIncompatibleMethodOverride]
+        """Long-running operations: ``await handle(operation_or_name)`` to wait on one."""
+        return self.api.operations
+
+    async def aclose(self) -> None:
+        """Close the underlying HTTP connection pool."""
+        await self._client_wrapper.httpx_client.httpx_client.aclose()
+
+    async def __aenter__(self) -> "AsyncAutoAssembler":
+        return self
+
+    async def __aexit__(self, *exc_info: object) -> None:
+        await self.aclose()
+
+    @property
+    def assemblies(self) -> typing.NoReturn:  # pyright: ignore[reportIncompatibleMethodOverride]
+        raise NotImplementedError(_NOT_YET.format(name="assemblies"))
+
+    @property
+    def planning(self) -> typing.NoReturn:  # pyright: ignore[reportIncompatibleMethodOverride]
+        raise NotImplementedError(_NOT_YET.format(name="planning"))
+
+
+_NOT_YET = (
+    "AsyncAutoAssembler.{name} is not available yet: the curated namespaces ship sync-first and "
+    "arrive on the async client in a later release with the same names. Until then use the "
+    "generated client, client.api.{name}."
+)