UncountablePythonSDK 0.0.128__py3-none-any.whl → 0.0.129__py3-none-any.whl

examples/integration-server/jobs/materials_auto/example_instrument.py

@@ -3,8 +3,6 @@ import time
 from dataclasses import dataclass
 from decimal import Decimal
 
-from pkgs.argument_parser.argument_parser import CachedParser
-from pkgs.serialization_util import serialize_for_api
 from uncountable.integration.job import JobArguments, WebhookJob, register_job
 from uncountable.types import (
     base_t,
@@ -16,6 +14,9 @@ from uncountable.types.integration_session_t import IntegrationSessionInstrument
 from websockets.sync.client import connect
 from websockets.typing import Data
 
+from pkgs.argument_parser.argument_parser import CachedParser
+from pkgs.serialization_util import serialize_for_api
+
 
 @dataclass(kw_only=True)
 class InstrumentPayload:
@@ -34,7 +35,7 @@ class InstrumentExample(WebhookJob[InstrumentPayload]):
         def parse_message(message: Data) -> sockets_t.SocketEventData | None:
             try:
                 return parser.parse_api(json.loads(message)).data
-            except ValueError as e:
+            except ValueError:
                 return None
 
         integration_session = IntegrationSessionInstrument(

examples/integration-server/jobs/materials_auto/example_parse.py

@@ -1,11 +1,14 @@
 from dataclasses import dataclass
+from decimal import Decimal
 
 from uncountable.integration.job import JobArguments, WebhookJob, register_job
 from uncountable.types import (
     base_t,
+    entity_t,
     generic_upload_t,
     identifier_t,
     job_definition_t,
+    notifications_t,
     uploader_t,
 )
 
@@ -68,18 +71,58 @@ class ParseExample(WebhookJob[ParsePayload]):
                             data=uploader_t.StringValue(value="my_file_to_upload.xlsx"),
                         ),
                     ),
+                    uploader_t.HeaderEntry(
+                        type=uploader_t.StructureElementType.HEADER,
+                        value=uploader_t.NumericHeaderData(
+                            name="file structure number",
+                            data=uploader_t.DecimalValue(value=Decimal(99)),
+                        ),
+                    ),
                 ],
             )
         ]
 
-        args.client.complete_async_parse(
+        user_id: base_t.ObjectId | None = None
+        recipe_id: base_t.ObjectId | None = None
+        data = args.client.get_entities_data(
+            entity_ids=[payload.async_job_id], entity_type=entity_t.EntityType.ASYNC_JOB
+        )
+        for field_value in data.entity_details[0].field_values:
+            if field_value.field_ref_name == "core_async_job_jobData":
+                assert isinstance(field_value.value, dict)
+                assert isinstance(field_value.value["user_id"], int)
+                user_id = field_value.value["user_id"]
+            if (
+                field_value.field_ref_name
+                == "unc_async_job_custom_parser_recipe_ids_in_view"
+            ):
+                assert isinstance(field_value.value, list)
+                assert isinstance(field_value.value[0], int)
+                recipe_id = field_value.value[0]
+
+        assert user_id is not None
+        assert recipe_id is not None
+
+        complete_async_parse_req = args.batch_processor.complete_async_parse(
             parsed_file_data=dummy_parsed_file_data,
             async_job_key=identifier_t.IdentifierKeyId(id=payload.async_job_id),
             upload_destination=generic_upload_t.UploadDestinationRecipe(
-                recipe_key=identifier_t.IdentifierKeyId(id=1)
+                recipe_key=identifier_t.IdentifierKeyId(id=recipe_id)
             ),
         )
 
+        args.batch_processor.push_notification(
+            depends_on=[complete_async_parse_req.batch_reference],
+            notification_targets=[
+                notifications_t.NotificationTargetUser(
+                    user_key=identifier_t.IdentifierKeyId(id=user_id)
+                )
+            ],
+            subject="Upload complete",
+            message="Your file has been uploaded",
+            display_notice=True,
+        )
+
         return job_definition_t.JobResult(success=True)
 
     @property

examples/integration-server/jobs/materials_auto/example_predictions.py

@@ -1,6 +1,6 @@
 import random
 from dataclasses import dataclass
-from datetime import datetime
+from datetime import UTC, datetime
 from decimal import Decimal
 
 from uncountable.integration.job import JobArguments, WebhookJob, register_job
@@ -25,7 +25,7 @@ class PredictionsExample(WebhookJob[PredictionsPayload]):
         self, args: JobArguments, payload: PredictionsPayload
     ) -> job_definition_t.JobResult:
         recipe_data = args.client.get_recipes_data(recipe_ids=payload.recipe_ids)
-        formatted_datetime = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        formatted_datetime = datetime.now(UTC).strftime("%Y-%m-%d %H:%M:%S")
 
         for recipe in recipe_data.recipes:
             test_sample_name = f"Predictions Model ({formatted_datetime})"

examples/integration-server/pyproject.toml

@@ -115,7 +115,6 @@ lint.ignore = [
     "PD010", # .pivottable.  Should add
     "PD011", # use .to_numpy.  Skip
     "PD015", # use .merge.  Should add
-    "PD901", # avoid generic df name.  Skip
     "PERF203", # avoid try except in loop. Skip
     "PERF401", # use list comprehension. Skip
     "PERF402", # use list.copy.  Skip
@@ -213,6 +212,7 @@ exclude = [
 
 [tool.ruff.lint.isort]
 split-on-trailing-comma = true
+known-first-party = ["pkgs"]
 
 [tool.ruff.lint.mccabe]
 max-complexity = 130 # goal would be to bring this down to ~50 or so

pkgs/serialization_util/serialization_helpers.py

@@ -85,7 +85,9 @@ def _serialize_dataclass(d: Any) -> dict[str, JsonValue]:
 
 
 def _to_string_value(value: Any) -> str:
-    assert isinstance(value, (Decimal, int))
+    assert isinstance(value, (Decimal, int)), (
+        f"Expecting decimal or int, received: {value} (type={type(value)})"
+    )
     return str(value)
 
 

pkgs/type_spec/builder.py

@@ -13,7 +13,7 @@ from enum import Enum, StrEnum, auto
 from typing import Any, Self
 
 from . import util
-from .cross_output_links import CrossOutputPaths
+from .builder_types import CrossOutputPaths
 from .non_discriminated_union_exceptions import NON_DISCRIMINATED_UNION_EXCEPTIONS
 from .util import parse_type_str
 
@@ -1101,7 +1101,7 @@ def _parse_const(
         elif const_type.defn_type.name == BaseTypeName.s_dict:
             assert isinstance(value, dict)
             builder.ensure(
-                len(const_type.parameters) == 2, "constant-dict-expects-one-type"
+                len(const_type.parameters) == 2, "constant-dict-expects-two-types"
             )
             key_type = const_type.parameters[0]
             value_type = const_type.parameters[1]
@@ -1150,6 +1150,11 @@ def _parse_const(
             )
             return value
 
+        if not const_type.is_base:
+            # IMPROVE: validate the object type properties before emission stage
+            builder.ensure(isinstance(value, dict), "invalid value for object constant")
+            return value
+
     raise Exception("unsupported-const-scalar-type", const_type)
 
 
@@ -1271,7 +1276,8 @@ class SpecNamespace:
 
             assert util.is_valid_type_name(name), f"{name} is not a valid type name"
             assert name not in self.types, f"{name} is duplicate"
-            defn_type = defn["type"]
+            defn_type = defn.get("type")
+            assert isinstance(defn_type, str), f"{name} requires a string type"
             spec_type: SpecTypeDefn
             if defn_type == DefnTypeName.s_alias:
                 spec_type = SpecTypeDefnAlias(self, name)

pkgs/type_spec/builder_types.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+
+@dataclass(kw_only=True, frozen=True)
+class CrossOutputPaths:
+    python_types_output: str
+    typescript_types_output: str
+    typescript_routes_output_by_endpoint: dict[str, str]
+    typespec_files_input: list[str]

pkgs/type_spec/cross_output_links.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import os
-from dataclasses import dataclass
 
-from pkgs.type_spec import builder
+from . import builder
+from .builder_types import CrossOutputPaths
 
 
 def get_python_stub_file_path(
@@ -17,14 +17,6 @@ def get_python_stub_file_path(
     return api_stub_file
 
 
-@dataclass(kw_only=True, frozen=True)
-class CrossOutputPaths:
-    python_types_output: str
-    typescript_types_output: str
-    typescript_routes_output_by_endpoint: dict[str, str]
-    typespec_files_input: list[str]
-
-
 def get_python_api_file_path(
     cross_output_paths: CrossOutputPaths,
     namespace: builder.SpecNamespace,

pkgs/type_spec/emit_open_api.py

@@ -610,18 +610,6 @@ def _emit_type(
     ctx.types[stype.name] = final_type
 
 
-def _emit_constant(ctx: EmitOpenAPIContext, sconst: builder.SpecConstant) -> None:
-    if sconst.value_type.is_base_type(builder.BaseTypeName.s_string):
-        value = util.encode_common_string(cast(str, sconst.value))
-    elif sconst.value_type.is_base_type(builder.BaseTypeName.s_integer):
-        value = str(sconst.value)
-    else:
-        raise Exception("invalid constant type", sconst.name)
-
-    const_name = sconst.name.upper()
-    print("_emit_constant", value, const_name)
-
-
 def _emit_endpoint(
     gctx: EmitOpenAPIGlobalContext,
     ctx: EmitOpenAPIContext,

pkgs/type_spec/emit_python.py

@@ -35,6 +35,11 @@ QUEUED_BATCH_REQUEST_STYPE = builder.SpecTypeDefnObject(
     namespace=ASYNC_BATCH_TYPE_NAMESPACE, name="QueuedAsyncBatchRequest"
 )
 
+CLIENT_CONFIG_TYPE_NAMESPACE = builder.SpecNamespace(name="client_config")
+REQUEST_OPTIONS_STYPE = builder.SpecTypeDefnObject(
+    namespace=CLIENT_CONFIG_TYPE_NAMESPACE, name="RequestOptions"
+)
+
 
 @dataclasses.dataclass(kw_only=True)
 class TrackingContext:
@@ -117,26 +122,36 @@ def _check_type_match(stype: builder.SpecType, value: Any) -> bool:
     raise Exception("invalid type", stype, value)
 
 
-def _emit_value(ctx: TrackingContext, stype: builder.SpecType, value: Any) -> str:
+def _emit_value(
+    ctx: TrackingContext, stype: builder.SpecType, value: Any, indent: int = 0
+) -> str:
     literal = builder.unwrap_literal_type(stype)
     if literal is not None:
         return _emit_value(ctx, literal.value_type, literal.value)
 
     if stype.is_base_type(builder.BaseTypeName.s_string):
-        assert isinstance(value, str)
+        assert isinstance(value, str), (
+            f"Expected str value for {stype.name} but got {value}"
+        )
         return util.encode_common_string(value)
     elif stype.is_base_type(builder.BaseTypeName.s_integer):
-        assert isinstance(value, int)
+        assert isinstance(value, int), (
+            f"Expected int value for {stype.name} but got {value}"
+        )
         return str(value)
     elif stype.is_base_type(builder.BaseTypeName.s_boolean):
-        assert isinstance(value, bool)
+        assert isinstance(value, bool), (
+            f"Expected bool value for {stype.name} but got {value}"
+        )
         return "True" if value else "False"
     elif stype.is_base_type(builder.BaseTypeName.s_decimal) or stype.is_base_type(
         builder.BaseTypeName.s_lossy_decimal
     ):
         # Note that decimal requires the `!decimal 123.12` style notation in the YAML
         # file since PyYaml parses numbers as float, unfortuantely
-        assert isinstance(value, (Decimal, int))
+        assert isinstance(value, (Decimal, int)), (
+            f"Expected decimal value for {stype.name} but got {value} (type: {type(value)})"
+        )
         if isinstance(value, int):
             # skip quotes for integers
             return f"Decimal({value})"
@@ -151,14 +166,14 @@ def _emit_value(ctx: TrackingContext, stype: builder.SpecType, value: Any) -> st
             key_type = stype.parameters[0]
             value_type = stype.parameters[1]
             return (
-                "{\n    "
-                + ",\n    ".join(
+                f"{{\n{INDENT * (indent + 1)}"
+                + f",\n{INDENT * (indent + 1)}".join(
                     _emit_value(ctx, key_type, dkey)
                     + ": "
-                    + _emit_value(ctx, value_type, dvalue)
+                    + _emit_value(ctx, value_type, dvalue, indent=indent + 1)
                     for dkey, dvalue in value.items()
                 )
-                + "\n}"
+                + f"\n{INDENT * indent}}}"
             )
 
         if stype.defn_type.is_base_type(builder.BaseTypeName.s_optional):
@@ -184,6 +199,34 @@ def _emit_value(ctx: TrackingContext, stype: builder.SpecType, value: Any) -> st
         return f"{refer_to(ctx, stype)}.{_resolve_enum_name(value, stype.name_case)}"
     elif isinstance(stype, builder.SpecTypeDefnAlias):
         return _emit_value(ctx, stype.alias, value)
+    elif isinstance(stype, builder.SpecTypeDefnObject):
+        assert isinstance(value, dict), (
+            f"Expected dict value for {stype.name} but got {value}"
+        )
+        if not stype.is_hashable:
+            raise Exception("invalid constant object type, non-hashable", value, stype)
+        obj_out = f"{refer_to(ctx, stype)}("
+        emitted_fields: set[str] = set()
+        for prop_name, prop in (stype.properties or {}).items():
+            if prop_name not in value:
+                continue
+            else:
+                value_to_emit = value[prop_name]
+            emitted_fields.add(prop_name)
+            py_name = python_field_name(prop.name, prop.name_case)
+            obj_out += f"\n{INDENT * (indent + 1)}{py_name}={_emit_value(ctx, prop.spec_type, value_to_emit, indent=indent + 1)},"
+        whitespace = f"\n{INDENT * indent}" if len(emitted_fields) > 0 else ""
+        obj_out += f"{whitespace})"
+
+        if emitted_fields != set(value.keys()):
+            raise Exception(
+                "invalid object type, extra fields found:",
+                value,
+                stype,
+                set(value.keys()) - emitted_fields,
+            )
+
+        return obj_out
 
     raise Exception("invalid constant type", value, stype)
 
@@ -471,6 +514,19 @@ def _emit_endpoint_invocation_function_signature(
         else []
     ) + (extra_params if extra_params is not None else [])
 
+    request_options_property = builder.SpecProperty(
+        name="_request_options",
+        label="_request_options",
+        spec_type=REQUEST_OPTIONS_STYPE,
+        extant=builder.PropertyExtant.optional,
+        convert_value=builder.PropertyConvertValue.auto,
+        name_case=builder.NameCase.convert,
+        default=None,
+        has_default=True,
+        desc=None,
+    )
+    all_arguments.append(request_options_property)
+
     # All endpoints share a function name
     function = endpoint.path_per_api_endpoint[endpoint.default_endpoint_key].function
     assert function is not None
@@ -641,6 +697,7 @@ def _emit_endpoint_invocation_function(
             method={refer_to(ctx=ctx, stype=endpoint_method_stype)},
             endpoint={refer_to(ctx=ctx, stype=endpoint_path_stype)},
             args=args,
+            request_options=_request_options,
         )
         return self.do_request(api_request=api_request, return_type={refer_to(ctx=ctx, stype=data_type)})"""
     )
@@ -1396,7 +1453,7 @@ CLIENT_CLASS_IMPORTS = [
     "import dataclasses",
 ]
 ASYNC_BATCH_PROCESSOR_FILENAME = "async_batch_processor"
-ASYNC_BATCH_PROCESSOR_IMPORTS = [
+ASYNC_BATCH_PROCESSOR_BASE_IMPORTS = [
     "import uuid",
     "from abc import ABC, abstractmethod",
     "from pkgs.serialization_util import serialize_for_api",
@@ -1434,8 +1491,11 @@ def _emit_async_batch_processor(
         config=config,
     )
 
+    imports = ASYNC_BATCH_PROCESSOR_BASE_IMPORTS.copy()
+    if ctx.use_dataclass:
+        imports.append("import dataclasses")
     async_batch_processor_out.write(
-        f"""{LINE_BREAK.join(ASYNC_BATCH_PROCESSOR_IMPORTS)}
+        f"""{LINE_BREAK.join(imports)}
 
 
 class AsyncBatchProcessorBase(ABC):
@@ -1498,6 +1558,7 @@ class APIRequest:
     method: str
     endpoint: str
     args: typing.Any
+    request_options: {refer_to(ctx=ctx, stype=REQUEST_OPTIONS_STYPE)} | None = None
 
 
 class ClientMethods(ABC):

pkgs/type_spec/emit_typescript_util.py

@@ -3,7 +3,7 @@ import typing
 from dataclasses import dataclass, field
 
 from . import builder, util
-from .cross_output_links import CrossOutputPaths
+from .builder_types import CrossOutputPaths
 
 INDENT = "  "
 
@@ -51,7 +51,10 @@ def ts_name(name: str, name_case: builder.NameCase) -> str:
 
 
 def emit_value_ts(
-    ctx: EmitTypescriptContext, stype: builder.SpecType, value: typing.Any
+    ctx: EmitTypescriptContext,
+    stype: builder.SpecType,
+    value: typing.Any,
+    indent: int = 0,
 ) -> str:
     """Mimics emit_python even if not all types are used in TypeScript yet"""
     literal = builder.unwrap_literal_type(stype)
@@ -88,17 +91,17 @@ def emit_value_ts(
                 raise Exception("invalid dict keys -- dict keys must be string or enum")
 
             return (
-                "{\n\t"
-                + ",\n\t".join(
+                f"{{\n{INDENT * (indent + 1)}"
+                + f",\n{INDENT * (indent + 1)}".join(
                     (
                         f"[{emit_value_ts(ctx, key_type, dkey)}]: "
                         if not key_type.is_base_type(builder.BaseTypeName.s_string)
                         else f"{dkey}: "
                     )
-                    + emit_value_ts(ctx, value_type, dvalue)
+                    + emit_value_ts(ctx, value_type, dvalue, indent=indent + 1)
                     for dkey, dvalue in value.items()
                 )
-                + "\n}"
+                + f"\n{INDENT * (indent)}}}"
             )
 
         if stype.defn_type.is_base_type(builder.BaseTypeName.s_optional):
@@ -109,6 +112,25 @@ def emit_value_ts(
 
     elif isinstance(stype, builder.SpecTypeDefnStringEnum):
         return f"{refer_to(ctx, stype)}.{ts_enum_name(value, stype.name_case)}"
+    elif isinstance(stype, builder.SpecTypeDefnObject):
+        assert isinstance(value, dict), (
+            f"Expected dict value for {stype.name} but got {value}"
+        )
+        obj_out = "{"
+        did_emit = False
+        for prop_name, prop in (stype.properties or {}).items():
+            if prop_name not in value and prop.has_default:
+                value_to_emit = prop.default
+            elif prop_name not in value:
+                continue
+            else:
+                value_to_emit = value[prop_name]
+            did_emit = True
+            typescript_name = ts_name(prop.name, prop.name_case)
+            obj_out += f"\n{INDENT * (indent + 1)}{typescript_name}: {emit_value_ts(ctx, prop.spec_type, value_to_emit, indent=indent + 1)},"
+        whitespace = f"\n{INDENT * indent}" if did_emit else ""
+        obj_out += f"{whitespace}}} as const"
+        return obj_out
 
     raise Exception("invalid constant type", value, stype, type(stype))
 

pkgs/type_spec/load_types.py

@@ -7,8 +7,8 @@ from shelljob import fs
 from pkgs.serialization import yaml
 
 from .builder import SpecBuilder
+from .builder_types import CrossOutputPaths
 from .config import Config
-from .cross_output_links import CrossOutputPaths
 
 ext_map = {
     ".ts": "typescript",

pkgs/type_spec/type_info/emit_type_info.py

@@ -171,9 +171,16 @@ class MapTypeAlias(MapTypeBase):
     discriminator: str | None
 
 
+@dataclasses.dataclass
+class StringEnumValue:
+    value: str
+    label: str
+    deprecated: bool = False
+
+
 @dataclasses.dataclass
 class MapStringEnum(MapTypeBase):
-    values: dict[str, str]
+    values: dict[str, StringEnumValue]
 
 
 MapType = MapTypeObject | MapTypeAlias | MapStringEnum
@@ -436,7 +443,11 @@ def _build_map_type(
             # IMPROVE: We probably want the label here, but this requires a change
             # to the front-end type-info and form code to handle
             values={
-                entry.value: (entry.label or entry.name)
+                entry.value: StringEnumValue(
+                    value=entry.value,
+                    label=entry.label or entry.name,
+                    deprecated=entry.deprecated,
+                )
                 for entry in stype.values.values()
             },
         )

uncountable/core/client.py

@@ -226,13 +226,15 @@ class Client(ClientMethods):
         except JSONDecodeError as e:
             raise SDKError("unable to process response", request_id=request_id) from e
 
-    def _send_request(self, request: requests.Request) -> requests.Response:
+    def _send_request(
+        self, request: requests.Request, *, timeout: float | None = None
+    ) -> requests.Response:
         if self._cfg.extra_headers is not None:
             request.headers = {**request.headers, **self._cfg.extra_headers}
         if self._cfg.transform_request is not None:
             request = self._cfg.transform_request(request)
         prepared_request = request.prepare()
-        response = self._session.send(prepared_request)
+        response = self._session.send(prepared_request, timeout=timeout)
         return response
 
     def do_request(self, *, api_request: APIRequest, return_type: type[DT]) -> DT:
@@ -257,7 +259,12 @@ 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)
-            response = self._send_request(request)
+            timeout = (
+                api_request.request_options.timeout_secs
+                if api_request.request_options is not None
+                else None
+            )
+            response = self._send_request(request, timeout=timeout)
         response_data = self._get_response_json(response, request_id=request_id)
         cached_parser = self._get_cached_parser(return_type)
         try:

uncountable/integration/queue_runner/command_server/command_server.py

@@ -1,8 +1,9 @@
 import asyncio
 
+import grpc.aio as grpc_aio
 import simplejson as json
 from google.protobuf.timestamp_pb2 import Timestamp
-from grpc import StatusCode, aio
+from grpc import StatusCode
 
 from pkgs.argument_parser import CachedParser
 from uncountable.core.environment import get_local_admin_server_port
@@ -40,11 +41,11 @@ queued_job_payload_parser = CachedParser(queued_job_t.QueuedJobPayload)
 
 
 async def serve(command_queue: CommandQueue, datastore: DatastoreSqlite) -> None:
-    server = aio.server()
+    server = grpc_aio.server()
 
     class CommandServerHandler(CommandServerServicer):
         async def EnqueueJob(
-            self, request: EnqueueJobRequest, context: aio.ServicerContext
+            self, request: EnqueueJobRequest, context: grpc_aio.ServicerContext
         ) -> EnqueueJobResult:
             payload_json = json.loads(request.serialized_payload)
             payload = queued_job_payload_parser.parse_api(payload_json)
@@ -63,7 +64,7 @@ async def serve(command_queue: CommandQueue, datastore: DatastoreSqlite) -> None
             return result
 
         async def RetryJob(
-            self, request: RetryJobRequest, context: aio.ServicerContext
+            self, request: RetryJobRequest, context: grpc_aio.ServicerContext
         ) -> RetryJobResult:
             response_queue: asyncio.Queue[CommandRetryJobResponse] = asyncio.Queue()
             await command_queue.put(
@@ -80,12 +81,12 @@ async def serve(command_queue: CommandQueue, datastore: DatastoreSqlite) -> None
                 return RetryJobResult(successfully_queued=False, queued_job_uuid="")
 
         async def CheckHealth(
-            self, request: CheckHealthRequest, context: aio.ServicerContext
+            self, request: CheckHealthRequest, context: grpc_aio.ServicerContext
         ) -> CheckHealthResult:
             return CheckHealthResult(success=True)
 
         async def ListQueuedJobs(
-            self, request: ListQueuedJobsRequest, context: aio.ServicerContext
+            self, request: ListQueuedJobsRequest, context: grpc_aio.ServicerContext
         ) -> ListQueuedJobsResult:
             if (
                 request.limit < ListQueuedJobsConstants.LIMIT_MIN
@@ -121,7 +122,7 @@ async def serve(command_queue: CommandQueue, datastore: DatastoreSqlite) -> None
             return ListQueuedJobsResult(queued_jobs=response_list)
 
         async def VaccuumQueuedJobs(
-            self, request: VaccuumQueuedJobsRequest, context: aio.ServicerContext
+            self, request: VaccuumQueuedJobsRequest, context: grpc_aio.ServicerContext
         ) -> VaccuumQueuedJobsResult:
             response_queue: asyncio.Queue[CommandVaccuumQueuedJobsResponse] = (
                 asyncio.Queue()

uncountable/integration/webhook_server/entrypoint.py

@@ -73,6 +73,8 @@ def register_route(
 
 
 def main() -> None:
+    app.add_url_rule("/health", "health", lambda: ("OK", 200))
+
     profiles = load_profiles()
     for profile_metadata in profiles:
         server_logger = Logger(get_current_span())

uncountable/types/__init__.py

@@ -70,6 +70,7 @@ from . import integration_session_t as integration_session_t
 from . import integrations_t as integrations_t
 from .api.uploader import invoke_uploader as invoke_uploader_t
 from . import job_definition_t as job_definition_t
+from .api.entity import list_aggregate as list_aggregate_t
 from .api.entity import list_entities as list_entities_t
 from .api.id_source import list_id_source as list_id_source_t
 from .api.entity import lock_entity as lock_entity_t
@@ -199,6 +200,7 @@ __all__: list[str] = [
     "integrations_t",
     "invoke_uploader_t",
     "job_definition_t",
+    "list_aggregate_t",
     "list_entities_t",
     "list_id_source_t",
     "lock_entity_t",