autoassembler 0.3.1__py3-none-any.whl

autoassembler/_custom/planning_api.py

@@ -0,0 +1,225 @@
+"""``client.api.planning``: the generated planning client, with operations for its runs.
+
+Hand-written, protected via `.fernignore`. `PlanningApi` subclasses the generated
+`PlanningClient` (keeping every MPP call); `plan`, `validate`, `evaluate_dfa` and `adapt`
+replace the generated calls: they return an `Operation` to wait on rather than the 202 it
+starts from. The operations namespace is injected so they can build it. The curated
+`ProcessPlan` verbs are built on these.
+"""
+
+import typing
+
+from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ..core.request_options import RequestOptions
+from ..operation import AsyncOperation, Operation
+from ..planning.client import OMIT, AsyncPlanningClient, PlanningClient
+from ..planning.types.adapt_request_namespace import AdaptRequestNamespace
+from ..planning.types.evaluate_dfa_request_namespace import EvaluateDfaRequestNamespace
+from ..planning.types.plan_request_namespace import PlanRequestNamespace
+from ..planning.types.validate_request_namespace import ValidateRequestNamespace
+from ..types.diff_report import DiffReport
+from ..types.operation_response import (
+    OperationResponse_MppAdapt,
+    OperationResponse_MppEvaluateDfa,
+    OperationResponse_MppPlan,
+    OperationResponse_MppValidate,
+)
+from .operations import AsyncOperations, Operations, async_response_of, response_of
+
+
+class PlanningApi(PlanningClient):
+    """Generated planning client + operations for the station runs."""
+
+    def __init__(self, *, client_wrapper: SyncClientWrapper, operations: Operations):
+        super().__init__(client_wrapper=client_wrapper)
+        self._operations = operations
+
+
+    def plan(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self,
+        namespace: PlanRequestNamespace,
+        id: str,
+        mpp_id: str,
+        *,
+        station_ids: typing.Sequence[str],
+        overwrite: bool | None = OMIT,
+        request_options: RequestOptions | None = None,
+    ) -> Operation[OperationResponse_MppPlan]:
+        """Plan the stations.
+
+        The operation's result is the plan's version once their plans are saved.
+        """
+        accepted = super().plan(
+            namespace,
+            id,
+            mpp_id,
+            station_ids=station_ids,
+            overwrite=overwrite,
+            request_options=request_options,
+        )
+        return self._operations.handle(accepted, resolve=response_of(OperationResponse_MppPlan))
+
+    def validate(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self,
+        namespace: ValidateRequestNamespace,
+        id: str,
+        mpp_id: str,
+        *,
+        station_ids: typing.Sequence[str],
+        fix_directions: bool | None = OMIT,
+        request_options: RequestOptions | None = None,
+    ) -> Operation[OperationResponse_MppValidate]:
+        """Validate the stations.
+
+        The operation's result is the plan's version once the verdicts are saved.
+        """
+        accepted = super().validate(
+            namespace,
+            id,
+            mpp_id,
+            station_ids=station_ids,
+            fix_directions=fix_directions,
+            request_options=request_options,
+        )
+        return self._operations.handle(accepted, resolve=response_of(OperationResponse_MppValidate))
+
+    def evaluate_dfa(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self,
+        namespace: EvaluateDfaRequestNamespace,
+        id: str,
+        mpp_id: str,
+        *,
+        station_ids: typing.Sequence[str] | None = OMIT,
+        request_options: RequestOptions | None = None,
+    ) -> Operation[OperationResponse_MppEvaluateDfa]:
+        """Score the stations.
+
+        The operation's result is the plan's version once the scores are saved.
+        """
+        accepted = super().evaluate_dfa(
+            namespace, id, mpp_id, station_ids=station_ids, request_options=request_options
+        )
+        return self._operations.handle(
+            accepted, resolve=response_of(OperationResponse_MppEvaluateDfa)
+        )
+
+    def adapt(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self,
+        namespace: AdaptRequestNamespace,
+        id: str,
+        *,
+        reference_mpp_id: str,
+        diff: DiffReport,
+        name: str | None = OMIT,
+        request_options: RequestOptions | None = None,
+    ) -> Operation[OperationResponse_MppAdapt]:
+        """Create a process plan for the assembly by adapting a reference assembly's plan.
+
+        ``diff`` compares the reference assembly with this one. The operation's result is
+        the new plan's id and version once it is saved; ``op.operation.mpp_id`` names it
+        from the start.
+        """
+        accepted = super().adapt(
+            namespace,
+            id,
+            reference_mpp_id=reference_mpp_id,
+            diff=diff,
+            name=name,
+            request_options=request_options,
+        )
+        return self._operations.handle(accepted, resolve=response_of(OperationResponse_MppAdapt))
+
+
+class AsyncPlanningApi(AsyncPlanningClient):
+    """Async generated planning client + operations for the station runs (see `PlanningApi`)."""
+
+    def __init__(self, *, client_wrapper: AsyncClientWrapper, operations: AsyncOperations):
+        super().__init__(client_wrapper=client_wrapper)
+        self._operations = operations
+
+
+    async def plan(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self,
+        namespace: PlanRequestNamespace,
+        id: str,
+        mpp_id: str,
+        *,
+        station_ids: typing.Sequence[str],
+        overwrite: bool | None = OMIT,
+        request_options: RequestOptions | None = None,
+    ) -> AsyncOperation[OperationResponse_MppPlan]:
+        """Plan the stations; see `PlanningApi.plan`."""
+        accepted = await super().plan(
+            namespace,
+            id,
+            mpp_id,
+            station_ids=station_ids,
+            overwrite=overwrite,
+            request_options=request_options,
+        )
+        return await self._operations.handle(
+            accepted, resolve=async_response_of(OperationResponse_MppPlan)
+        )
+
+    async def validate(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self,
+        namespace: ValidateRequestNamespace,
+        id: str,
+        mpp_id: str,
+        *,
+        station_ids: typing.Sequence[str],
+        fix_directions: bool | None = OMIT,
+        request_options: RequestOptions | None = None,
+    ) -> AsyncOperation[OperationResponse_MppValidate]:
+        """Validate the stations; see `PlanningApi.validate`."""
+        accepted = await super().validate(
+            namespace,
+            id,
+            mpp_id,
+            station_ids=station_ids,
+            fix_directions=fix_directions,
+            request_options=request_options,
+        )
+        return await self._operations.handle(
+            accepted, resolve=async_response_of(OperationResponse_MppValidate)
+        )
+
+    async def evaluate_dfa(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self,
+        namespace: EvaluateDfaRequestNamespace,
+        id: str,
+        mpp_id: str,
+        *,
+        station_ids: typing.Sequence[str] | None = OMIT,
+        request_options: RequestOptions | None = None,
+    ) -> AsyncOperation[OperationResponse_MppEvaluateDfa]:
+        """Score the stations; see `PlanningApi.evaluate_dfa`."""
+        accepted = await super().evaluate_dfa(
+            namespace, id, mpp_id, station_ids=station_ids, request_options=request_options
+        )
+        return await self._operations.handle(
+            accepted, resolve=async_response_of(OperationResponse_MppEvaluateDfa)
+        )
+
+    async def adapt(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self,
+        namespace: AdaptRequestNamespace,
+        id: str,
+        *,
+        reference_mpp_id: str,
+        diff: DiffReport,
+        name: str | None = OMIT,
+        request_options: RequestOptions | None = None,
+    ) -> AsyncOperation[OperationResponse_MppAdapt]:
+        """Adapt a reference assembly's plan; see `PlanningApi.adapt`."""
+        accepted = await super().adapt(
+            namespace,
+            id,
+            reference_mpp_id=reference_mpp_id,
+            diff=diff,
+            name=name,
+            request_options=request_options,
+        )
+        return await self._operations.handle(
+            accepted, resolve=async_response_of(OperationResponse_MppAdapt)
+        )

autoassembler/_default_clients.py

@@ -0,0 +1,32 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import httpx
+
+SDK_DEFAULT_TIMEOUT = 60
+
+try:
+    import httpx_aiohttp  # type: ignore[import-not-found]
+except ImportError:
+
+    class DefaultAioHttpClient(httpx.AsyncClient):  # type: ignore
+        def __init__(self, **kwargs: typing.Any) -> None:
+            raise RuntimeError(
+                "To use the aiohttp client, install the aiohttp extra: pip install autoassembler[aiohttp]"
+            )
+
+else:
+
+    class DefaultAioHttpClient(httpx_aiohttp.HttpxAiohttpClient):  # type: ignore
+        def __init__(self, **kwargs: typing.Any) -> None:
+            kwargs.setdefault("timeout", SDK_DEFAULT_TIMEOUT)
+            kwargs.setdefault("follow_redirects", True)
+            super().__init__(**kwargs)
+
+
+class DefaultAsyncHttpxClient(httpx.AsyncClient):
+    def __init__(self, **kwargs: typing.Any) -> None:
+        kwargs.setdefault("timeout", SDK_DEFAULT_TIMEOUT)
+        kwargs.setdefault("follow_redirects", True)
+        super().__init__(**kwargs)

autoassembler/_version.py

@@ -0,0 +1,8 @@
+"""Package and API versions — hand-written, protected via `.fernignore`."""
+
+from importlib.metadata import version
+
+__version__ = version("autoassembler")
+
+# The API major version this SDK is generated against (the vendored spec is the API's v4).
+API_VERSION = "v4"

autoassembler/alpha/__init__.py

@@ -0,0 +1,63 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# isort: skip_file
+
+import typing
+from importlib import import_module
+
+if typing.TYPE_CHECKING:
+    from . import jobs, planning
+    from .jobs import CancelJobJobsResponse, ListJobsJobsResponse, ListJobsJobsResponsePagination, RetryJobJobsResponse
+    from .planning import (
+        ApplyOpsPlanningRequestNamespace,
+        ApplyOpsPlanningRequestOpsItem,
+        ApplyOpsPlanningRequestOpsItemOp,
+        ApplyOpsPlanningResponse,
+    )
+_dynamic_imports: typing.Dict[str, str] = {
+    "ApplyOpsPlanningRequestNamespace": ".planning",
+    "ApplyOpsPlanningRequestOpsItem": ".planning",
+    "ApplyOpsPlanningRequestOpsItemOp": ".planning",
+    "ApplyOpsPlanningResponse": ".planning",
+    "CancelJobJobsResponse": ".jobs",
+    "ListJobsJobsResponse": ".jobs",
+    "ListJobsJobsResponsePagination": ".jobs",
+    "RetryJobJobsResponse": ".jobs",
+    "jobs": ".jobs",
+    "planning": ".planning",
+}
+
+
+def __getattr__(attr_name: str) -> typing.Any:
+    module_name = _dynamic_imports.get(attr_name)
+    if module_name is None:
+        raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}")
+    try:
+        module = import_module(module_name, __package__)
+        if module_name == f".{attr_name}":
+            return module
+        else:
+            return getattr(module, attr_name)
+    except ImportError as e:
+        raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e
+    except AttributeError as e:
+        raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e
+
+
+def __dir__():
+    lazy_attrs = list(_dynamic_imports.keys())
+    return sorted(lazy_attrs)
+
+
+__all__ = [
+    "ApplyOpsPlanningRequestNamespace",
+    "ApplyOpsPlanningRequestOpsItem",
+    "ApplyOpsPlanningRequestOpsItemOp",
+    "ApplyOpsPlanningResponse",
+    "CancelJobJobsResponse",
+    "ListJobsJobsResponse",
+    "ListJobsJobsResponsePagination",
+    "RetryJobJobsResponse",
+    "jobs",
+    "planning",
+]

autoassembler/alpha/client.py

@@ -0,0 +1,82 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from __future__ import annotations
+
+import typing
+
+from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from .raw_client import AsyncRawAlphaClient, RawAlphaClient
+
+if typing.TYPE_CHECKING:
+    from .jobs.client import AsyncJobsClient, JobsClient
+    from .planning.client import AsyncPlanningClient, PlanningClient
+
+
+class AlphaClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._raw_client = RawAlphaClient(client_wrapper=client_wrapper)
+        self._client_wrapper = client_wrapper
+        self._jobs: typing.Optional[JobsClient] = None
+        self._planning: typing.Optional[PlanningClient] = None
+
+    @property
+    def with_raw_response(self) -> RawAlphaClient:
+        """
+        Retrieves a raw implementation of this client that returns raw responses.
+
+        Returns
+        -------
+        RawAlphaClient
+        """
+        return self._raw_client
+
+    @property
+    def jobs(self):
+        if self._jobs is None:
+            from .jobs.client import JobsClient  # noqa: E402
+
+            self._jobs = JobsClient(client_wrapper=self._client_wrapper)
+        return self._jobs
+
+    @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
+
+
+class AsyncAlphaClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._raw_client = AsyncRawAlphaClient(client_wrapper=client_wrapper)
+        self._client_wrapper = client_wrapper
+        self._jobs: typing.Optional[AsyncJobsClient] = None
+        self._planning: typing.Optional[AsyncPlanningClient] = None
+
+    @property
+    def with_raw_response(self) -> AsyncRawAlphaClient:
+        """
+        Retrieves a raw implementation of this client that returns raw responses.
+
+        Returns
+        -------
+        AsyncRawAlphaClient
+        """
+        return self._raw_client
+
+    @property
+    def jobs(self):
+        if self._jobs is None:
+            from .jobs.client import AsyncJobsClient  # noqa: E402
+
+            self._jobs = AsyncJobsClient(client_wrapper=self._client_wrapper)
+        return self._jobs
+
+    @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

autoassembler/alpha/jobs/__init__.py

@@ -0,0 +1,39 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# isort: skip_file
+
+import typing
+from importlib import import_module
+
+if typing.TYPE_CHECKING:
+    from .types import CancelJobJobsResponse, ListJobsJobsResponse, ListJobsJobsResponsePagination, RetryJobJobsResponse
+_dynamic_imports: typing.Dict[str, str] = {
+    "CancelJobJobsResponse": ".types",
+    "ListJobsJobsResponse": ".types",
+    "ListJobsJobsResponsePagination": ".types",
+    "RetryJobJobsResponse": ".types",
+}
+
+
+def __getattr__(attr_name: str) -> typing.Any:
+    module_name = _dynamic_imports.get(attr_name)
+    if module_name is None:
+        raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}")
+    try:
+        module = import_module(module_name, __package__)
+        if module_name == f".{attr_name}":
+            return module
+        else:
+            return getattr(module, attr_name)
+    except ImportError as e:
+        raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e
+    except AttributeError as e:
+        raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e
+
+
+def __dir__():
+    lazy_attrs = list(_dynamic_imports.keys())
+    return sorted(lazy_attrs)
+
+
+__all__ = ["CancelJobJobsResponse", "ListJobsJobsResponse", "ListJobsJobsResponsePagination", "RetryJobJobsResponse"]