autoassembler 0.3.1__py3-none-any.whl

autoassembler/planning/raw_client.py

@@ -0,0 +1,1349 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from json.decoder import JSONDecodeError
+
+from ..core.api_error import ApiError
+from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ..core.http_response import AsyncHttpResponse, HttpResponse
+from ..core.jsonable_encoder import encode_path_param
+from ..core.parse_error import ParsingError
+from ..core.pydantic_utilities import parse_obj_as
+from ..core.request_options import RequestOptions
+from ..core.serialization import convert_and_respect_annotation_metadata
+from ..errors.bad_request_error import BadRequestError
+from ..errors.conflict_error import ConflictError
+from ..errors.forbidden_error import ForbiddenError
+from ..errors.not_found_error import NotFoundError
+from ..errors.unprocessable_entity_error import UnprocessableEntityError
+from ..types.adapt_mpp_accepted import AdaptMppAccepted
+from ..types.diff_report import DiffReport
+from ..types.error_response import ErrorResponse
+from ..types.manufacturing_process_plan import ManufacturingProcessPlan
+from ..types.mpp_summary import MppSummary
+from ..types.seq_plan_accepted import SeqPlanAccepted
+from .types.adapt_request_namespace import AdaptRequestNamespace
+from .types.create_mpp_request_body import CreateMppRequestBody
+from .types.create_mpp_request_namespace import CreateMppRequestNamespace
+from .types.delete_mpp_request_namespace import DeleteMppRequestNamespace
+from .types.delete_mpp_response import DeleteMppResponse
+from .types.evaluate_dfa_request_namespace import EvaluateDfaRequestNamespace
+from .types.get_mpp_request_namespace import GetMppRequestNamespace
+from .types.get_mpp_response import GetMppResponse
+from .types.list_mpps_request_namespace import ListMppsRequestNamespace
+from .types.plan_request_namespace import PlanRequestNamespace
+from .types.validate_request_namespace import ValidateRequestNamespace
+from pydantic import ValidationError
+
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
+
+
+class RawPlanningClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    def list_mpps(
+        self, namespace: ListMppsRequestNamespace, id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> HttpResponse[typing.List[MppSummary]]:
+        """
+        Parameters
+        ----------
+        namespace : ListMppsRequestNamespace
+            Assembly URL namespace. `user`, `shared`, and `public` are routed through the same assembly lookup.
+
+        id : str
+            Assembly ID.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[typing.List[MppSummary]]
+            Process plan summaries for the assembly.
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"api/v4/assemblies/{encode_path_param(namespace)}/{encode_path_param(id)}/mpps",
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    typing.List[MppSummary],
+                    parse_obj_as(
+                        type_=typing.List[MppSummary],  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        except ValidationError as e:
+            raise ParsingError(
+                status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e
+            )
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    def create_mpp(
+        self,
+        namespace: CreateMppRequestNamespace,
+        id: str,
+        *,
+        request: CreateMppRequestBody,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> HttpResponse[ManufacturingProcessPlan]:
+        """
+        Parameters
+        ----------
+        namespace : CreateMppRequestNamespace
+            Assembly URL namespace. `user`, `shared`, and `public` are routed through the same assembly lookup.
+
+        id : str
+            Assembly ID.
+
+        request : CreateMppRequestBody
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[ManufacturingProcessPlan]
+            Created process plan document.
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"api/v4/assemblies/{encode_path_param(namespace)}/{encode_path_param(id)}/mpps",
+            method="POST",
+            json=convert_and_respect_annotation_metadata(
+                object_=request, annotation=CreateMppRequestBody, direction="write"
+            ),
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    ManufacturingProcessPlan,
+                    parse_obj_as(
+                        type_=ManufacturingProcessPlan,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        except ValidationError as e:
+            raise ParsingError(
+                status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e
+            )
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    def adapt(
+        self,
+        namespace: AdaptRequestNamespace,
+        id: str,
+        *,
+        reference_mpp_id: str,
+        diff: DiffReport,
+        name: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> HttpResponse[AdaptMppAccepted]:
+        """
+        Creates a process plan for the target assembly by adapting a reference assembly's
+        process plan. Runs asynchronously and returns immediately with the
+        new `mppId` and `jobId`.
+
+        Parameters
+        ----------
+        namespace : AdaptRequestNamespace
+            Assembly URL namespace. `user`, `shared`, and `public` are routed through the same assembly lookup.
+
+        id : str
+            Assembly ID.
+
+        reference_mpp_id : str
+            Process plan for the reference assembly to adapt from.
+
+        diff : DiffReport
+
+        name : typing.Optional[str]
+            Optional name for the adapted process plan.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[AdaptMppAccepted]
+            Adaptation queued, with the operation tracking it.
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"api/v4/assemblies/{encode_path_param(namespace)}/{encode_path_param(id)}/mpps:adapt",
+            method="POST",
+            json={
+                "referenceMppId": reference_mpp_id,
+                "name": name,
+                "diff": convert_and_respect_annotation_metadata(object_=diff, annotation=DiffReport, direction="write"),
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    AdaptMppAccepted,
+                    parse_obj_as(
+                        type_=AdaptMppAccepted,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        parse_obj_as(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 403:
+                raise ForbiddenError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        except ValidationError as e:
+            raise ParsingError(
+                status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e
+            )
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    def get_mpp(
+        self,
+        namespace: GetMppRequestNamespace,
+        id: str,
+        mpp_id: str,
+        *,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> HttpResponse[GetMppResponse]:
+        """
+        Parameters
+        ----------
+        namespace : GetMppRequestNamespace
+            Assembly URL namespace. `user`, `shared`, and `public` are routed through the same assembly lookup.
+
+        id : str
+            Assembly ID.
+
+        mpp_id : str
+            Manufacturing Process Plan ID.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[GetMppResponse]
+            Process plan document wrapper.
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"api/v4/assemblies/{encode_path_param(namespace)}/{encode_path_param(id)}/mpps/{encode_path_param(mpp_id)}",
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    GetMppResponse,
+                    parse_obj_as(
+                        type_=GetMppResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        except ValidationError as e:
+            raise ParsingError(
+                status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e
+            )
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    def delete_mpp(
+        self,
+        namespace: DeleteMppRequestNamespace,
+        id: str,
+        mpp_id: str,
+        *,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> HttpResponse[DeleteMppResponse]:
+        """
+        Parameters
+        ----------
+        namespace : DeleteMppRequestNamespace
+            Assembly URL namespace. `user`, `shared`, and `public` are routed through the same assembly lookup.
+
+        id : str
+            Assembly ID.
+
+        mpp_id : str
+            Manufacturing Process Plan ID.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[DeleteMppResponse]
+            Delete status.
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"api/v4/assemblies/{encode_path_param(namespace)}/{encode_path_param(id)}/mpps/{encode_path_param(mpp_id)}",
+            method="DELETE",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    DeleteMppResponse,
+                    parse_obj_as(
+                        type_=DeleteMppResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        except ValidationError as e:
+            raise ParsingError(
+                status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e
+            )
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    def plan(
+        self,
+        namespace: PlanRequestNamespace,
+        id: str,
+        mpp_id: str,
+        *,
+        station_ids: typing.Sequence[str],
+        overwrite: typing.Optional[bool] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> HttpResponse[SeqPlanAccepted]:
+        """
+        Plans the Station graph from scratch, computing a suitable process plan (Step graph)
+        for each of the requested stations. The run overwrites any pre-existing plan; deciding which
+        stations have to be re-planned is the caller's responsibility.
+        Pass `overwrite: false` to have a station that already has a plan left alone instead.
+
+        **Async** — returns 202 immediately.
+
+        Parameters
+        ----------
+        namespace : PlanRequestNamespace
+            Assembly URL namespace. `user`, `shared`, and `public` are routed through the same assembly lookup.
+
+        id : str
+            Assembly ID.
+
+        mpp_id : str
+            Manufacturing Process Plan ID.
+
+        station_ids : typing.Sequence[str]
+            IDs of the Station nodes to plan. All must exist in the process plan's station graph and have a supported input/output boundary.
+
+        overwrite : typing.Optional[bool]
+            Whether the run may replace a plan a requested station already has. Checked per station, so one station never blocks another.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[SeqPlanAccepted]
+            Planning jobs accepted and running in the background.
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"api/v4/assemblies/{encode_path_param(namespace)}/{encode_path_param(id)}/mpps/{encode_path_param(mpp_id)}:seq-plan",
+            method="POST",
+            json={
+                "stationIds": station_ids,
+                "overwrite": overwrite,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    SeqPlanAccepted,
+                    parse_obj_as(
+                        type_=SeqPlanAccepted,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        parse_obj_as(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 409:
+                raise ConflictError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        parse_obj_as(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        except ValidationError as e:
+            raise ParsingError(
+                status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e
+            )
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    def validate(
+        self,
+        namespace: ValidateRequestNamespace,
+        id: str,
+        mpp_id: str,
+        *,
+        station_ids: typing.Sequence[str],
+        fix_directions: typing.Optional[bool] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> HttpResponse[SeqPlanAccepted]:
+        """
+        **Feasibility validation** — checks structural consistency of the entire process plan,
+        then validates geometrical feasibility of assembly steps for the requested
+        stations. When a blocked step has a workspace-free alternative direction,
+        `fixDirections` (off by default) writes it onto the step graph and the
+        persisted verdict reflects the repaired plan.
+
+        **Async** — returns 202 with `{ queued }`.
+
+        Parameters
+        ----------
+        namespace : ValidateRequestNamespace
+            Assembly URL namespace. `user`, `shared`, and `public` are routed through the same assembly lookup.
+
+        id : str
+            Assembly ID.
+
+        mpp_id : str
+            Manufacturing Process Plan ID.
+
+        station_ids : typing.Sequence[str]
+            IDs of the Station nodes to validate. All must exist in the process plan's station graph and stations without persisted assembly steps are accepted and reported as skipped.
+
+        fix_directions : typing.Optional[bool]
+            Apply each blocked step's workspace-free alternative direction onto the step graph, so the persisted verdict describes the repaired plan. Absent, the step graph is untouched.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[SeqPlanAccepted]
+            Validation jobs accepted and running in the background.
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"api/v4/assemblies/{encode_path_param(namespace)}/{encode_path_param(id)}/mpps/{encode_path_param(mpp_id)}:validate",
+            method="POST",
+            json={
+                "stationIds": station_ids,
+                "fixDirections": fix_directions,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    SeqPlanAccepted,
+                    parse_obj_as(
+                        type_=SeqPlanAccepted,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        parse_obj_as(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        except ValidationError as e:
+            raise ParsingError(
+                status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e
+            )
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    def evaluate_dfa(
+        self,
+        namespace: EvaluateDfaRequestNamespace,
+        id: str,
+        mpp_id: str,
+        *,
+        station_ids: typing.Optional[typing.Sequence[str]] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> HttpResponse[SeqPlanAccepted]:
+        """
+        Projects each sequential assembly addend directly from the persisted Step
+        graph into an explicit state-of-assembly transition, evaluates DFA, and
+        persists per-station reports under `plan.dfa`. Runs asynchronously.
+
+        Parameters
+        ----------
+        namespace : EvaluateDfaRequestNamespace
+            Assembly URL namespace. `user`, `shared`, and `public` are routed through the same assembly lookup.
+
+        id : str
+            Assembly ID.
+
+        mpp_id : str
+            Manufacturing Process Plan ID.
+
+        station_ids : typing.Optional[typing.Sequence[str]]
+            Stations to score. Omitted means every station with assembly steps, and then a station that is not ready is skipped rather than refused. A station named here must be planned and hold a feasible validation verdict, or the whole request is refused with 409. Named stations without assembly steps are accepted and reported as skipped.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[SeqPlanAccepted]
+            DFA evaluation accepted (or nothing to evaluate). `skipped` lists requested stations that were not queued — no assembly steps, or, for an unfiltered request, not yet validated.
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"api/v4/assemblies/{encode_path_param(namespace)}/{encode_path_param(id)}/mpps/{encode_path_param(mpp_id)}:dfa",
+            method="POST",
+            json={
+                "stationIds": station_ids,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    SeqPlanAccepted,
+                    parse_obj_as(
+                        type_=SeqPlanAccepted,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        parse_obj_as(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 409:
+                raise ConflictError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        parse_obj_as(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        except ValidationError as e:
+            raise ParsingError(
+                status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e
+            )
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+
+class AsyncRawPlanningClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    async def list_mpps(
+        self, namespace: ListMppsRequestNamespace, id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> AsyncHttpResponse[typing.List[MppSummary]]:
+        """
+        Parameters
+        ----------
+        namespace : ListMppsRequestNamespace
+            Assembly URL namespace. `user`, `shared`, and `public` are routed through the same assembly lookup.
+
+        id : str
+            Assembly ID.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[typing.List[MppSummary]]
+            Process plan summaries for the assembly.
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"api/v4/assemblies/{encode_path_param(namespace)}/{encode_path_param(id)}/mpps",
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    typing.List[MppSummary],
+                    parse_obj_as(
+                        type_=typing.List[MppSummary],  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        except ValidationError as e:
+            raise ParsingError(
+                status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e
+            )
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def create_mpp(
+        self,
+        namespace: CreateMppRequestNamespace,
+        id: str,
+        *,
+        request: CreateMppRequestBody,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[ManufacturingProcessPlan]:
+        """
+        Parameters
+        ----------
+        namespace : CreateMppRequestNamespace
+            Assembly URL namespace. `user`, `shared`, and `public` are routed through the same assembly lookup.
+
+        id : str
+            Assembly ID.
+
+        request : CreateMppRequestBody
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[ManufacturingProcessPlan]
+            Created process plan document.
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"api/v4/assemblies/{encode_path_param(namespace)}/{encode_path_param(id)}/mpps",
+            method="POST",
+            json=convert_and_respect_annotation_metadata(
+                object_=request, annotation=CreateMppRequestBody, direction="write"
+            ),
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    ManufacturingProcessPlan,
+                    parse_obj_as(
+                        type_=ManufacturingProcessPlan,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        except ValidationError as e:
+            raise ParsingError(
+                status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e
+            )
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def adapt(
+        self,
+        namespace: AdaptRequestNamespace,
+        id: str,
+        *,
+        reference_mpp_id: str,
+        diff: DiffReport,
+        name: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[AdaptMppAccepted]:
+        """
+        Creates a process plan for the target assembly by adapting a reference assembly's
+        process plan. Runs asynchronously and returns immediately with the
+        new `mppId` and `jobId`.
+
+        Parameters
+        ----------
+        namespace : AdaptRequestNamespace
+            Assembly URL namespace. `user`, `shared`, and `public` are routed through the same assembly lookup.
+
+        id : str
+            Assembly ID.
+
+        reference_mpp_id : str
+            Process plan for the reference assembly to adapt from.
+
+        diff : DiffReport
+
+        name : typing.Optional[str]
+            Optional name for the adapted process plan.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[AdaptMppAccepted]
+            Adaptation queued, with the operation tracking it.
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"api/v4/assemblies/{encode_path_param(namespace)}/{encode_path_param(id)}/mpps:adapt",
+            method="POST",
+            json={
+                "referenceMppId": reference_mpp_id,
+                "name": name,
+                "diff": convert_and_respect_annotation_metadata(object_=diff, annotation=DiffReport, direction="write"),
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    AdaptMppAccepted,
+                    parse_obj_as(
+                        type_=AdaptMppAccepted,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        parse_obj_as(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 403:
+                raise ForbiddenError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        except ValidationError as e:
+            raise ParsingError(
+                status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e
+            )
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def get_mpp(
+        self,
+        namespace: GetMppRequestNamespace,
+        id: str,
+        mpp_id: str,
+        *,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[GetMppResponse]:
+        """
+        Parameters
+        ----------
+        namespace : GetMppRequestNamespace
+            Assembly URL namespace. `user`, `shared`, and `public` are routed through the same assembly lookup.
+
+        id : str
+            Assembly ID.
+
+        mpp_id : str
+            Manufacturing Process Plan ID.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[GetMppResponse]
+            Process plan document wrapper.
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"api/v4/assemblies/{encode_path_param(namespace)}/{encode_path_param(id)}/mpps/{encode_path_param(mpp_id)}",
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    GetMppResponse,
+                    parse_obj_as(
+                        type_=GetMppResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        except ValidationError as e:
+            raise ParsingError(
+                status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e
+            )
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def delete_mpp(
+        self,
+        namespace: DeleteMppRequestNamespace,
+        id: str,
+        mpp_id: str,
+        *,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[DeleteMppResponse]:
+        """
+        Parameters
+        ----------
+        namespace : DeleteMppRequestNamespace
+            Assembly URL namespace. `user`, `shared`, and `public` are routed through the same assembly lookup.
+
+        id : str
+            Assembly ID.
+
+        mpp_id : str
+            Manufacturing Process Plan ID.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[DeleteMppResponse]
+            Delete status.
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"api/v4/assemblies/{encode_path_param(namespace)}/{encode_path_param(id)}/mpps/{encode_path_param(mpp_id)}",
+            method="DELETE",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    DeleteMppResponse,
+                    parse_obj_as(
+                        type_=DeleteMppResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        except ValidationError as e:
+            raise ParsingError(
+                status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e
+            )
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def plan(
+        self,
+        namespace: PlanRequestNamespace,
+        id: str,
+        mpp_id: str,
+        *,
+        station_ids: typing.Sequence[str],
+        overwrite: typing.Optional[bool] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[SeqPlanAccepted]:
+        """
+        Plans the Station graph from scratch, computing a suitable process plan (Step graph)
+        for each of the requested stations. The run overwrites any pre-existing plan; deciding which
+        stations have to be re-planned is the caller's responsibility.
+        Pass `overwrite: false` to have a station that already has a plan left alone instead.
+
+        **Async** — returns 202 immediately.
+
+        Parameters
+        ----------
+        namespace : PlanRequestNamespace
+            Assembly URL namespace. `user`, `shared`, and `public` are routed through the same assembly lookup.
+
+        id : str
+            Assembly ID.
+
+        mpp_id : str
+            Manufacturing Process Plan ID.
+
+        station_ids : typing.Sequence[str]
+            IDs of the Station nodes to plan. All must exist in the process plan's station graph and have a supported input/output boundary.
+
+        overwrite : typing.Optional[bool]
+            Whether the run may replace a plan a requested station already has. Checked per station, so one station never blocks another.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[SeqPlanAccepted]
+            Planning jobs accepted and running in the background.
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"api/v4/assemblies/{encode_path_param(namespace)}/{encode_path_param(id)}/mpps/{encode_path_param(mpp_id)}:seq-plan",
+            method="POST",
+            json={
+                "stationIds": station_ids,
+                "overwrite": overwrite,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    SeqPlanAccepted,
+                    parse_obj_as(
+                        type_=SeqPlanAccepted,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        parse_obj_as(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 409:
+                raise ConflictError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        parse_obj_as(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        except ValidationError as e:
+            raise ParsingError(
+                status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e
+            )
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def validate(
+        self,
+        namespace: ValidateRequestNamespace,
+        id: str,
+        mpp_id: str,
+        *,
+        station_ids: typing.Sequence[str],
+        fix_directions: typing.Optional[bool] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[SeqPlanAccepted]:
+        """
+        **Feasibility validation** — checks structural consistency of the entire process plan,
+        then validates geometrical feasibility of assembly steps for the requested
+        stations. When a blocked step has a workspace-free alternative direction,
+        `fixDirections` (off by default) writes it onto the step graph and the
+        persisted verdict reflects the repaired plan.
+
+        **Async** — returns 202 with `{ queued }`.
+
+        Parameters
+        ----------
+        namespace : ValidateRequestNamespace
+            Assembly URL namespace. `user`, `shared`, and `public` are routed through the same assembly lookup.
+
+        id : str
+            Assembly ID.
+
+        mpp_id : str
+            Manufacturing Process Plan ID.
+
+        station_ids : typing.Sequence[str]
+            IDs of the Station nodes to validate. All must exist in the process plan's station graph and stations without persisted assembly steps are accepted and reported as skipped.
+
+        fix_directions : typing.Optional[bool]
+            Apply each blocked step's workspace-free alternative direction onto the step graph, so the persisted verdict describes the repaired plan. Absent, the step graph is untouched.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[SeqPlanAccepted]
+            Validation jobs accepted and running in the background.
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"api/v4/assemblies/{encode_path_param(namespace)}/{encode_path_param(id)}/mpps/{encode_path_param(mpp_id)}:validate",
+            method="POST",
+            json={
+                "stationIds": station_ids,
+                "fixDirections": fix_directions,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    SeqPlanAccepted,
+                    parse_obj_as(
+                        type_=SeqPlanAccepted,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        parse_obj_as(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        except ValidationError as e:
+            raise ParsingError(
+                status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e
+            )
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def evaluate_dfa(
+        self,
+        namespace: EvaluateDfaRequestNamespace,
+        id: str,
+        mpp_id: str,
+        *,
+        station_ids: typing.Optional[typing.Sequence[str]] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[SeqPlanAccepted]:
+        """
+        Projects each sequential assembly addend directly from the persisted Step
+        graph into an explicit state-of-assembly transition, evaluates DFA, and
+        persists per-station reports under `plan.dfa`. Runs asynchronously.
+
+        Parameters
+        ----------
+        namespace : EvaluateDfaRequestNamespace
+            Assembly URL namespace. `user`, `shared`, and `public` are routed through the same assembly lookup.
+
+        id : str
+            Assembly ID.
+
+        mpp_id : str
+            Manufacturing Process Plan ID.
+
+        station_ids : typing.Optional[typing.Sequence[str]]
+            Stations to score. Omitted means every station with assembly steps, and then a station that is not ready is skipped rather than refused. A station named here must be planned and hold a feasible validation verdict, or the whole request is refused with 409. Named stations without assembly steps are accepted and reported as skipped.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[SeqPlanAccepted]
+            DFA evaluation accepted (or nothing to evaluate). `skipped` lists requested stations that were not queued — no assembly steps, or, for an unfiltered request, not yet validated.
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"api/v4/assemblies/{encode_path_param(namespace)}/{encode_path_param(id)}/mpps/{encode_path_param(mpp_id)}:dfa",
+            method="POST",
+            json={
+                "stationIds": station_ids,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    SeqPlanAccepted,
+                    parse_obj_as(
+                        type_=SeqPlanAccepted,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        parse_obj_as(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 409:
+                raise ConflictError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        parse_obj_as(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        except ValidationError as e:
+            raise ParsingError(
+                status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e
+            )
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)