UncountablePythonSDK 0.0.163__py3-none-any.whl → 0.0.166__py3-none-any.whl

examples/integration-server/pyproject.toml

@@ -9,7 +9,7 @@ dependencies = [
   "ruff == 0.*",
   "openpyxl == 3.*",
   "more_itertools == 10.*",
-  "types-paramiko ==4.0.0.20250822",
+  "types-paramiko ==4.0.0.20260322",
   "types-openpyxl == 3.*",
   "types-pysftp == 0.*",
   "types-pytz ==2026.*",

pkgs/argument_parser/__init__.py

@@ -11,6 +11,7 @@ from .argument_parser import is_union as is_union
 from .case_convert import camel_to_snake_case as camel_to_snake_case
 from .case_convert import kebab_to_pascal_case as kebab_to_pascal_case
 from .case_convert import snake_to_camel_case as snake_to_camel_case
+from .parser_error import ParserEnumError as ParserEnumError
 from .parser_error import ParserError as ParserError
 from .parser_error import ParserExtraFieldsError as ParserExtraFieldsError
 from .parser_error import ParserTypeError as ParserTypeError

pkgs/argument_parser/argument_parser.py

@@ -26,7 +26,12 @@ from pkgs.serialization import (
 from ._is_enum import is_string_enum_class
 from ._is_namedtuple import is_namedtuple_type
 from .case_convert import camel_to_snake_case, snake_to_camel_case
-from .parser_error import ParserError, ParserExtraFieldsError, ParserTypeError
+from .parser_error import (
+    ParserEnumError,
+    ParserError,
+    ParserExtraFieldsError,
+    ParserTypeError,
+)
 
 T = typing.TypeVar("T")
 ParserFunction = typing.Callable[[typing.Any], T]
@@ -500,9 +505,24 @@ def _build_parser_inner(
 
         return parse_as_numeric_type
 
-    if parsed_type in (dict, bool) or is_string_enum_class(parsed_type):
+    if parsed_type in (dict, bool):
         return lambda value: parsed_type(value)  # type: ignore
 
+    if is_string_enum_class(parsed_type):
+        assert issubclass(parsed_type, Enum)
+        enum_values: set[str] = set(member.value for member in parsed_type)
+
+        def parse_enum(value: typing.Any) -> T:
+            if not isinstance(value, str) or value not in enum_values:
+                raise ParserEnumError(
+                    value=value,
+                    enum_type=parsed_type,
+                    valid_values=enum_values,
+                )
+            return parsed_type(value)
+
+        return parse_enum
+
     if parsed_type is MissingSentryType:
 
         def error(value: typing.Any) -> T:

pkgs/argument_parser/parser_error.py

@@ -1,8 +1,25 @@
 from __future__ import annotations
 
+import reprlib
 import typing
 
 _UNSET = object()
+_VALUE_REPR_MAX_LENGTH = 120
+
+
+def _format_value(value: object) -> str:
+    value_repr = reprlib.Repr(
+        maxstring=_VALUE_REPR_MAX_LENGTH, maxother=_VALUE_REPR_MAX_LENGTH
+    ).repr(value)
+    if len(value_repr) <= _VALUE_REPR_MAX_LENGTH:
+        return value_repr
+    return f"{value_repr[: _VALUE_REPR_MAX_LENGTH - 3]}..."
+
+
+def _format_message(message: str, value: object) -> str:
+    if value is _UNSET:
+        return message
+    return f"{message} (value: {_format_value(value)})"
 
 
 class ParserError(ValueError):
@@ -22,6 +39,9 @@ class ParserError(ValueError):
         self.field_name = field_name
         super().__init__(message)
 
+    def __str__(self) -> str:
+        return _format_message(self.error_message, self.value)
+
     def error_chain(self) -> list[ParserError]:
         errors: list[ParserError] = []
         current: BaseException | None = self
@@ -35,14 +55,14 @@ class ParserError(ValueError):
         current: BaseException | None = self
         while current is not None:
             if isinstance(current, ParserError):
-                messages.append(current.error_message)
+                messages.append(_format_message(current.error_message, current.value))
                 current = current.__cause__
             else:
                 messages.append(str(current))
                 break
 
         if len(messages) <= 1:
-            return self.error_message
+            return _format_message(self.error_message, self.value)
 
         return " → ".join(messages)
 
@@ -57,4 +77,19 @@ class ParserExtraFieldsError(ParserError):
         )
 
 
+class ParserEnumError(ParserError):
+    valid_values: set[str]
+
+    def __init__(
+        self,
+        *,
+        value: object,
+        enum_type: type,
+        valid_values: set[str],
+    ) -> None:
+        self.valid_values = valid_values
+        message = f"'{value}' is not a valid string enum of type {enum_type.__name__}."
+        super().__init__(message, value=value, expected_type=enum_type)
+
+
 class ParserTypeError(ParserError): ...

pkgs/serialization_util/__init__.py

@@ -3,12 +3,14 @@ from .dataclasses import dict_fields as dict_fields
 from .dataclasses import iterate_fields as iterate_fields
 from .serialization_helpers import (
     JsonValue,
+    convert_decimals_to_strings,
     serialize_for_api,
     serialize_for_storage,
     serialize_for_storage_dict,
 )
 
 __all__: list[str] = [
+    "convert_decimals_to_strings",
     "convert_dict_to_snake_case",
     "serialize_for_api",
     "serialize_for_storage",

pkgs/serialization_util/serialization_helpers.py

@@ -14,6 +14,7 @@ from typing import (
     Protocol,
     TypeVar,
     Union,
+    assert_never,
     overload,
 )
 
@@ -37,6 +38,30 @@ else:
 T = TypeVar("T")
 
 
+# IMPROVE: this match should be exhaustive over JsonValue, but mypy can't verify
+# that Mapping()/Sequence() fully narrow the TYPE_CHECKING definition of JsonValue.
+def convert_decimals_to_strings(obj: JsonValue) -> JsonValue:
+    match obj:
+        case Decimal():
+            return str(obj)
+        case (
+            str()
+            | int()
+            | float()
+            | bool()
+            | None
+            | datetime.datetime()
+            | datetime.date()
+        ):
+            return obj
+        case Mapping():
+            return {k: convert_decimals_to_strings(v) for k, v in obj.items()}
+        case Sequence():
+            return [convert_decimals_to_strings(v) for v in obj]
+        case _ as unreachable:
+            assert_never(unreachable)
+
+
 class Dataclass(Protocol):
     __dataclass_fields__: ClassVar[dict]  # type: ignore[type-arg,unused-ignore]
 

pkgs/type_spec/type_info/emit_type_info.py

@@ -144,11 +144,10 @@ def asdict_for_yaml_dump(dataclass_instance: Any) -> Any:
 def emit_type_info_python(build: builder.SpecBuilder, output: str) -> None:
     type_map = _build_map_all(build, python=True)
 
-    stripped = _dict_null_strip(asdict_for_yaml_dump(type_map))
-    serialized = serialize_for_storage(stripped)
-
-    yaml_content = yaml.dump(serialized, default_flow_style=False, sort_keys=True)
-    util.rewrite_file(f"{output}/type_map.yaml", yaml_content)
+    for namespace, data in type_map.namespaces.items():
+        serial = serialize_for_storage(asdict_for_yaml_dump(data))
+        yaml_content = yaml.dump(serial, default_flow_style=False, sort_keys=True)
+        util.rewrite_file(f"{output}/namespace_{namespace}.yaml", yaml_content)
 
 
 @dataclasses.dataclass

uncountable/core/client.py

@@ -24,13 +24,12 @@ from uncountable.types import download_file_t
 from uncountable.types.client_base import APIRequest, ClientMethods
 from uncountable.types.client_config import ClientConfigOptions
 from uncountable.types.client_config_t import RequestContext
+from uncountable.types.request_headers_t import InternalRequestHeaders, VersionHeaders
 
 from .file_upload import FileUpload, FileUploader, UploadedFile
 from .types import AuthDetailsAll, AuthDetailsApiKey, AuthDetailsOAuth
 
 DT = typing.TypeVar("DT")
-UNC_REQUEST_ID_HEADER = "X-UNC-REQUEST-ID"
-UNC_SDK_VERSION_HEADER = "X-UNC-SDK-VERSION"
 
 
 class EndpointMethod(StrEnum):
@@ -328,8 +327,8 @@ class Client(ClientMethods):
         self, *, api_request: APIRequest, request_id: str
     ) -> HTTPRequest:
         headers = self._build_auth_headers()
-        headers[UNC_REQUEST_ID_HEADER] = request_id
-        headers[UNC_SDK_VERSION_HEADER] = get_version()
+        headers[InternalRequestHeaders.REQUEST_ID] = request_id
+        headers[VersionHeaders.UNC_SDK_VERSION] = get_version()
         if self._cfg.request_context is not None:
             if self._cfg.request_context.user_locale is not None:
                 headers["X-User-Locale"] = self._cfg.request_context.user_locale

uncountable/integration/construct_client.py

@@ -30,34 +30,28 @@ def _construct_auth_details(profile_meta: ProfileMetadata) -> AuthDetailsAll:
             return AuthDetailsApiKey(api_id=api_id, api_secret_key=api_key)
 
 
-def _construct_client_config(
-    *,
-    profile_meta: ProfileMetadata,
-    job_logger: JobLogger,
-    request_context: RequestContext | None = None,
-) -> ClientConfig:
-    if profile_meta.client_options is None:
-        return ClientConfig(logger=job_logger, request_context=request_context)
-    return ClientConfig(
-        allow_insecure_tls=profile_meta.client_options.allow_insecure_tls,
-        extra_headers=profile_meta.client_options.extra_headers,
-        logger=job_logger,
-        request_context=request_context,
-    )
-
-
 def construct_uncountable_client(
     profile_meta: ProfileMetadata,
     logger: JobLogger,
     *,
     request_context: RequestContext | None = None,
+    headers: dict[str, str] | None = None,
 ) -> Client:
+    extra_headers = {}
+    allow_insecure_tls = False
+    if profile_meta.client_options is not None:
+        extra_headers.update(profile_meta.client_options.extra_headers or {})
+        allow_insecure_tls = profile_meta.client_options.allow_insecure_tls
+
+    extra_headers.update(headers or {})
+
     return Client(
         base_url=profile_meta.base_url,
         auth_details=_construct_auth_details(profile_meta),
-        config=_construct_client_config(
-            profile_meta=profile_meta,
-            job_logger=logger,
+        config=ClientConfig(
+            allow_insecure_tls=allow_insecure_tls,
+            extra_headers=extra_headers,
+            logger=logger,
             request_context=request_context,
         ),
         app_base_url=profile_meta.app_base_url,

uncountable/integration/queue_runner/worker.py

@@ -1,4 +1,6 @@
 import asyncio
+import logging
+import pathlib
 import sys
 import typing
 from concurrent.futures import ProcessPoolExecutor
@@ -23,7 +25,13 @@ from uncountable.integration.queue_runner.datastore.interface import Datastore
 from uncountable.integration.queue_runner.types import ListenQueue, ResultQueue
 from uncountable.integration.scan_profiles import load_profiles
 from uncountable.integration.telemetry import JobLogger, Logger, get_otel_tracer
-from uncountable.types import base_t, client_config_t, job_definition_t, queued_job_t
+from uncountable.types import (
+    base_t,
+    client_config_t,
+    job_definition_t,
+    queued_job_t,
+    request_headers_t,
+)
 
 
 class Worker:
@@ -99,14 +107,48 @@ def _resolve_queued_job_request_context(
             return None
 
 
+_CGROUP_V2_MEMORY_MAX = pathlib.Path("/sys/fs/cgroup/memory.max")
+_CGROUP_V1_MEMORY_LIMIT = pathlib.Path("/sys/fs/cgroup/memory/memory.limit_in_bytes")
+
+_MEMORY_LIMIT_FRACTION_CGROUP = 0.75
+_MEMORY_LIMIT_FRACTION_HOST = 0.9
+
+_logger = logging.getLogger(__name__)
+
+
+def _get_cgroup_memory_limit_bytes() -> int | None:
+    for cgroup_path in (_CGROUP_V2_MEMORY_MAX, _CGROUP_V1_MEMORY_LIMIT):
+        if not cgroup_path.exists():
+            continue
+        raw = cgroup_path.read_text().strip()
+        if raw == "max":
+            # cgroups v2 "max" means no limit is set
+            return None
+        value = int(raw)
+        # cgroups v1 uses a very large sentinel for "no limit"
+        if value >= 2**63 - 1:
+            return None
+        return value
+    return None
+
+
 def run_queued_job(
     queued_job: queued_job_t.QueuedJob,
 ) -> job_definition_t.JobResult:
     with get_otel_tracer().start_as_current_span(name="run_queued_job") as span:
         if resource is not None:
-            total_mem = psutil.virtual_memory().total
-            limit_bytes = int(total_mem * 0.9)
+            cgroup_limit = _get_cgroup_memory_limit_bytes()
+            if cgroup_limit is not None:
+                limit_bytes = int(cgroup_limit * _MEMORY_LIMIT_FRACTION_CGROUP)
+            else:
+                total_mem = psutil.virtual_memory().total
+                limit_bytes = int(total_mem * _MEMORY_LIMIT_FRACTION_HOST)
             resource.setrlimit(resource.RLIMIT_AS, (limit_bytes, limit_bytes))
+            _logger.info(
+                "RLIMIT_AS set to %.2f GiB (source: %s)",
+                limit_bytes / (1024**3),
+                "cgroup" if cgroup_limit is not None else "host",
+            )
 
         job_details = get_registered_job_details(queued_job.job_ref_name)
         job_logger = JobLogger(
@@ -123,6 +165,11 @@ def run_queued_job(
                     profile_meta=job_details.profile_metadata,
                     logger=job_logger,
                     request_context=request_context,
+                    headers={
+                        request_headers_t.IntegrationServerHeaders.JOB_UUID: queued_job.queued_job_uuid,
+                        request_headers_t.IntegrationServerHeaders.JOB_ID: job_details.job_definition.id,
+                        request_headers_t.IntegrationServerHeaders.JOB_NAME: job_details.job_definition.name,
+                    },
                 )
                 batch_processor = AsyncBatchProcessor(client=client)
 

uncountable/integration/telemetry.py

@@ -220,9 +220,15 @@ class Logger:
 
 
 class PerJobResourceTracker:
-    def __init__(self, logger: "JobLogger", sample_interval: float = 0.5) -> None:
+    def __init__(
+        self,
+        logger: "JobLogger",
+        sample_interval: float = 0.5,
+        log_interval: float = 30.0,
+    ) -> None:
         self.logger = logger
         self.sample_interval = sample_interval
+        self.log_interval = log_interval
         self._process = psutil.Process(os.getpid())
         self._stop_event = threading.Event()
         self._thread: threading.Thread | None = None
@@ -233,15 +239,40 @@ class PerJobResourceTracker:
         self.start_wall_time: float | None = None
         self.end_wall_time: float | None = None
 
+    def _current_stats(self) -> Attributes:
+        assert self.start_cpu_times is not None
+        assert self.start_wall_time is not None
+        current_cpu_times = self._process.cpu_times()
+        cpu_user = current_cpu_times.user - self.start_cpu_times.user
+        cpu_sys = current_cpu_times.system - self.start_cpu_times.system
+        cpu_total = cpu_user + cpu_sys
+        elapsed = time.monotonic() - self.start_wall_time
+        return {
+            "cpu_user_s": round(cpu_user, 3),
+            "cpu_system_s": round(cpu_sys, 3),
+            "cpu_total_s": round(cpu_total, 3),
+            "wall_time_s": round(elapsed, 3),
+            "current_rss_mb": round(self._process.memory_info().rss / (1024 * 1024), 2),
+            "peak_rss_mb": round(self.max_rss / (1024 * 1024), 2),
+        }
+
     def start(self) -> None:
         self.start_cpu_times = self._process.cpu_times()
         self.start_wall_time = time.monotonic()
 
         def _monitor() -> None:
+            last_log_time = time.monotonic()
             try:
                 while not self._stop_event.is_set():
                     rss = self._process.memory_info().rss
                     self.max_rss = max(self.max_rss, rss)
+                    now = time.monotonic()
+                    if now - last_log_time >= self.log_interval:
+                        self.logger.log_info(
+                            "Job resource usage (periodic)",
+                            attributes=self._current_stats(),
+                        )
+                        last_log_time = now
                     time.sleep(self.sample_interval)
             except Exception:
                 self._stop_event.set()

uncountable/integration/webhook_server/entrypoint.py

@@ -24,8 +24,22 @@ def register_route(
     job: job_definition_t.HttpJobDefinitionBase,
 ) -> None:
     route = f"/{profile_meta.name}/{job.id}"
+    log_attributes = {
+        "profile.name": profile_meta.name,
+        "profile.base_url": profile_meta.base_url,
+        "job.name": job.name,
+        "job.id": job.id,
+        "http.route": route,
+    }
 
     def handle_request() -> ResponseReturnValue:
+        method = flask.request.method
+        url = flask.request.url
+        request_attributes = {
+            **log_attributes,
+            "http.method": method,
+            "http.url": url,
+        }
         with server_logger.push_scope(route):
             try:
                 if not isinstance(job.executor, job_definition_t.JobExecutorScript):
@@ -56,10 +70,18 @@ def register_route(
                     http_response.headers,
                 )
             except HttpException as e:
-                server_logger.log_exception(e)
+                server_logger.log_exception(
+                    e,
+                    message=f"HTTP error on {method} {url}",
+                    attributes=request_attributes,
+                )
                 return e.make_error_response()
             except Exception as e:
-                server_logger.log_exception(e)
+                server_logger.log_exception(
+                    e,
+                    message=f"Unexpected error on {method} {url}",
+                    attributes=request_attributes,
+                )
                 return HttpException.unknown_error().make_error_response()
 
     app.add_url_rule(
@@ -69,7 +91,9 @@ def register_route(
         methods=["POST"],
     )
 
-    server_logger.log_info(f"job {job.id} webhook registered at: {route}")
+    server_logger.log_info(
+        f"job {job.id} webhook registered at: {route}", attributes=log_attributes
+    )
 
 
 def main() -> None:

uncountable/types/__init__.py

@@ -108,6 +108,7 @@ from . import recipes_t as recipes_t
 from .api.integrations import register_sockets_token as register_sockets_token_t
 from .api.recipes import remove_recipe_from_project as remove_recipe_from_project_t
 from .api.recipe_links import remove_recipe_link as remove_recipe_link_t
+from . import request_headers_t as request_headers_t
 from .api.entity import resolve_entity_ids as resolve_entity_ids_t
 from .api.outputs import resolve_output_conditions as resolve_output_conditions_t
 from . import response_t as response_t
@@ -134,6 +135,7 @@ from .api.entity import set_values as set_values_t
 from . import sockets_t as sockets_t
 from . import specs_t as specs_t
 from . import step_relationships_t as step_relationships_t
+from .api.output_parameters import swap_output_condition_parameters as swap_output_condition_parameters_t
 from .api.entity import transition_entity_phase as transition_entity_phase_t
 from .api.recipes import unarchive_recipes as unarchive_recipes_t
 from . import units_t as units_t
@@ -258,6 +260,7 @@ __all__: list[str] = [
     "register_sockets_token_t",
     "remove_recipe_from_project_t",
     "remove_recipe_link_t",
+    "request_headers_t",
     "resolve_entity_ids_t",
     "resolve_output_conditions_t",
     "response_t",
@@ -284,6 +287,7 @@ __all__: list[str] = [
     "sockets_t",
     "specs_t",
     "step_relationships_t",
+    "swap_output_condition_parameters_t",
     "transition_entity_phase_t",
     "unarchive_recipes_t",
     "units_t",

uncountable/types/api/output_parameters/__init__.py

@@ -0,0 +1 @@
+# DO NOT MODIFY -- This file is generated by type_spec

uncountable/types/api/output_parameters/swap_output_condition_parameters.py

@@ -0,0 +1,150 @@
+# DO NOT MODIFY -- This file is generated by type_spec
+# 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 enum import StrEnum
+import dataclasses
+from pkgs.serialization import serial_class
+from pkgs.serialization import serial_union_annotation
+from ... import async_batch_t
+from ... import base_t
+from ... import identifier_t
+
+__all__: list[str] = [
+    "AllInProjectSwapScope",
+    "Arguments",
+    "ConditionParameterDefinition",
+    "Data",
+    "ENDPOINT_METHOD",
+    "ENDPOINT_PATH",
+    "NewOutputCondition",
+    "NewOutputConditionExisting",
+    "NewOutputConditionFromDefinition",
+    "NewOutputConditionType",
+    "SwapScope",
+    "SwapScopeType",
+    "TargetedSwapScope",
+]
+
+ENDPOINT_METHOD = "POST"
+ENDPOINT_PATH = "api/external/output_parameters/swap_output_condition_parameters"
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.output_parameters.swap_output_condition_parameters.ConditionParameterDefinition",
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class ConditionParameterDefinition:
+    condition_parameter_key: identifier_t.IdentifierKey
+    value_numeric: Decimal | None = None
+    value_text: str | None = None
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+class NewOutputConditionType(StrEnum):
+    EXISTING = "existing"
+    DEFINITION = "definition"
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.output_parameters.swap_output_condition_parameters.NewOutputConditionExisting",
+    parse_require={"type"},
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class NewOutputConditionExisting:
+    type: typing.Literal[NewOutputConditionType.EXISTING] = NewOutputConditionType.EXISTING
+    condition_key: identifier_t.IdentifierKey
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.output_parameters.swap_output_condition_parameters.NewOutputConditionFromDefinition",
+    parse_require={"type"},
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class NewOutputConditionFromDefinition:
+    type: typing.Literal[NewOutputConditionType.DEFINITION] = NewOutputConditionType.DEFINITION
+    parameters: list[ConditionParameterDefinition]
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+NewOutputCondition = typing.Annotated[
+    NewOutputConditionExisting | NewOutputConditionFromDefinition,
+    serial_union_annotation(
+    named_type_path="sdk.api.output_parameters.swap_output_condition_parameters.NewOutputCondition",
+        discriminator="type",
+        discriminator_map={
+            "existing": NewOutputConditionExisting,
+            "definition": NewOutputConditionFromDefinition,
+        },
+    ),
+]
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+class SwapScopeType(StrEnum):
+    TARGETED = "targeted"
+    ALL_IN_PROJECT = "all_in_project"
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.output_parameters.swap_output_condition_parameters.TargetedSwapScope",
+    parse_require={"type"},
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class TargetedSwapScope:
+    type: typing.Literal[SwapScopeType.TARGETED] = SwapScopeType.TARGETED
+    recipe_keys: list[identifier_t.IdentifierKey]
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.output_parameters.swap_output_condition_parameters.AllInProjectSwapScope",
+    parse_require={"type"},
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class AllInProjectSwapScope:
+    type: typing.Literal[SwapScopeType.ALL_IN_PROJECT] = SwapScopeType.ALL_IN_PROJECT
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+SwapScope = typing.Annotated[
+    TargetedSwapScope | AllInProjectSwapScope,
+    serial_union_annotation(
+    named_type_path="sdk.api.output_parameters.swap_output_condition_parameters.SwapScope",
+        discriminator="type",
+        discriminator_map={
+            "targeted": TargetedSwapScope,
+            "all_in_project": AllInProjectSwapScope,
+        },
+    ),
+]
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.output_parameters.swap_output_condition_parameters.Arguments",
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class Arguments:
+    scope: SwapScope
+    output_key: identifier_t.IdentifierKey
+    new_condition: NewOutputCondition
+    old_condition_key: identifier_t.IdentifierKey | None = None
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.output_parameters.swap_output_condition_parameters.Data",
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class Data(async_batch_t.AsyncBatchActionReturn):
+    pass
+# DO NOT MODIFY -- This file is generated by type_spec