UncountablePythonSDK 0.0.8__py3-none-any.whl → 0.0.92__py3-none-any.whl

uncountable/types/async_batch_processor.py

@@ -0,0 +1,384 @@
+# DO NOT MODIFY -- This file is generated by type_spec
+# flake8: noqa: F821
+# ruff: noqa: E402 Q003
+# fmt: off
+# isort: skip_file
+# ruff: noqa: PLR0904
+from __future__ import annotations
+import typing  # noqa: F401
+import datetime  # noqa: F401
+from decimal import Decimal  # noqa: F401
+import uncountable.types.api.equipment.associate_equipment_input as associate_equipment_input_t
+import uncountable.types.api.recipes.associate_recipe_as_input as associate_recipe_as_input_t
+from uncountable.types import async_batch_t
+from uncountable.types import base_t
+import uncountable.types.api.recipes.clear_recipe_outputs as clear_recipe_outputs_t
+import uncountable.types.api.recipes.create_recipe as create_recipe_t
+import uncountable.types.api.recipes.edit_recipe_inputs as edit_recipe_inputs_t
+from uncountable.types import entity_t
+from uncountable.types import field_values_t
+from uncountable.types import generic_upload_t
+import uncountable.types.api.entity.grant_entity_permissions as grant_entity_permissions_t
+from uncountable.types import identifier_t
+import uncountable.types.api.uploader.invoke_uploader as invoke_uploader_t
+from uncountable.types import recipe_identifiers_t
+from uncountable.types import recipe_metadata_t
+from uncountable.types import recipe_workflow_steps_t
+import uncountable.types.api.entity.set_entity_field_values as set_entity_field_values_t
+import uncountable.types.api.recipes.set_recipe_metadata as set_recipe_metadata_t
+import uuid
+from abc import ABC, abstractmethod
+from pkgs.serialization_util import serialize_for_api
+
+
+class AsyncBatchProcessorBase(ABC):
+    @abstractmethod
+    def _enqueue(self, req: async_batch_t.AsyncBatchRequest) -> None:
+        ...
+
+    @abstractmethod
+    def send(self) -> base_t.ObjectId:
+        ...
+
+    def associate_equipment_input(
+        self,
+        *,
+        equipment_key: identifier_t.IdentifierKey,
+        material_family_ids: list[base_t.ObjectId],
+        depends_on: list[str] | None = None,
+    ) -> async_batch_t.QueuedAsyncBatchRequest:
+        """Create or return the input association for equipment
+
+        :param equipment_key: Identifier of the equipment to associate
+        :param material_family_ids: The list of material families to add the input to. This must be non-empty
+        :param depends_on: A list of batch reference keys to process before processing this request
+        """
+        args = associate_equipment_input_t.Arguments(
+            equipment_key=equipment_key,
+            material_family_ids=material_family_ids,
+        )
+        json_data = serialize_for_api(args)
+
+        batch_reference = str(uuid.uuid4())
+
+        req = async_batch_t.AsyncBatchRequest(
+            path=async_batch_t.AsyncBatchRequestPath.ASSOCIATE_EQUIPMENT_INPUT,
+            data=json_data,
+            depends_on=depends_on,
+            batch_reference=batch_reference,
+        )
+
+        self._enqueue(req)
+
+        return async_batch_t.QueuedAsyncBatchRequest(
+            path=req.path,
+            batch_reference=req.batch_reference,
+        )
+
+    def associate_recipe_as_input(
+        self,
+        *,
+        recipe_key: identifier_t.IdentifierKey,
+        input_key: identifier_t.IdentifierKey | None = None,
+        show_in_listings: bool | None = None,
+        depends_on: list[str] | None = None,
+    ) -> async_batch_t.QueuedAsyncBatchRequest:
+        """Create or return the input association for a recipe
+
+        :param recipe_key: Identifier for the recipe
+        :param input_key: Identifier for an input to use for the association.  Optionally supplied.  If not supplied, one is created
+        :param show_in_listings: After associating the input should it be present in listings
+        :param depends_on: A list of batch reference keys to process before processing this request
+        """
+        args = associate_recipe_as_input_t.Arguments(
+            recipe_key=recipe_key,
+            input_key=input_key,
+            show_in_listings=show_in_listings,
+        )
+        json_data = serialize_for_api(args)
+
+        batch_reference = str(uuid.uuid4())
+
+        req = async_batch_t.AsyncBatchRequest(
+            path=async_batch_t.AsyncBatchRequestPath.ASSOCIATE_RECIPE_AS_INPUT,
+            data=json_data,
+            depends_on=depends_on,
+            batch_reference=batch_reference,
+        )
+
+        self._enqueue(req)
+
+        return async_batch_t.QueuedAsyncBatchRequest(
+            path=req.path,
+            batch_reference=req.batch_reference,
+        )
+
+    def clear_recipe_outputs(
+        self,
+        *,
+        recipe_key: identifier_t.IdentifierKey,
+        depends_on: list[str] | None = None,
+    ) -> async_batch_t.QueuedAsyncBatchRequest:
+        """Clears all output values & output metadata for a given recipe
+
+        :param recipe_key: The identifier of the recipe
+        :param depends_on: A list of batch reference keys to process before processing this request
+        """
+        args = clear_recipe_outputs_t.Arguments(
+            recipe_key=recipe_key,
+        )
+        json_data = serialize_for_api(args)
+
+        batch_reference = str(uuid.uuid4())
+
+        req = async_batch_t.AsyncBatchRequest(
+            path=async_batch_t.AsyncBatchRequestPath.CLEAR_RECIPE_OUTPUTS,
+            data=json_data,
+            depends_on=depends_on,
+            batch_reference=batch_reference,
+        )
+
+        self._enqueue(req)
+
+        return async_batch_t.QueuedAsyncBatchRequest(
+            path=req.path,
+            batch_reference=req.batch_reference,
+        )
+
+    def create_recipe(
+        self,
+        *,
+        material_family_id: base_t.ObjectId,
+        workflow_id: base_t.ObjectId,
+        name: str | None = None,
+        project_id: base_t.ObjectId | None = None,
+        workflow_variant_id: typing.Optional[base_t.ObjectId] | None = None,
+        recipe_metadata: list[recipe_metadata_t.MetadataValue] | None = None,
+        identifiers: recipe_identifiers_t.RecipeIdentifiers | None = None,
+        definition_key: identifier_t.IdentifierKey | None = None,
+        depends_on: list[str] | None = None,
+    ) -> async_batch_t.QueuedAsyncBatchRequest:
+        """Returns the id of the recipe being created.
+
+        :param name: The name for the recipe
+        :param material_family_id: The material family for the recipe
+        :param project_id: The identifier of the project to create the recipe in
+        :param workflow_id: The identifier of the workflow to create the recipe with
+        :param workflow_variant_id: The identifier of the workflow variant to create the recipe with
+        :param recipe_metadata: Metadata values to populate the recipe with
+        :param identifiers: A recipe won't be created if it matches the identifier.  An identifier must be unique in the schema
+        :param definition_key: The entity definition identifier, default is used if not supplied
+        :param depends_on: A list of batch reference keys to process before processing this request
+        """
+        args = create_recipe_t.Arguments(
+            name=name,
+            material_family_id=material_family_id,
+            project_id=project_id,
+            workflow_id=workflow_id,
+            workflow_variant_id=workflow_variant_id,
+            recipe_metadata=recipe_metadata,
+            identifiers=identifiers,
+            definition_key=definition_key,
+        )
+        json_data = serialize_for_api(args)
+
+        batch_reference = str(uuid.uuid4())
+
+        req = async_batch_t.AsyncBatchRequest(
+            path=async_batch_t.AsyncBatchRequestPath.CREATE_RECIPE,
+            data=json_data,
+            depends_on=depends_on,
+            batch_reference=batch_reference,
+        )
+
+        self._enqueue(req)
+
+        return async_batch_t.QueuedAsyncBatchRequest(
+            path=req.path,
+            batch_reference=req.batch_reference,
+        )
+
+    def edit_recipe_inputs(
+        self,
+        *,
+        recipe_key: identifier_t.IdentifierKey,
+        recipe_workflow_step_identifier: recipe_workflow_steps_t.RecipeWorkflowStepIdentifier,
+        edits: list[edit_recipe_inputs_t.RecipeInputEdit],
+        depends_on: list[str] | None = None,
+    ) -> async_batch_t.QueuedAsyncBatchRequest:
+        """Clear, update, or add inputs on a recipe
+
+        :param recipe_key: Identifier for the recipe
+        :param depends_on: A list of batch reference keys to process before processing this request
+        """
+        args = edit_recipe_inputs_t.Arguments(
+            recipe_key=recipe_key,
+            recipe_workflow_step_identifier=recipe_workflow_step_identifier,
+            edits=edits,
+        )
+        json_data = serialize_for_api(args)
+
+        batch_reference = str(uuid.uuid4())
+
+        req = async_batch_t.AsyncBatchRequest(
+            path=async_batch_t.AsyncBatchRequestPath.EDIT_RECIPE_INPUTS,
+            data=json_data,
+            depends_on=depends_on,
+            batch_reference=batch_reference,
+        )
+
+        self._enqueue(req)
+
+        return async_batch_t.QueuedAsyncBatchRequest(
+            path=req.path,
+            batch_reference=req.batch_reference,
+        )
+
+    def grant_entity_permissions(
+        self,
+        *,
+        entity_type: entity_t.LimitedEntityType,
+        entity_key: identifier_t.IdentifierKey,
+        permission_types: list[entity_t.GrantableEntityPermissionType],
+        user_keys: list[identifier_t.IdentifierKey] | None = None,
+        user_group_keys: list[identifier_t.IdentifierKey] | None = None,
+        all_users: bool | None = None,
+        depends_on: list[str] | None = None,
+    ) -> async_batch_t.QueuedAsyncBatchRequest:
+        """Grant entity permissions to a list of users or user groups or to all users.
+
+        :param depends_on: A list of batch reference keys to process before processing this request
+        """
+        args = grant_entity_permissions_t.Arguments(
+            entity_type=entity_type,
+            entity_key=entity_key,
+            permission_types=permission_types,
+            user_keys=user_keys,
+            user_group_keys=user_group_keys,
+            all_users=all_users,
+        )
+        json_data = serialize_for_api(args)
+
+        batch_reference = str(uuid.uuid4())
+
+        req = async_batch_t.AsyncBatchRequest(
+            path=async_batch_t.AsyncBatchRequestPath.GRANT_ENTITY_PERMISSIONS,
+            data=json_data,
+            depends_on=depends_on,
+            batch_reference=batch_reference,
+        )
+
+        self._enqueue(req)
+
+        return async_batch_t.QueuedAsyncBatchRequest(
+            path=req.path,
+            batch_reference=req.batch_reference,
+        )
+
+    def invoke_uploader(
+        self,
+        *,
+        uploader_key: identifier_t.IdentifierKey,
+        destination: generic_upload_t.UploadDestination,
+        file_id: base_t.ObjectId | None = None,
+        file_ids: list[base_t.ObjectId] | None = None,
+        depends_on: list[str] | None = None,
+    ) -> async_batch_t.QueuedAsyncBatchRequest:
+        """Runs a file through an uploader.
+
+        :param file_id: DEPRECATED: use file_ids
+        :param depends_on: A list of batch reference keys to process before processing this request
+        """
+        args = invoke_uploader_t.Arguments(
+            file_id=file_id,
+            file_ids=file_ids,
+            uploader_key=uploader_key,
+            destination=destination,
+        )
+        json_data = serialize_for_api(args)
+
+        batch_reference = str(uuid.uuid4())
+
+        req = async_batch_t.AsyncBatchRequest(
+            path=async_batch_t.AsyncBatchRequestPath.INVOKE_UPLOADER,
+            data=json_data,
+            depends_on=depends_on,
+            batch_reference=batch_reference,
+        )
+
+        self._enqueue(req)
+
+        return async_batch_t.QueuedAsyncBatchRequest(
+            path=req.path,
+            batch_reference=req.batch_reference,
+        )
+
+    def set_entity_field_values(
+        self,
+        *,
+        entity_identifier: entity_t.EntityIdentifier,
+        field_values: list[field_values_t.FieldArgumentValue],
+        depends_on: list[str] | None = None,
+    ) -> async_batch_t.QueuedAsyncBatchRequest:
+        """Sets field values for an entity
+
+        :param entity_identifier: Entity to update
+        :param field_values: Field values to set
+        :param depends_on: A list of batch reference keys to process before processing this request
+        """
+        args = set_entity_field_values_t.Arguments(
+            entity_identifier=entity_identifier,
+            field_values=field_values,
+        )
+        json_data = serialize_for_api(args)
+
+        batch_reference = str(uuid.uuid4())
+
+        req = async_batch_t.AsyncBatchRequest(
+            path=async_batch_t.AsyncBatchRequestPath.SET_ENTITY_FIELD_VALUES,
+            data=json_data,
+            depends_on=depends_on,
+            batch_reference=batch_reference,
+        )
+
+        self._enqueue(req)
+
+        return async_batch_t.QueuedAsyncBatchRequest(
+            path=req.path,
+            batch_reference=req.batch_reference,
+        )
+
+    def set_recipe_metadata(
+        self,
+        *,
+        recipe_key: identifier_t.IdentifierKey,
+        recipe_metadata: list[recipe_metadata_t.MetadataValue],
+        depends_on: list[str] | None = None,
+    ) -> async_batch_t.QueuedAsyncBatchRequest:
+        """Set metadata values on a recipe
+
+        :param recipe_key: Identifier for the recipe
+        :param recipe_metadata: Metadata values to populate the recipe with
+        :param depends_on: A list of batch reference keys to process before processing this request
+        """
+        args = set_recipe_metadata_t.Arguments(
+            recipe_key=recipe_key,
+            recipe_metadata=recipe_metadata,
+        )
+        json_data = serialize_for_api(args)
+
+        batch_reference = str(uuid.uuid4())
+
+        req = async_batch_t.AsyncBatchRequest(
+            path=async_batch_t.AsyncBatchRequestPath.SET_RECIPE_METADATA,
+            data=json_data,
+            depends_on=depends_on,
+            batch_reference=batch_reference,
+        )
+
+        self._enqueue(req)
+
+        return async_batch_t.QueuedAsyncBatchRequest(
+            path=req.path,
+            batch_reference=req.batch_reference,
+        )

uncountable/types/async_batch_t.py

@@ -0,0 +1,97 @@
+# DO NOT MODIFY -- This file is generated by type_spec
+# flake8: noqa: F821
+# ruff: noqa: E402 Q003
+# fmt: off
+# isort: skip_file
+from __future__ import annotations
+import typing  # noqa: F401
+import datetime  # noqa: F401
+from decimal import Decimal  # noqa: F401
+from pkgs.strenum_compat import StrEnum
+import dataclasses
+from pkgs.serialization import serial_class
+from . import base_t
+from . import entity_t
+
+__all__: list[str] = [
+    "AsyncBatchActionReturn",
+    "AsyncBatchRequest",
+    "AsyncBatchRequestPath",
+    "AsyncBatchResultValue",
+    "QueuedAsyncBatchRequest",
+    "SavedAsyncBatchActionReturn",
+]
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+class AsyncBatchRequestPath(StrEnum):
+    CREATE_RECIPE = "recipes/create_recipe"
+    SET_RECIPE_METADATA = "recipes/set_recipe_metadata"
+    SET_RECIPE_TAGS = "recipes/set_recipe_tags"
+    EDIT_RECIPE_INPUTS = "recipes/edit_recipe_inputs"
+    ARCHIVE_RECIPES = "recipes/archive"
+    LOCK_RECIPES = "recipes/lock_recipes"
+    UNLOCK_RECIPES = "recipes/unlock_recipes"
+    ASSOCIATE_EQUIPMENT_INPUT = "equipment/associate_equipment_input"
+    INVOKE_UPLOADER = "uploader/invoke_uploader"
+    ASSOCIATE_RECIPE_AS_INPUT = "recipes/associate_recipe_as_input"
+    CLEAR_RECIPE_OUTPUTS = "recipes/clear_recipe_outputs"
+    GRANT_ENTITY_PERMISSIONS = "entity/grant_entity_permissions"
+    SET_ENTITY_FIELD_VALUES = "entity/set_entity_field_values"
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.async_batch.AsyncBatchRequest",
+    unconverted_values={"data"},
+)
+@dataclasses.dataclass(kw_only=True)
+class AsyncBatchRequest:
+    path: AsyncBatchRequestPath
+    data: base_t.JsonValue
+    batch_reference: str
+    depends_on: list[str] | None = None
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.async_batch.AsyncBatchResultValue",
+    unconverted_values={"value"},
+)
+@dataclasses.dataclass(kw_only=True)
+class AsyncBatchResultValue:
+    data_key: str
+    value: base_t.JsonValue
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.async_batch.AsyncBatchActionReturn",
+)
+@dataclasses.dataclass(kw_only=True)
+class AsyncBatchActionReturn:
+    modification_made: bool
+    result_id: base_t.ObjectId | None = None
+    entity: entity_t.Entity | None = None
+    result_values: list[AsyncBatchResultValue] | None = None
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.async_batch.SavedAsyncBatchActionReturn",
+)
+@dataclasses.dataclass(kw_only=True)
+class SavedAsyncBatchActionReturn:
+    identifier: str
+    result_data: AsyncBatchActionReturn
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.async_batch.QueuedAsyncBatchRequest",
+)
+@dataclasses.dataclass(kw_only=True, frozen=True, eq=True)
+class QueuedAsyncBatchRequest:
+    path: AsyncBatchRequestPath
+    batch_reference: str
+# DO NOT MODIFY -- This file is generated by type_spec

uncountable/types/async_jobs.py

@@ -0,0 +1,9 @@
+# flake8: noqa: F821
+# ruff: noqa: E402 Q003
+# fmt: off
+# isort: skip_file
+# DO NOT MODIFY -- This file is generated by type_spec
+# Kept only for SDK backwards compatibility
+from .async_jobs_t import AsyncJobType as AsyncJobType
+from .async_jobs_t import AsyncJobStatus as AsyncJobStatus
+# DO NOT MODIFY -- This file is generated by type_spec

uncountable/types/async_jobs_t.py

@@ -0,0 +1,53 @@
+# DO NOT MODIFY -- This file is generated by type_spec
+# flake8: noqa: F821
+# ruff: noqa: E402 Q003
+# fmt: off
+# isort: skip_file
+from __future__ import annotations
+import typing  # noqa: F401
+import datetime  # noqa: F401
+from decimal import Decimal  # noqa: F401
+from pkgs.strenum_compat import StrEnum
+from pkgs.serialization import serial_string_enum
+
+__all__: list[str] = [
+    "ASYNC_JOB_STATUS_FIELD_REF_NAME",
+    "ASYNC_JOB_TYPE_FIELD_REF_NAME",
+    "AsyncJobStatus",
+    "AsyncJobType",
+]
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_string_enum(
+    labels={
+        "async_batch_load": "Async Batch Load",
+        "integration_server_run": "Integration Server Run",
+    },
+)
+class AsyncJobType(StrEnum):
+    ASYNC_BATCH_LOAD = "async_batch_load"
+    INTEGRATION_SERVER_RUN = "integration_server_run"
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_string_enum(
+    labels={
+        "in_progress": "In Progress",
+        "completed": "Completed",
+        "error": "Error",
+    },
+)
+class AsyncJobStatus(StrEnum):
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    ERROR = "error"
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+ASYNC_JOB_TYPE_FIELD_REF_NAME = "core_async_job_jobType"
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+ASYNC_JOB_STATUS_FIELD_REF_NAME = "core_async_job_status"
+# DO NOT MODIFY -- This file is generated by type_spec

uncountable/types/auth_retrieval.py

@@ -0,0 +1,12 @@
+# flake8: noqa: F821
+# ruff: noqa: E402 Q003
+# fmt: off
+# isort: skip_file
+# DO NOT MODIFY -- This file is generated by type_spec
+# Kept only for SDK backwards compatibility
+from .auth_retrieval_t import AuthRetrievalType as AuthRetrievalType
+from .auth_retrieval_t import AuthRetrievalBase as AuthRetrievalBase
+from .auth_retrieval_t import AuthRetrievalOAuth as AuthRetrievalOAuth
+from .auth_retrieval_t import AuthRetrievalBasic as AuthRetrievalBasic
+from .auth_retrieval_t import AuthRetrieval as AuthRetrieval
+# DO NOT MODIFY -- This file is generated by type_spec

uncountable/types/auth_retrieval_t.py

@@ -0,0 +1,75 @@
+# DO NOT MODIFY -- This file is generated by type_spec
+# flake8: noqa: F821
+# ruff: noqa: E402 Q003
+# fmt: off
+# isort: skip_file
+from __future__ import annotations
+import typing  # noqa: F401
+import datetime  # noqa: F401
+from decimal import Decimal  # noqa: F401
+from pkgs.strenum_compat import StrEnum
+import dataclasses
+from pkgs.serialization import serial_class
+from pkgs.serialization import serial_union_annotation
+from . import secret_retrieval_t
+
+__all__: list[str] = [
+    "AuthRetrieval",
+    "AuthRetrievalBase",
+    "AuthRetrievalBasic",
+    "AuthRetrievalOAuth",
+    "AuthRetrievalType",
+]
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+class AuthRetrievalType(StrEnum):
+    OAUTH = "oauth"
+    BASIC = "basic"
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.auth_retrieval.AuthRetrievalBase",
+)
+@dataclasses.dataclass(kw_only=True)
+class AuthRetrievalBase:
+    type: AuthRetrievalType
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.auth_retrieval.AuthRetrievalOAuth",
+    parse_require={"type"},
+)
+@dataclasses.dataclass(kw_only=True)
+class AuthRetrievalOAuth(AuthRetrievalBase):
+    type: typing.Literal[AuthRetrievalType.OAUTH] = AuthRetrievalType.OAUTH
+    refresh_token_secret: secret_retrieval_t.SecretRetrieval
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.auth_retrieval.AuthRetrievalBasic",
+    parse_require={"type"},
+)
+@dataclasses.dataclass(kw_only=True)
+class AuthRetrievalBasic(AuthRetrievalBase):
+    type: typing.Literal[AuthRetrievalType.BASIC] = AuthRetrievalType.BASIC
+    api_id_secret: secret_retrieval_t.SecretRetrieval
+    api_key_secret: secret_retrieval_t.SecretRetrieval
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+AuthRetrieval = typing.Annotated[
+    typing.Union[AuthRetrievalOAuth, AuthRetrievalBasic],
+    serial_union_annotation(
+    named_type_path="sdk.auth_retrieval.AuthRetrieval",
+        discriminator="type",
+        discriminator_map={
+            "oauth": AuthRetrievalOAuth,
+            "basic": AuthRetrievalBasic,
+        },
+    ),
+]
+# DO NOT MODIFY -- This file is generated by type_spec