UncountablePythonSDK 0.0.181__tar.gz → 0.0.182__tar.gz

{uncountablepythonsdk-0.0.181/UncountablePythonSDK.egg-info → uncountablepythonsdk-0.0.182}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UncountablePythonSDK
-Version: 0.0.181
+Version: 0.0.182
 Summary: Uncountable SDK
 Project-URL: Homepage, https://github.com/uncountableinc/uncountable-python-sdk
 Project-URL: Repository, https://github.com/uncountableinc/uncountable-python-sdk.git

{uncountablepythonsdk-0.0.181 → uncountablepythonsdk-0.0.182/UncountablePythonSDK.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UncountablePythonSDK
-Version: 0.0.181
+Version: 0.0.182
 Summary: Uncountable SDK
 Project-URL: Homepage, https://github.com/uncountableinc/uncountable-python-sdk
 Project-URL: Repository, https://github.com/uncountableinc/uncountable-python-sdk.git

{uncountablepythonsdk-0.0.181 → uncountablepythonsdk-0.0.182}/UncountablePythonSDK.egg-info/SOURCES.txt

@@ -151,7 +151,8 @@ uncountable/integration/scan_profiles.py
 uncountable/integration/scheduler.py
 uncountable/integration/server.py
 uncountable/integration/telemetry.py
-uncountable/integration/webhook_signature_key.py
+uncountable/integration/webhook_bootstrap.py
+uncountable/integration/webhook_entity.py
 uncountable/integration/db/__init__.py
 uncountable/integration/db/connect.py
 uncountable/integration/db/session.py
@@ -190,8 +191,12 @@ uncountable/integration/secret_retrieval/__init__.py
 uncountable/integration/secret_retrieval/basic_secret.py
 uncountable/integration/secret_retrieval/retrieve_secret.py
 uncountable/integration/webhook_server/admin_auth.py
-uncountable/integration/webhook_server/admin_routes.py
 uncountable/integration/webhook_server/entrypoint.py
+uncountable/integration/webhook_server/admin_routes/__init__.py
+uncountable/integration/webhook_server/admin_routes/_boundary.py
+uncountable/integration/webhook_server/admin_routes/health.py
+uncountable/integration/webhook_server/admin_routes/jobs.py
+uncountable/integration/webhook_server/admin_routes/register.py
 uncountable/types/__init__.py
 uncountable/types/async_batch.py
 uncountable/types/async_batch_processor.py

{uncountablepythonsdk-0.0.181 → uncountablepythonsdk-0.0.182}/examples/integration-server/jobs/materials_auto/profile.yaml

@@ -1,4 +1,5 @@
 base_url: http://host.docker.internal:5000
+integration_server_base_url: http://localhost:5001
 auth_retrieval:
   type: basic
   api_id_secret:
@@ -60,6 +61,13 @@ jobs:
     executor:
       type: script
       import_path: example_wh
+  - id: example_unc_wh
+    type: uncountable_webhook
+    name: Uncountable Webhook
+    purpose: trigger
+    executor:
+      type: script
+      import_path: example_wh
   - id: example_http
     type: custom_http
     name: Custom HTTP

{uncountablepythonsdk-0.0.181 → uncountablepythonsdk-0.0.182}/uncountable/integration/entrypoint.py

@@ -1,11 +1,14 @@
 from uncountable.integration.db.connect import IntegrationDBService, create_db_engine
 from uncountable.integration.scan_profiles import load_profiles
 from uncountable.integration.server import IntegrationServer
+from uncountable.integration.webhook_bootstrap import start_webhook_entity_bootstrap
 
 
 def main() -> None:
+    profiles = load_profiles()
     with IntegrationServer(create_db_engine(IntegrationDBService.CRON)) as server:
-        server.register_jobs(load_profiles())
+        start_webhook_entity_bootstrap(profiles)
+        server.register_jobs(profiles)
         server.serve_forever()
 
 

{uncountablepythonsdk-0.0.181 → uncountablepythonsdk-0.0.182}/uncountable/integration/http_server/types.py

@@ -28,6 +28,10 @@ class HttpException(Exception):
     def body_parse_error() -> "HttpException":
         return HttpException(error_code=400, message="body parse error")
 
+    @staticmethod
+    def bad_request(message: str = "bad request") -> "HttpException":
+        return HttpException(error_code=400, message=message)
+
     @staticmethod
     def unauthorized() -> "HttpException":
         return HttpException(error_code=401, message="unauthorized")

{uncountablepythonsdk-0.0.181 → uncountablepythonsdk-0.0.182}/uncountable/integration/job.py

@@ -27,7 +27,7 @@ from uncountable.integration.queue_runner.command_server.types import (
 from uncountable.integration.request_context import extract_request_context
 from uncountable.integration.secret_retrieval import retrieve_secret
 from uncountable.integration.telemetry import JobLogger
-from uncountable.integration.webhook_signature_key import (
+from uncountable.integration.webhook_entity import (
     webhook_signature_key_retrieval,
 )
 from uncountable.types import (

{uncountablepythonsdk-0.0.181 → uncountablepythonsdk-0.0.182}/uncountable/integration/queue_runner/command_server/provision_webhook.py

@@ -3,9 +3,7 @@ from opentelemetry.trace import get_current_span
 from uncountable.integration.construct_client import construct_uncountable_client
 from uncountable.integration.scan_profiles import load_profiles
 from uncountable.integration.telemetry import Logger
-from uncountable.integration.webhook_signature_key import (
-    bootstrap_webhook_signature_key,
-)
+from uncountable.integration.webhook_entity import create_missing_webhook_entities
 from uncountable.types import job_definition_t
 
 
@@ -17,12 +15,10 @@ def provision_webhook(*, job_id: str) -> str | None:
                 isinstance(job, job_definition_t.UncountableWebhookJobDefinition)
                 and job.id == job_id
             ):
-                client = construct_uncountable_client(profile_metadata, logger)
-                bootstrap_webhook_signature_key(
-                    client=client,
+                create_missing_webhook_entities(
+                    client=construct_uncountable_client(profile_metadata, logger),
                     profile_metadata=profile_metadata,
-                    job_id=job.id,
-                    purpose=job.purpose,
+                    jobs=[job],
                 )
                 return profile_metadata.name
     return None

uncountablepythonsdk-0.0.182/uncountable/integration/webhook_bootstrap.py

@@ -0,0 +1,67 @@
+import threading
+
+from opentelemetry.trace import get_current_span
+
+from uncountable.integration.construct_client import construct_uncountable_client
+from uncountable.integration.telemetry import Logger
+from uncountable.integration.webhook_entity import create_missing_webhook_entities
+from uncountable.types import job_definition_t
+
+_BOOTSTRAP_SCOPE_NAME = "bootstrap_webhook_entities"
+_BOOTSTRAP_THREAD_NAME = "webhook-entity-bootstrap"
+
+
+def _bootstrap_profile_webhook_entities(
+    *,
+    profile_metadata: job_definition_t.ProfileMetadata,
+    jobs: list[job_definition_t.UncountableWebhookJobDefinition],
+    logger: Logger,
+) -> None:
+    created_job_ids = create_missing_webhook_entities(
+        client=construct_uncountable_client(profile_metadata, logger),
+        profile_metadata=profile_metadata,
+        jobs=jobs,
+    )
+    logger.log_debug(
+        f"bootstrapped {len(created_job_ids)} webhook entities for profile {profile_metadata.name}",
+        attributes={
+            "profile.name": profile_metadata.name,
+            "webhook.created_job_ids": created_job_ids,
+        },
+    )
+
+
+def _bootstrap_webhook_entities(
+    profiles: list[job_definition_t.ProfileMetadata],
+) -> None:
+    logger = Logger(get_current_span())
+    with logger.push_scope(_BOOTSTRAP_SCOPE_NAME):
+        for profile_metadata in profiles:
+            webhook_jobs = [
+                job
+                for job in profile_metadata.jobs
+                if isinstance(job, job_definition_t.UncountableWebhookJobDefinition)
+            ]
+            if len(webhook_jobs) == 0:
+                continue
+            try:
+                _bootstrap_profile_webhook_entities(
+                    profile_metadata=profile_metadata, jobs=webhook_jobs, logger=logger
+                )
+            except Exception as e:
+                logger.log_exception(
+                    e,
+                    message=f"failed to bootstrap webhook entities for profile {profile_metadata.name}",
+                    attributes={"profile.name": profile_metadata.name},
+                )
+
+
+def start_webhook_entity_bootstrap(
+    profiles: list[job_definition_t.ProfileMetadata],
+) -> None:
+    threading.Thread(
+        target=_bootstrap_webhook_entities,
+        args=(profiles,),
+        name=_BOOTSTRAP_THREAD_NAME,
+        daemon=True,
+    ).start()

uncountablepythonsdk-0.0.182/uncountable/integration/webhook_entity.py

@@ -0,0 +1,147 @@
+import secrets
+from collections.abc import Sequence
+
+from uncountable.core.client import Client
+from uncountable.core.query.builder import QueryBuilder
+from uncountable.core.query.column import (
+    NullableColumn,
+    TextColumn,
+)
+from uncountable.core.query.row import QueryRow
+from uncountable.types import (
+    create_or_update_entities_t,
+    entity_t,
+    field_values_t,
+    identifier_t,
+    listing_t,
+)
+from uncountable.types.job_definition_t import (
+    ProfileMetadata,
+    UncountableWebhookJobDefinition,
+)
+from uncountable.types.secret_retrieval_t import SecretRetrievalEntityColumn
+
+_WEBHOOK_DEFINITION_REF_NAME = "unc_webhook_definition"
+_WEBHOOK_REF_NAME_FIELD_REF_NAME = "refName"
+_WEBHOOK_NAME_FIELD_REF_NAME = "name"
+_WEBHOOK_URL_FIELD_REF_NAME = "core_webhook_url"
+_WEBHOOK_SIGNATURE_KEY_FIELD_REF_NAME = "core_webhook_signatureKey"
+_WEBHOOK_PURPOSE_FIELD_REF_NAME = "core_webhook_purpose"
+_SIGNATURE_KEY_NUM_BYTES = 32
+
+
+class _WebhookEntityQueryRow(QueryRow):
+    ref_name = TextColumn(
+        identifier=listing_t.ColumnIdentifierEntityRefName(
+            entity_type=entity_t.EntityType.WEBHOOK,
+            ref_name=_WEBHOOK_REF_NAME_FIELD_REF_NAME,
+        ),
+        nullable=NullableColumn,
+    )
+
+
+def webhook_signature_key_retrieval(*, job_id: str) -> SecretRetrievalEntityColumn:
+    return SecretRetrievalEntityColumn(
+        entity_key=identifier_t.IdentifierKeyRefName(ref_name=job_id),
+        column_identifier=listing_t.ColumnIdentifierEntityRefName(
+            entity_type=entity_t.EntityType.WEBHOOK,
+            ref_name=_WEBHOOK_SIGNATURE_KEY_FIELD_REF_NAME,
+        ),
+    )
+
+
+def _resolve_webhook_url(*, profile_metadata: ProfileMetadata, job_id: str) -> str:
+    integration_server_base_url = profile_metadata.integration_server_base_url
+    if integration_server_base_url is None:
+        raise ValueError(
+            "integration_server_base_url is required to resolve the webhook entity "
+            f"for {profile_metadata.name}/{job_id}"
+        )
+    return f"{integration_server_base_url.rstrip('/')}/{profile_metadata.name}/{job_id}"
+
+
+def _fetch_existing_webhook_ref_names(
+    *, client: Client, job_ids: Sequence[str]
+) -> set[str]:
+    existing_webhooks = (
+        QueryBuilder(client=client, model=_WebhookEntityQueryRow)
+        .filter(_WebhookEntityQueryRow.ref_name.includes(tuple(job_ids)))
+        .all()
+    )
+    return {
+        webhook.ref_name
+        for webhook in existing_webhooks
+        if webhook.ref_name is not None
+    }
+
+
+def _text_field_value(
+    *, field_ref_name: str, value: str
+) -> field_values_t.FieldArgumentValue:
+    return field_values_t.FieldArgumentValue(
+        field_key=identifier_t.IdentifierKeyRefName(ref_name=field_ref_name),
+        value=field_values_t.FieldValueText(value=value),
+    )
+
+
+def _build_webhook_operation(
+    *, profile_metadata: ProfileMetadata, job: UncountableWebhookJobDefinition
+) -> create_or_update_entities_t.EntityToCreateOrUpdate:
+    # entity_key is deliberately omitted so the operation always takes the create
+    # path. Supplying a ref_name key that resolves to nothing raises not-found
+    # rather than creating the entity, and callers only pass jobs already known
+    # to have no webhook entity.
+    return create_or_update_entities_t.EntityToCreateOrUpdate(
+        field_values=[],
+        on_create_init_field_values=[
+            _text_field_value(
+                field_ref_name=_WEBHOOK_REF_NAME_FIELD_REF_NAME, value=job.id
+            ),
+            _text_field_value(
+                field_ref_name=_WEBHOOK_NAME_FIELD_REF_NAME,
+                value=f"{profile_metadata.name}/{job.id}",
+            ),
+            _text_field_value(
+                field_ref_name=_WEBHOOK_URL_FIELD_REF_NAME,
+                value=_resolve_webhook_url(
+                    profile_metadata=profile_metadata, job_id=job.id
+                ),
+            ),
+            _text_field_value(
+                field_ref_name=_WEBHOOK_SIGNATURE_KEY_FIELD_REF_NAME,
+                value=secrets.token_urlsafe(_SIGNATURE_KEY_NUM_BYTES),
+            ),
+            field_values_t.FieldArgumentValue(
+                field_key=identifier_t.IdentifierKeyRefName(
+                    ref_name=_WEBHOOK_PURPOSE_FIELD_REF_NAME
+                ),
+                value=field_values_t.FieldValueFieldOption(value=job.purpose.value),
+            ),
+        ],
+    )
+
+
+def create_missing_webhook_entities(
+    *,
+    client: Client,
+    profile_metadata: ProfileMetadata,
+    jobs: Sequence[UncountableWebhookJobDefinition],
+) -> list[str]:
+    existing_ref_names = _fetch_existing_webhook_ref_names(
+        client=client, job_ids=[job.id for job in jobs]
+    )
+    missing_jobs = [job for job in jobs if job.id not in existing_ref_names]
+    if len(missing_jobs) == 0:
+        return []
+
+    client.create_or_update_entities(
+        entity_type=entity_t.EntityType.WEBHOOK,
+        definition_key=identifier_t.IdentifierKeyRefName(
+            ref_name=_WEBHOOK_DEFINITION_REF_NAME
+        ),
+        operations=[
+            _build_webhook_operation(profile_metadata=profile_metadata, job=job)
+            for job in missing_jobs
+        ],
+    )
+    return [job.id for job in missing_jobs]

uncountablepythonsdk-0.0.182/uncountable/integration/webhook_server/admin_routes/__init__.py

@@ -0,0 +1,3 @@
+from uncountable.integration.webhook_server.admin_routes.register import (
+    register_admin_routes as register_admin_routes,
+)

uncountablepythonsdk-0.0.182/uncountable/integration/webhook_server/admin_routes/_boundary.py

@@ -0,0 +1,39 @@
+import functools
+from collections.abc import Callable
+
+import flask
+from flask.typing import ResponseReturnValue
+from uncountable.integration.http_server import HttpException
+from uncountable.integration.queue_runner.command_server.types import (
+    CommandServerException,
+)
+from uncountable.integration.telemetry import Logger
+
+
+def register_admin_route(
+    *,
+    app: flask.Flask,
+    logger: Logger,
+    route: str,
+    endpoint: str,
+    view: Callable[..., ResponseReturnValue],
+    methods: list[str],
+) -> None:
+    @functools.wraps(view)
+    def wrapped(*args: object, **kwargs: object) -> ResponseReturnValue:
+        with logger.push_scope(route):
+            try:
+                return view(*args, **kwargs)
+            except HttpException as e:
+                return e.make_error_response()
+            except CommandServerException as e:
+                logger.log_exception(
+                    e,
+                    message=f"admin route {route} could not reach the command server",
+                )
+                return HttpException.bad_gateway().make_error_response()
+            except Exception as e:
+                logger.log_exception(e, message=f"unexpected error on {route}")
+                return HttpException.unknown_error().make_error_response()
+
+    app.add_url_rule(route, endpoint=endpoint, view_func=wrapped, methods=methods)

uncountablepythonsdk-0.0.182/uncountable/integration/webhook_server/admin_routes/health.py

@@ -0,0 +1,30 @@
+import flask
+from flask.typing import ResponseReturnValue
+from uncountable.core.environment import get_local_admin_server_port
+from uncountable.integration.queue_runner.command_server.command_client import (
+    check_health,
+)
+from uncountable.integration.telemetry import Logger
+from uncountable.integration.webhook_server.admin_auth import require_admin_auth
+from uncountable.integration.webhook_server.admin_routes._boundary import (
+    register_admin_route,
+)
+
+_ADMIN_HEALTH_ROUTE = "/admin/health"
+
+
+@require_admin_auth
+def _handle_admin_health() -> ResponseReturnValue:
+    healthy = check_health(port=get_local_admin_server_port())
+    return flask.jsonify({"healthy": healthy})
+
+
+def register_health_routes(*, app: flask.Flask, logger: Logger) -> None:
+    register_admin_route(
+        app=app,
+        logger=logger,
+        route=_ADMIN_HEALTH_ROUTE,
+        endpoint="admin_health",
+        view=_handle_admin_health,
+        methods=["GET"],
+    )

uncountablepythonsdk-0.0.182/uncountable/integration/webhook_server/admin_routes/jobs.py

@@ -0,0 +1,147 @@
+import datetime
+
+import flask
+from flask.typing import ResponseReturnValue
+from uncountable.core.environment import get_local_admin_server_port
+from uncountable.integration.http_server import HttpException
+from uncountable.integration.queue_runner.command_server.command_client import (
+    send_job_cancellation_message,
+    send_job_queue_message,
+    send_list_queued_jobs_message,
+    send_retry_job_message,
+)
+from uncountable.integration.queue_runner.command_server.protocol.command_server_pb2 import (
+    ListQueuedJobsResult,
+)
+from uncountable.integration.telemetry import Logger
+from uncountable.integration.webhook_server.admin_auth import require_admin_auth
+from uncountable.integration.webhook_server.admin_routes._boundary import (
+    register_admin_route,
+)
+from uncountable.types import base_t, queued_job_t
+
+from pkgs.serialization_util import serialize_for_api
+
+_ADMIN_JOBS_ROUTE = "/admin/jobs"
+_ADMIN_ENQUEUE_JOB_ROUTE = "/admin/jobs/enqueue"
+_ADMIN_RETRY_JOB_ROUTE = "/admin/jobs/<job_uuid>/retry"
+_ADMIN_CANCEL_JOB_ROUTE = "/admin/jobs/<job_uuid>/cancel"
+_DEFAULT_JOBS_LIMIT = 100
+_VALID_JOB_STATUSES = {status.value for status in queued_job_t.JobStatus}
+
+
+def _parse_job_status(raw_status: str | None) -> queued_job_t.JobStatus | None:
+    if raw_status is None:
+        return None
+    if raw_status not in _VALID_JOB_STATUSES:
+        raise HttpException.bad_request(f"invalid status: {raw_status}")
+    return queued_job_t.JobStatus(raw_status)
+
+
+def _parse_non_negative_int(raw_value: str | None, *, default: int) -> int:
+    if raw_value is None:
+        return default
+    if not raw_value.isdigit():
+        raise HttpException.bad_request(
+            f"expected a non-negative integer, got: {raw_value}"
+        )
+    return int(raw_value)
+
+
+def _serialize_queued_job(
+    item: ListQueuedJobsResult.ListQueuedJobsResultItem,
+) -> dict[str, base_t.JsonValue]:
+    metadata = queued_job_t.QueuedJobMetadata(
+        queued_job_uuid=item.uuid,
+        job_ref_name=item.job_ref_name,
+        num_attempts=item.num_attempts,
+        status=queued_job_t.JobStatus(item.status),
+        submitted_at=item.submitted_at.ToDatetime(datetime.timezone.utc),
+    )
+    return serialize_for_api(metadata)
+
+
+@require_admin_auth
+def _handle_list_jobs() -> ResponseReturnValue:
+    status = _parse_job_status(flask.request.args.get("status"))
+    offset = _parse_non_negative_int(flask.request.args.get("offset"), default=0)
+    limit = _parse_non_negative_int(
+        flask.request.args.get("limit"), default=_DEFAULT_JOBS_LIMIT
+    )
+    jobs = send_list_queued_jobs_message(
+        status=status, offset=offset, limit=limit, port=get_local_admin_server_port()
+    )
+    return flask.jsonify({"jobs": [_serialize_queued_job(job) for job in jobs]})
+
+
+@require_admin_auth
+def _handle_enqueue_job() -> ResponseReturnValue:
+    body = flask.request.get_json(silent=True)
+    if not isinstance(body, dict):
+        raise HttpException.bad_request("expected a JSON object body")
+    job_ref_name = body.get("job_ref_name")
+    if not isinstance(job_ref_name, str):
+        raise HttpException.bad_request("job_ref_name is required")
+    webhook_payload = body.get("webhook_payload")
+    invocation_context: queued_job_t.InvocationContext = (
+        queued_job_t.InvocationContextManual()
+        if webhook_payload is None
+        else queued_job_t.InvocationContextWebhook(webhook_payload=webhook_payload)
+    )
+    queued_job_uuid = send_job_queue_message(
+        job_ref_name=job_ref_name,
+        payload=queued_job_t.QueuedJobPayload(invocation_context=invocation_context),
+        port=get_local_admin_server_port(),
+    )
+    return flask.jsonify({"queuedJobUuid": queued_job_uuid})
+
+
+@require_admin_auth
+def _handle_retry_job(job_uuid: str) -> ResponseReturnValue:
+    queued_job_uuid = send_retry_job_message(
+        job_uuid=job_uuid, port=get_local_admin_server_port()
+    )
+    return flask.jsonify({"queuedJobUuid": queued_job_uuid})
+
+
+@require_admin_auth
+def _handle_cancel_job(job_uuid: str) -> ResponseReturnValue:
+    status = send_job_cancellation_message(
+        queued_job_uuid=job_uuid, port=get_local_admin_server_port()
+    )
+    return flask.jsonify({"status": status.value})
+
+
+def register_job_routes(*, app: flask.Flask, logger: Logger) -> None:
+    register_admin_route(
+        app=app,
+        logger=logger,
+        route=_ADMIN_JOBS_ROUTE,
+        endpoint="admin_list_jobs",
+        view=_handle_list_jobs,
+        methods=["GET"],
+    )
+    register_admin_route(
+        app=app,
+        logger=logger,
+        route=_ADMIN_ENQUEUE_JOB_ROUTE,
+        endpoint="admin_enqueue_job",
+        view=_handle_enqueue_job,
+        methods=["POST"],
+    )
+    register_admin_route(
+        app=app,
+        logger=logger,
+        route=_ADMIN_RETRY_JOB_ROUTE,
+        endpoint="admin_retry_job",
+        view=_handle_retry_job,
+        methods=["POST"],
+    )
+    register_admin_route(
+        app=app,
+        logger=logger,
+        route=_ADMIN_CANCEL_JOB_ROUTE,
+        endpoint="admin_cancel_job",
+        view=_handle_cancel_job,
+        methods=["POST"],
+    )

uncountablepythonsdk-0.0.182/uncountable/integration/webhook_server/admin_routes/register.py

@@ -0,0 +1,13 @@
+import flask
+from opentelemetry.trace import get_current_span
+from uncountable.integration.telemetry import Logger
+from uncountable.integration.webhook_server.admin_routes.health import (
+    register_health_routes,
+)
+from uncountable.integration.webhook_server.admin_routes.jobs import register_job_routes
+
+
+def register_admin_routes(app: flask.Flask) -> None:
+    logger = Logger(get_current_span())
+    register_health_routes(app=app, logger=logger)
+    register_job_routes(app=app, logger=logger)

{uncountablepythonsdk-0.0.181 → uncountablepythonsdk-0.0.182}/uncountable/types/generic_upload.py

@@ -9,6 +9,7 @@ from .generic_upload_t import UploadDestinationBase as UploadDestinationBase
 from .generic_upload_t import UploadDestinationProject as UploadDestinationProject
 from .generic_upload_t import UploadDestinationMaterialFamily as UploadDestinationMaterialFamily
 from .generic_upload_t import UploadDestinationRecipe as UploadDestinationRecipe
+from .generic_upload_t import UploadDestinationAutoMatch as UploadDestinationAutoMatch
 from .generic_upload_t import UploadDestination as UploadDestination
 from .generic_upload_t import GenericUploadStrategy as GenericUploadStrategy
 # DO NOT MODIFY -- This file is generated by type_spec

{uncountablepythonsdk-0.0.181 → uncountablepythonsdk-0.0.182}/uncountable/types/generic_upload_t.py

@@ -16,6 +16,7 @@ __all__: list[str] = [
     "GenericRemoteDirectoryScope",
     "GenericUploadStrategy",
     "UploadDestination",
+    "UploadDestinationAutoMatch",
     "UploadDestinationBase",
     "UploadDestinationMaterialFamily",
     "UploadDestinationProject",
@@ -47,6 +48,7 @@ class UploadDestinationType(StrEnum):
     PROJECT = "project"
     MATERIAL_FAMILY = "material_family"
     RECIPE = "recipe"
+    AUTO_MATCH = "auto_match"
 
 
 # DO NOT MODIFY -- This file is generated by type_spec
@@ -91,9 +93,19 @@ class UploadDestinationRecipe(UploadDestinationBase):
     recipe_key: identifier_t.IdentifierKey
 
 
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.generic_upload.UploadDestinationAutoMatch",
+    parse_require={"type"},
+)
+@dataclasses.dataclass(slots=True, kw_only=True)
+class UploadDestinationAutoMatch(UploadDestinationBase):
+    type: typing.Literal[UploadDestinationType.AUTO_MATCH] = UploadDestinationType.AUTO_MATCH
+
+
 # DO NOT MODIFY -- This file is generated by type_spec
 UploadDestination = typing.Annotated[
-    UploadDestinationProject | UploadDestinationMaterialFamily | UploadDestinationRecipe,
+    UploadDestinationProject | UploadDestinationMaterialFamily | UploadDestinationRecipe | UploadDestinationAutoMatch,
     serial_union_annotation(
     named_type_path="sdk.generic_upload.UploadDestination",
         discriminator="type",
@@ -101,6 +113,7 @@ UploadDestination = typing.Annotated[
             "project": UploadDestinationProject,
             "material_family": UploadDestinationMaterialFamily,
             "recipe": UploadDestinationRecipe,
+            "auto_match": UploadDestinationAutoMatch,
         },
     ),
 ]