UncountablePythonSDK 0.0.166__tar.gz → 0.0.167__tar.gz

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UncountablePythonSDK
-Version: 0.0.166
+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.166 → 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.166 → 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.166 → 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.166 → 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.166 → 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.166 → 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.166 → 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.166 → 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
@@ -268,7 +278,7 @@ class PerJobResourceTracker:
                     self.max_rss = max(self.max_rss, rss)
                     now = time.monotonic()
                     if now - last_log_time >= self.log_interval:
-                        self.logger.log_info(
+                        self.logger.log_debug(
                             "Job resource usage (periodic)",
                             attributes=self._current_stats(),
                         )
@@ -310,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.166 → uncountablepythonsdk-0.0.167}/uncountable/integration/webhook_server/entrypoint.py

@@ -91,7 +91,7 @@ def register_route(
         methods=["POST"],
     )
 
-    server_logger.log_info(
+    server_logger.log_debug(
         f"job {job.id} webhook registered at: {route}", attributes=log_attributes
     )