UncountablePythonSDK 0.0.164__tar.gz → 0.0.167__tar.gz

{uncountablepythonsdk-0.0.164 → uncountablepythonsdk-0.0.167}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UncountablePythonSDK
-Version: 0.0.164
+Version: 0.0.167
 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.164 → uncountablepythonsdk-0.0.167}/UncountablePythonSDK.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UncountablePythonSDK
-Version: 0.0.164
+Version: 0.0.167
 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.164 → uncountablepythonsdk-0.0.167}/UncountablePythonSDK.egg-info/SOURCES.txt

@@ -345,6 +345,8 @@ uncountable/types/api/material_families/update_entity_material_families.py
 uncountable/types/api/notebooks/__init__.py
 uncountable/types/api/notebooks/add_notebook_content.py
 uncountable/types/api/notebooks/get_notebook_content.py
+uncountable/types/api/output_parameters/__init__.py
+uncountable/types/api/output_parameters/swap_output_condition_parameters.py
 uncountable/types/api/outputs/__init__.py
 uncountable/types/api/outputs/get_output_data.py
 uncountable/types/api/outputs/get_output_names.py

{uncountablepythonsdk-0.0.164 → uncountablepythonsdk-0.0.167}/pkgs/argument_parser/argument_parser.py

@@ -426,9 +426,11 @@ def _build_parser_inner(
             return inner
 
         v_parser = _build_parser_inner(args[1], context, type_var_map)
-        return lambda value: origin(
-            (key_parser(k), v_parser(v)) for k, v in value.items()
-        )
+
+        def parse_dict(value: typing.Any) -> typing.Any:
+            return origin((key_parser(k), v_parser(v)) for k, v in value.items())
+
+        return parse_dict
 
     if origin == typing.Literal:
         valid_values: set[T] = set(typing.get_args(parsed_type))

{uncountablepythonsdk-0.0.164 → uncountablepythonsdk-0.0.167}/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",

{uncountablepythonsdk-0.0.164 → uncountablepythonsdk-0.0.167}/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]
 

{uncountablepythonsdk-0.0.164 → uncountablepythonsdk-0.0.167}/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

{uncountablepythonsdk-0.0.164 → uncountablepythonsdk-0.0.167}/uncountable/core/client.py

@@ -264,7 +264,7 @@ class Client(ClientMethods):
         }
         with push_scope_optional(self._cfg.logger, "api_call", attributes=attributes):
             if self._cfg.logger is not None:
-                self._cfg.logger.log_info(api_request.endpoint, attributes=attributes)
+                self._cfg.logger.log_debug(api_request.endpoint, attributes=attributes)
             timeout = (
                 api_request.request_options.timeout_secs
                 if api_request.request_options is not None

{uncountablepythonsdk-0.0.164 → uncountablepythonsdk-0.0.167}/uncountable/core/file_upload.py

@@ -142,7 +142,7 @@ class FileUploader:
                 self._logger, "upload_file", attributes=attributes
             ):
                 if self._logger is not None:
-                    self._logger.log_info("Uploading file", attributes=attributes)
+                    self._logger.log_debug("Uploading file", attributes=attributes)
                 with file_upload_data(file_upload) as file_bytes:
                     if file_bytes.bytes_data.read(1) == b"":
                         raise UploadFailed(

{uncountablepythonsdk-0.0.164 → uncountablepythonsdk-0.0.167}/uncountable/core/query/builder.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
 
 import json
-import time
 from copy import copy
 from dataclasses import make_dataclass
 from decimal import Decimal
-from typing import Self
+from typing import Callable, Self
 
 from pkgs.argument_parser import CachedParser
 from pkgs.serialization.serial_class import serial_class
@@ -29,8 +28,7 @@ from uncountable.types import (
 from uncountable.types.api.entity import list_entities as list_entities_t
 from uncountable.types.api.files.download_file import FileDownloadQueryEntityField
 
-_ASYNC_EXPORT_TIMEOUT_SECONDS = 60 * 10
-_ASYNC_EXPORT_POLL_INTERVAL_SECONDS = 1
+_FETCH_ROW_LIMIT = 100
 
 
 class _AsyncExportJob(QueryRow):
@@ -99,7 +97,9 @@ class QueryBuilder[QueryRowT: QueryRow]:
         )
         return branch
 
-    def _fetch(self, limit: int = 100, offset: int = 0) -> list[QueryRowT]:
+    def _fetch(self, limit: int, offset: int = 0) -> list[QueryRowT]:
+        if limit > _FETCH_ROW_LIMIT:
+            raise ValueError(f"Fetch row limit cannot exceed {_FETCH_ROW_LIMIT}")
         rows = self._client.fetch_listing(
             entity_type=self._base_type,
             columns=list(self._column_identifiers),
@@ -107,7 +107,6 @@ class QueryBuilder[QueryRowT: QueryRow]:
             limit=limit,
             offset=offset,
         ).results
-
         return [self._parse_row(row.column_values) for row in rows]
 
     def _hook_after_parse_row(self, row: QueryRowT) -> None:
@@ -124,13 +123,13 @@ class QueryBuilder[QueryRowT: QueryRow]:
         return parsed_model
 
     def one(self) -> QueryRowT:
-        results = self._fetch()
+        results = self._fetch(limit=2)
         if len(results) != 1:
             raise ValueError(f"Expected one result, received {len(results)}")
         return results[0]
 
     def one_or_none(self) -> QueryRowT | None:
-        results = self._fetch()
+        results = self._fetch(limit=2)
         if len(results) > 1:
             raise ValueError(f"Expected one result, received {len(results)}")
         if len(results) == 0:
@@ -142,59 +141,74 @@ class QueryBuilder[QueryRowT: QueryRow]:
         return None if len(results) == 0 else results[0]
 
     def all(self) -> list[QueryRowT]:
-        results = self._fetch()
-        if len(results) < 100:
+        results = self._fetch(limit=_FETCH_ROW_LIMIT)
+        if len(results) < _FETCH_ROW_LIMIT:
             return results
-        return self._await_async_export()
 
-    def _await_async_export(self) -> list[QueryRowT]:
+        # Generate an async listing export if the number of results >= 100
+        poll_for_async_export_results = self._submit_async_export()
+
+        # Resolve exponentially increasing pagination batches until all rows are fetched or the async job completes
+        iteration_count: int = 0
+        while True:
+            for _ in range(2**iteration_count):
+                rows = self._fetch(limit=_FETCH_ROW_LIMIT, offset=len(results))
+                results.extend(rows)
+                if len(rows) < _FETCH_ROW_LIMIT:
+                    return results
+
+            if export_results := poll_for_async_export_results():
+                return export_results
+            iteration_count += 1
+
+    def _submit_async_export(self) -> Callable[[], list[QueryRowT] | None]:
+        """
+        Requests an async export of the query results. Returns a closure for polling the results of the export.
+        """
         async_job_entity = self._client.export_listing(
             entity_type=self._base_type,
             columns=list(self._column_identifiers),
             filters=listing_t.FilterNodeColumnAnd(filters=tuple(self._filters)),
         ).entity
         if async_job_entity is None:
-            raise ValueError("Listing export failed to create async job")
-
-        status_query = QueryBuilder(client=self._client, model=_AsyncExportJob)
-
-        start_time = time.time()
-        while time.time() - start_time < _ASYNC_EXPORT_TIMEOUT_SECONDS:
-            match (
-                status_query
+            raise ValueError("async listing export generation failed")
+        async_job_status: async_jobs_t.AsyncJobStatus | str | None = None
+
+        def poll_for_results() -> list[QueryRowT] | None:
+            nonlocal async_job_status
+            if async_job_status == async_jobs_t.AsyncJobStatus.ERROR:
+                return None
+            async_job_status = (
+                QueryBuilder(client=self._client, model=_AsyncExportJob)
                 .filter(_AsyncExportJob.id == async_job_entity.id)
                 .one()
                 .status
-            ):
-                case async_jobs_t.AsyncJobStatus.COMPLETED:
-                    export_file = self._client.download_files(
-                        file_query=FileDownloadQueryEntityField(
-                            entity=entity_t.EntityIdentifier(
-                                identifier_key=identifier_t.IdentifierKeyId(
-                                    id=async_job_entity.id
-                                ),
-                                type=entity_t.EntityType.ASYNC_JOB,
-                            ),
-                            field_key=identifier_t.IdentifierKeyRefName(
-                                ref_name="unc_async_listing_export_file"
+            )
+            if async_job_status == async_jobs_t.AsyncJobStatus.COMPLETED:
+                export_file = self._client.download_files(
+                    file_query=FileDownloadQueryEntityField(
+                        entity=entity_t.EntityIdentifier(
+                            identifier_key=identifier_t.IdentifierKeyId(
+                                id=async_job_entity.id
                             ),
+                            type=entity_t.EntityType.ASYNC_JOB,
+                        ),
+                        field_key=identifier_t.IdentifierKeyRefName(
+                            ref_name="unc_async_listing_export_file"
+                        ),
+                    )
+                )[0].data.read()
+                return [
+                    self._parse_row(row.column_values)
+                    for row in CachedParser(list_entities_t.Data)
+                    .parse_api(
+                        json.loads(
+                            export_file,
+                            parse_float=Decimal,
                         )
-                    )[0].data.read()
-
-                    return [
-                        self._parse_row(row.column_values)
-                        for row in CachedParser(list_entities_t.Data)
-                        .parse_api(
-                            json.loads(
-                                export_file,
-                                parse_float=Decimal,
-                            )
-                        )
-                        .results
-                    ]
-                case async_jobs_t.AsyncJobStatus.ERROR:
-                    raise ValueError("Listing export failed")
-            time.sleep(_ASYNC_EXPORT_POLL_INTERVAL_SECONDS)
-        raise TimeoutError(
-            f"Async listing export timed out after {_ASYNC_EXPORT_TIMEOUT_SECONDS} seconds"
-        )
+                    )
+                    .results
+                ]
+            return None
+
+        return poll_for_results

{uncountablepythonsdk-0.0.164 → uncountablepythonsdk-0.0.167}/uncountable/integration/executors/executors.py

@@ -93,7 +93,7 @@ def execute_job(
         job = resolve_executor(job_definition.executor, profile_metadata)
         job_location = f"{job.__class__.__module__}.{job.__class__.__name__}"
 
-        job_logger.log_info(f"Starting job: `{job_location}`")
+        job_logger.log_debug(f"Starting job: `{job_location}`")
 
         run_entity: entity_t.Entity | None = None
         try:
@@ -115,7 +115,7 @@ def execute_job(
             result = job_definition_t.JobResult(success=False)
 
         submitted_batch_job_ids = args.batch_processor.get_submitted_job_ids()
-        job_logger.log_info(
+        job_logger.log_debug(
             f"Completed job: `{job_location}` (success={result.success})",
             attributes={
                 "submitted_batch_job_ids": submitted_batch_job_ids,

{uncountablepythonsdk-0.0.164 → uncountablepythonsdk-0.0.167}/uncountable/integration/queue_runner/job_scheduler.py

@@ -136,7 +136,7 @@ async def start_scheduler(
                 job_payload=payload,
                 job_ref_name=job_ref_name,
             )
-            logger.log_info(
+            logger.log_debug(
                 "Job submitted successfully.",
                 attributes={"job.queued_job_uuid": queued_job.queued_job_uuid},
             )
@@ -168,7 +168,7 @@ async def start_scheduler(
                     )
                 )
 
-                logger.log_info(
+                logger.log_debug(
                     "Job cancelled successfully.",
                     attributes={"job.queued_job_uuid": command.queued_job_uuid},
                 )
@@ -201,10 +201,10 @@ async def start_scheduler(
         def _handle_vaccuum_queued_jobs_command(
             command: CommandVaccuumQueuedJobs,
         ) -> None:
-            logger.log_info("Vaccuuming queued jobs...")
+            logger.log_debug("Vaccuuming queued jobs...")
             deleted_uuids = datastore.vaccuum_queued_jobs()
 
-            logger.log_info(
+            logger.log_debug(
                 "Queued jobs vacuumed successfully.",
                 attributes={"job.queued_job_uuids": deleted_uuids},
             )

{uncountablepythonsdk-0.0.164 → uncountablepythonsdk-0.0.167}/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
@@ -105,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(

{uncountablepythonsdk-0.0.164 → uncountablepythonsdk-0.0.167}/uncountable/integration/scheduler.py

@@ -71,7 +71,7 @@ ProcessAlarm = ProcessAlarmRestart | ProcessAlarmShutdownAll
 
 
 def handle_shutdown(logger: Logger, processes: dict[ProcessName, ProcessInfo]) -> None:
-    logger.log_info("received shutdown command, shutting down sub-processes")
+    logger.log_debug("received shutdown command, shutting down sub-processes")
     for proc_info in processes.values():
         if proc_info.is_alive:
             proc_info.process.terminate()
@@ -83,7 +83,7 @@ def handle_shutdown(logger: Logger, processes: dict[ProcessName, ProcessInfo]) -
         and len(still_living_processes) > 0
     ):
         current_loop_processes = [*still_living_processes]
-        logger.log_info(
+        logger.log_debug(
             "waiting for sub-processes to shut down",
             attributes={
                 "still_living_processes": [
@@ -94,7 +94,7 @@ def handle_shutdown(logger: Logger, processes: dict[ProcessName, ProcessInfo]) -
         still_living_processes = []
         for proc_info in current_loop_processes:
             if not proc_info.is_alive:
-                logger.log_info(f"{proc_info.name} shut down successfully")
+                logger.log_debug(f"{proc_info.name} shut down successfully")
             else:
                 still_living_processes.append(proc_info)
         time.sleep(1)
@@ -121,7 +121,7 @@ def restart_process(
             processes[ProcessName.QUEUE_RUNNER] = new_info
             try:
                 _wait_queue_runner_online()
-                logger.log_info("queue runner restarted successfully")
+                logger.log_debug("queue runner restarted successfully")
             except Exception as e:
                 logger.log_exception(e)
                 logger.log_error(
@@ -135,13 +135,13 @@ def restart_process(
             cron_proc.start()
             new_info = ProcessInfo(name=ProcessName.CRON_SERVER, process=cron_proc)
             processes[ProcessName.CRON_SERVER] = new_info
-            logger.log_info("cron server restarted successfully")
+            logger.log_debug("cron server restarted successfully")
 
         case ProcessName.UWSGI:
             uwsgi_proc: AnyProcess = subprocess.Popen(["uwsgi", "--die-on-term"])
             new_info = ProcessInfo(name=ProcessName.UWSGI, process=uwsgi_proc)
             processes[ProcessName.UWSGI] = new_info
-            logger.log_info("uwsgi restarted successfully")
+            logger.log_debug("uwsgi restarted successfully")
 
 
 def check_process_alarms(
@@ -188,7 +188,7 @@ def main() -> None:
 
     def add_process(process: ProcessInfo) -> None:
         processes[process.name] = process
-        logger.log_info(f"started process {process.name}")
+        logger.log_debug(f"started process {process.name}")
 
     def _start_queue_runner() -> None:
         runner_process = multiprocessing.Process(target=start_queue_runner)

{uncountablepythonsdk-0.0.164 → uncountablepythonsdk-0.0.167}/uncountable/integration/telemetry.py

@@ -94,6 +94,7 @@ def get_otel_logger() -> OTELLogger:
 
 
 class LogSeverity(StrEnum):
+    DEBUG = "Debug"
     INFO = "Info"
     WARN = "Warn"
     ERROR = "Error"
@@ -102,6 +103,8 @@ class LogSeverity(StrEnum):
 def _get_severity_number(severity: LogSeverity) -> _logs.SeverityNumber:
     """Map LogSeverity to OpenTelemetry SeverityNumber for Datadog."""
     match severity:
+        case LogSeverity.DEBUG:
+            return _logs.SeverityNumber.DEBUG
         case LogSeverity.INFO:
             return _logs.SeverityNumber.INFO
         case LogSeverity.WARN:
@@ -172,6 +175,13 @@ class Logger:
     def bind(self, *, attributes: Attributes) -> None:
         self._bound_attributes.update(attributes)
 
+    def log_debug(self, message: str, *, attributes: Attributes | None = None) -> None:
+        self._emit_log(
+            message=message, severity=LogSeverity.DEBUG, attributes=attributes
+        )
+
+    # Use log_info for user-facing job logs (e.g. example_* and custom executor output).
+    # SDK-internal instrumentation should use log_debug instead.
     def log_info(self, message: str, *, attributes: Attributes | None = None) -> None:
         self._emit_log(
             message=message, severity=LogSeverity.INFO, attributes=attributes
@@ -220,9 +230,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 +249,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_debug(
+                            "Job resource usage (periodic)",
+                            attributes=self._current_stats(),
+                        )
+                        last_log_time = now
                     time.sleep(self.sample_interval)
             except Exception:
                 self._stop_event.set()
@@ -279,7 +320,7 @@ class PerJobResourceTracker:
                     ),
                 )
             return
-        self.logger.log_info("Job resource usage summary", attributes=stats)
+        self.logger.log_debug("Job resource usage summary", attributes=stats)
         return
 
     def summary(self) -> Attributes:

{uncountablepythonsdk-0.0.164 → uncountablepythonsdk-0.0.167}/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_debug(
+        f"job {job.id} webhook registered at: {route}", attributes=log_attributes
+    )
 
 
 def main() -> None:

{uncountablepythonsdk-0.0.164 → uncountablepythonsdk-0.0.167}/uncountable/types/__init__.py

@@ -135,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
@@ -286,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",