UncountablePythonSDK 0.0.143__tar.gz → 0.0.145__tar.gz

{uncountablepythonsdk-0.0.143 → uncountablepythonsdk-0.0.145}/.github/workflows/publish.yml

@@ -36,7 +36,7 @@ jobs:
         run: |
           export SETUPTOOLS_SCM_PRETEND_VERSION_FOR_uncountablepythonsdk=$(git describe --tags --exact-match)
           python3 -m build
-      - uses: actions/upload-artifact@65462800fd760344b1a7b4382951275a0abb4808 # v4
+      - uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5
         with:
           name: package-distributions
           path: dist/
@@ -50,7 +50,7 @@ jobs:
     permissions:
       id-token: write
     steps:
-    - uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5
+    - uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6
       with:
         name: package-distributions
         path: dist/

{uncountablepythonsdk-0.0.143 → uncountablepythonsdk-0.0.145}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UncountablePythonSDK
-Version: 0.0.143
+Version: 0.0.145
 Summary: Uncountable SDK
 Project-URL: Homepage, https://github.com/uncountableinc/uncountable-python-sdk
 Project-URL: Repository, https://github.com/uncountableinc/uncountable-python-sdk.git
@@ -41,7 +41,7 @@ Requires-Dist: azure-storage-blob==12.*
 Requires-Dist: boto3-stubs[essential,ses]==1.*
 Requires-Dist: msgspec==0.19.*
 Requires-Dist: tabulate==0.9.0
-Requires-Dist: types-psutil~=5.9.5
+Requires-Dist: types-psutil~=7.0.0
 Requires-Dist: psutil>=5.9.0
 Provides-Extra: test
 Requires-Dist: mypy==1.*; extra == "test"

{uncountablepythonsdk-0.0.143 → uncountablepythonsdk-0.0.145}/UncountablePythonSDK.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UncountablePythonSDK
-Version: 0.0.143
+Version: 0.0.145
 Summary: Uncountable SDK
 Project-URL: Homepage, https://github.com/uncountableinc/uncountable-python-sdk
 Project-URL: Repository, https://github.com/uncountableinc/uncountable-python-sdk.git
@@ -41,7 +41,7 @@ Requires-Dist: azure-storage-blob==12.*
 Requires-Dist: boto3-stubs[essential,ses]==1.*
 Requires-Dist: msgspec==0.19.*
 Requires-Dist: tabulate==0.9.0
-Requires-Dist: types-psutil~=5.9.5
+Requires-Dist: types-psutil~=7.0.0
 Requires-Dist: psutil>=5.9.0
 Provides-Extra: test
 Requires-Dist: mypy==1.*; extra == "test"

{uncountablepythonsdk-0.0.143 → uncountablepythonsdk-0.0.145}/UncountablePythonSDK.egg-info/SOURCES.txt

@@ -17,6 +17,7 @@ docs/requirements.txt
 docs/integration_examples/create_ingredient.md
 docs/integration_examples/create_output.md
 docs/integration_examples/index.md
+docs/integration_examples/upload_file.md
 docs/static/logo_blue.png
 docs/static/favicons/android-chrome-192x192.png
 docs/static/favicons/android-chrome-512x512.png
@@ -294,6 +295,7 @@ uncountable/types/api/equipment/associate_equipment_input.py
 uncountable/types/api/field_options/__init__.py
 uncountable/types/api/field_options/upsert_field_options.py
 uncountable/types/api/files/__init__.py
+uncountable/types/api/files/create_file_record.py
 uncountable/types/api/files/download_file.py
 uncountable/types/api/id_source/__init__.py
 uncountable/types/api/id_source/list_id_source.py

{uncountablepythonsdk-0.0.143 → uncountablepythonsdk-0.0.145}/UncountablePythonSDK.egg-info/requires.txt

@@ -23,7 +23,7 @@ azure-storage-blob==12.*
 boto3-stubs[essential,ses]==1.*
 msgspec==0.19.*
 tabulate==0.9.0
-types-psutil~=5.9.5
+types-psutil~=7.0.0
 psutil>=5.9.0
 
 [test]

{uncountablepythonsdk-0.0.143 → uncountablepythonsdk-0.0.145}/docs/integration_examples/index.md

@@ -3,4 +3,5 @@
 ```{toctree}
 create_ingredient
 create_output
+upload_file
 ```

uncountablepythonsdk-0.0.145/docs/integration_examples/upload_file.md

@@ -0,0 +1,31 @@
+# Upload Files
+
+This example demonstrates the efficient way to upload files using the External API SDK's `client.upload_files()` method.
+
+```python
+from io import BytesIO
+from pathlib import Path
+
+from uncountable.core import AuthDetailsApiKey, Client
+from uncountable.core.client import ClientConfig
+from uncountable.core.file_upload import DataFileUpload, UploadedFile
+
+client: Client = Client(
+    base_url="<BASE_URL>",
+    auth_details=AuthDetailsApiKey(
+        api_id="<API_ID>", 
+        api_secret_key="<API_SECRET_KEY>"
+    ),
+    config=ClientConfig(allow_insecure_tls=False),
+)
+
+filepath = Path("<YOUR_FILE_PATH>")
+file_io: BytesIO = BytesIO(filepath.read_bytes())
+
+upload_file_response: list[UploadedFile] = client.upload_files(
+    file_uploads=[DataFileUpload(data=file_io, name=filepath.name)]
+)
+
+uploaded_file_name = upload_file_response[0].name
+uploaded_file_id = upload_file_response[0].file_id
+```

{uncountablepythonsdk-0.0.143 → uncountablepythonsdk-0.0.145}/pkgs/argument_parser/argument_parser.py

@@ -213,6 +213,59 @@ def _build_parser_discriminated_union(
     return parse
 
 
+def _resolve_type_var(
+    *,
+    type_arg: typing.Any,
+    type_var_map: dict[typing.TypeVar, type],
+) -> typing.Any:
+    if isinstance(type_arg, typing.TypeVar):
+        if type_arg in type_var_map:
+            return type_var_map[type_arg]
+    return type_arg
+
+
+def _resolve_base_type_vars(
+    *,
+    cls: type,
+    type_var_map: dict[typing.TypeVar, type],
+) -> None:
+    """Recursively resolve TypeVars from all base classes."""
+    for base in getattr(cls, "__orig_bases__", cls.__bases__):
+        base_origin = typing.get_origin(base)
+
+        # Skip typing.Generic marker
+        if base_origin is typing.Generic:
+            continue
+
+        base_args = typing.get_args(base)
+        if base_origin is None or base_args is None:
+            continue
+
+        # Map base class TypeVars
+        base_params = getattr(base_origin, "__parameters__", ())
+        for base_param, base_arg in zip(base_params, base_args, strict=True):
+            resolved_new_type = _resolve_type_var(
+                type_arg=base_arg, type_var_map=type_var_map
+            )
+            if base_param in type_var_map:
+                existing_type = type_var_map[base_param]
+
+                assert existing_type == resolved_new_type, (
+                    f"Conflicting generic type variable mapping detected: "
+                    f"TypeVar {base_param} is already mapped to {existing_type}, "
+                    f"but attempting to remap to {resolved_new_type}. "
+                )
+            else:
+                type_var_map[base_param] = resolved_new_type
+
+        # Recurse into base's bases
+        if dataclasses.is_dataclass(base_origin):
+            _resolve_base_type_vars(
+                cls=base_origin,  # type: ignore[arg-type]
+                type_var_map=type_var_map,
+            )
+
+
 def _build_parser_inner(
     parsed_type: type[T] | typing.TypeVar,
     context: ParserContext,
@@ -248,21 +301,25 @@ def _build_parser_inner(
     origin = typing.get_origin(parsed_type)
     type_args = typing.get_args(parsed_type)
     if dataclasses.is_dataclass(origin) and type_args is not None:
-        new_type_var_map = {}
-        type_params = getattr(origin, "__parameters__", ())
-        for type_param, type_arg in zip(type_params, type_args, strict=True):
-            resolved_type_arg = type_arg
-            if isinstance(type_arg, typing.TypeVar) and type_arg in type_var_map:
-                resolved_type_arg = type_var_map[type_arg]
-
-            new_type_var_map[type_param] = resolved_type_arg
+        # Build local TypeVar map
+        merged_map: dict[typing.TypeVar, type] = {
+            **type_var_map,
+            **{
+                param: _resolve_type_var(type_arg=arg, type_var_map=type_var_map)
+                for param, arg in zip(
+                    getattr(origin, "__parameters__", ()), type_args, strict=True
+                )
+            },
+        }
 
-        return _build_parser_dataclass(
-            origin,  # type: ignore[arg-type]
-            context,
-            new_type_var_map,
+        # Resolve base class TypeVars
+        _resolve_base_type_vars(
+            cls=origin,  # type: ignore[arg-type]
+            type_var_map=merged_map,
         )
 
+        return _build_parser_dataclass(origin, context, merged_map)  # type: ignore[arg-type]
+
     # namedtuple support
     if is_namedtuple_type(parsed_type):
         type_hints = typing.get_type_hints(parsed_type)
@@ -564,7 +621,7 @@ def _build_parser_dataclass(
 
     # Add to cache before building inner types, to support recursion
     parser_function = parse
-    context.cache[parsed_type] = parser_function
+    context.cache[cache_key] = parser_function
 
     dc_field_parsers = []
     for field in dataclasses.fields(parsed_type):  # type:ignore[arg-type]

{uncountablepythonsdk-0.0.143 → uncountablepythonsdk-0.0.145}/pkgs/type_spec/builder.py

@@ -646,14 +646,17 @@ class SpecTypeDefnUnion(SpecTypeDefn):
         if self.discriminator is not None:
             self.discriminator_map = {}
             for sub_type in self.types:
-                builder.push_where(sub_type.name)
-                assert isinstance(sub_type, SpecTypeDefnObject), (
+                defn_type = sub_type
+                if isinstance(sub_type, SpecTypeInstance):
+                    defn_type = sub_type.defn_type
+                builder.push_where(defn_type.name)
+                assert isinstance(defn_type, SpecTypeDefnObject), (
                     "union-type-must-be-object"
                 )
-                assert sub_type.properties is not None
-                discriminator_type = sub_type.properties.get(self.discriminator)
+                assert defn_type.properties is not None
+                discriminator_type = defn_type.properties.get(self.discriminator)
                 assert discriminator_type is not None, (
-                    f"missing-discriminator-field: {sub_type}"
+                    f"missing-discriminator-field: {defn_type}"
                 )
                 prop_type = unwrap_literal_type(discriminator_type.spec_type)
                 assert prop_type is not None
@@ -1299,6 +1302,8 @@ class SpecNamespace:
                 spec_type = SpecTypeDefnAlias(self, name)
             elif defn_type == DefnTypeName.s_union:
                 spec_type = SpecTypeDefnUnion(self, name)
+                if parsed_name.parameters is not None:
+                    raise ValueError("Union types with parameters are not supported")
             elif defn_type == DefnTypeName.s_external:
                 spec_type = SpecTypeDefnExternal(self, name)
             elif defn_type == DefnTypeName.s_string_enum:

{uncountablepythonsdk-0.0.143 → uncountablepythonsdk-0.0.145}/pkgs/type_spec/emit_python.py

@@ -5,7 +5,12 @@ from decimal import Decimal
 from typing import Any
 
 from . import builder, util
-from .builder import EndpointEmitType, EndpointSpecificPath, base_namespace_name
+from .builder import (
+    EndpointEmitType,
+    EndpointSpecificPath,
+    PropertyExtant,
+    base_namespace_name,
+)
 from .config import PythonConfig
 from .cross_output_links import get_path_links
 from .emit_open_api_util import EmitOpenAPIStabilityLevel
@@ -115,9 +120,33 @@ def _check_type_match(stype: builder.SpecType, value: Any) -> bool:
             return any(
                 _check_type_match(sub_type, value) for sub_type in stype.parameters
             )
-
+    elif isinstance(stype, builder.SpecTypeDefnObject):
+        if not isinstance(value, dict):
+            return False
+
+        assert stype.properties is not None
+        value_keys_validated: set[str] = set()
+        for field in stype.properties.values():
+            # Note: This has a dependency on python_field_name since we are forcing the
+            # constant values to use python style field name casing
+            py_name = python_field_name(field.name, field.name_case)
+            if py_name in value:
+                sub_value = value[py_name]
+                value_keys_validated.add(py_name)
+                if not _check_type_match(field.spec_type, sub_value):
+                    return False
+            elif field.extant == PropertyExtant.required:
+                return False
+
+        return value_keys_validated == set(value.keys())
     elif isinstance(stype, builder.SpecTypeDefnStringEnum):
         return value in stype.values
+    elif isinstance(stype, builder.SpecTypeDefnUnion):
+        assert stype.discriminator_map is not None
+        assert stype.discriminator is not None
+        return _check_type_match(
+            stype.discriminator_map[value[stype.discriminator]], value
+        )
 
     raise Exception("invalid type", stype, value)
 
@@ -199,6 +228,18 @@ def _emit_value(
         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.SpecTypeDefnUnion):
+        assert stype.discriminator_map is not None
+        assert stype.discriminator is not None
+        sub_type = stype.discriminator_map[value[stype.discriminator]]
+        if not _check_type_match(sub_type, value):
+            raise Exception("invalid union type for constant", value, stype)
+        return _emit_value(
+            ctx,
+            sub_type,
+            value,
+            indent=indent,
+        )
     elif isinstance(stype, builder.SpecTypeDefnObject):
         assert isinstance(value, dict), (
             f"Expected dict value for {stype.name} but got {value}"

{uncountablepythonsdk-0.0.143 → uncountablepythonsdk-0.0.145}/pkgs/type_spec/emit_typescript_util.py

@@ -112,6 +112,15 @@ 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.SpecTypeDefnUnion):
+        assert stype.discriminator_map is not None
+        assert stype.discriminator is not None
+        return emit_value_ts(
+            ctx,
+            stype.discriminator_map[value[stype.discriminator]],
+            value,
+            indent=indent,
+        )
     elif isinstance(stype, builder.SpecTypeDefnObject):
         assert isinstance(value, dict), (
             f"Expected dict value for {stype.name} but got {value}"

{uncountablepythonsdk-0.0.143 → uncountablepythonsdk-0.0.145}/pkgs/type_spec/type_info/emit_type_info.py

@@ -4,13 +4,14 @@ import decimal
 import io
 import json
 from enum import Enum
-from typing import Any, cast
+from typing import Any
 
 import yaml
 
 from main.base.types import data_t, type_info_t
 from main.base.types.base_t import PureJsonValue
 from pkgs.argument_parser import CachedParser
+from pkgs.serialization import OpaqueKey
 from pkgs.serialization_util import serialize_for_api, serialize_for_storage
 
 from .. import builder, util
@@ -87,11 +88,10 @@ def _dict_null_strip(data: dict[str, object]) -> dict[str, object]:
 
 
 class JsonEncoder(json.JSONEncoder):
-    """We have some defaults of special types that we need to emit"""
-
     def default(self, obj: object) -> object:
         if isinstance(obj, decimal.Decimal):
             return str(obj)
+
         return json.JSONEncoder.default(self, obj)
 
 
@@ -100,7 +100,9 @@ def emit_type_info(build: builder.SpecBuilder, output: str) -> None:
 
     # sort for stability, indent for smaller diffs
     stripped = _dict_null_strip(dataclasses.asdict(type_map))
-    serial = json.dumps(stripped, sort_keys=True, indent=2, cls=JsonEncoder)
+    serial = json.dumps(
+        serialize_for_api(stripped), sort_keys=True, indent=2, cls=JsonEncoder
+    )
     type_map_out = io.StringIO()
     type_map_out.write(MODIFY_NOTICE)
     type_map_out.write(f"export const TYPE_MAP = {serial}")
@@ -109,12 +111,22 @@ def emit_type_info(build: builder.SpecBuilder, output: str) -> None:
 
 
 def _convert_value_for_yaml_dump(value: Any) -> Any:
+    if dataclasses.is_dataclass(value):
+        return {
+            k: _convert_value_for_yaml_dump(v)
+            for k, v in dataclasses.asdict(value).items()  # type: ignore[arg-type]
+        }
     if isinstance(value, Enum):
         return value.value
     elif isinstance(value, list):
         return [_convert_value_for_yaml_dump(item) for item in value]
     elif isinstance(value, dict):
-        return {k: _convert_value_for_yaml_dump(v) for k, v in value.items()}
+        return {
+            (
+                str(k) if isinstance(k, OpaqueKey) else _convert_value_for_yaml_dump(k)
+            ): _convert_value_for_yaml_dump(v)
+            for k, v in value.items()
+        }
     elif isinstance(value, decimal.Decimal):
         return str(value)
     else:
@@ -132,8 +144,9 @@ 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(stripped, default_flow_style=False, sort_keys=True)
+    yaml_content = yaml.dump(serialized, default_flow_style=False, sort_keys=True)
     util.rewrite_file(f"{output}/type_map.yaml", yaml_content)
 
 
@@ -144,7 +157,7 @@ class MapProperty:
     label: str | None
     type_path: object
     extant: str
-    ext_info: PureJsonValue | None
+    ext_info: type_info_t.ExtInfo | None
     desc: str | None
     # We don't have typing on defaults yet, relying on emitters to check it. Limit
     # use of this field, as it'll necessarily change when adding type info
@@ -156,13 +169,13 @@ class MapTypeBase:
     type_name: str
     label: str | None
     desc: str | None
-    ext_info: PureJsonValue | None
+    ext_info: type_info_t.ExtInfo | None
 
 
 @dataclasses.dataclass
 class MapTypeObject(MapTypeBase):
     base_type_path: object
-    properties: dict[str, MapProperty]
+    properties: dict[OpaqueKey, MapProperty]
 
 
 @dataclasses.dataclass
@@ -180,7 +193,7 @@ class StringEnumValue:
 
 @dataclasses.dataclass
 class MapStringEnum(MapTypeBase):
-    values: dict[str, StringEnumValue]
+    values: dict[OpaqueKey, StringEnumValue]
 
 
 MapType = MapTypeObject | MapTypeAlias | MapStringEnum
@@ -188,12 +201,12 @@ MapType = MapTypeObject | MapTypeAlias | MapStringEnum
 
 @dataclasses.dataclass
 class MapNamespace:
-    types: dict[str, MapType]
+    types: dict[OpaqueKey, MapType]
 
 
 @dataclasses.dataclass
 class MapAll:
-    namespaces: dict[str, MapNamespace]
+    namespaces: dict[OpaqueKey, MapNamespace]
 
 
 def _build_map_all(build: builder.SpecBuilder, *, python: bool = False) -> MapAll:
@@ -207,12 +220,12 @@ def _build_map_all(build: builder.SpecBuilder, *, python: bool = False) -> MapAl
             continue
 
         map_namespace = MapNamespace(types={})
-        map_all.namespaces[namespace.name] = map_namespace
+        map_all.namespaces[OpaqueKey(key=namespace.name)] = map_namespace
 
         for type_ in namespace.types.values():
             map_type = _build_map_type(build, type_)
             if map_type is not None:
-                map_namespace.types[type_.name] = map_type
+                map_namespace.types[OpaqueKey(key=type_.name)] = map_type
 
     return map_all
 
@@ -382,14 +395,14 @@ def _build_map_type(
     ):
         _, ext_info = _validate_type_ext_info(stype)
 
-        properties: dict[str, MapProperty] = {}
+        properties: dict[OpaqueKey, MapProperty] = {}
         map_type = MapTypeObject(
             type_name=stype.name,
             label=stype.label,
             properties=properties,
             desc=stype.desc,
             base_type_path=type_path_of(stype.base),
-            ext_info=serialize_for_api(ext_info),  # type: ignore[arg-type]
+            ext_info=ext_info,
         )
 
         if stype.properties is not None:
@@ -403,21 +416,22 @@ def _build_map_type(
                     api_name=ts_name(prop.name, prop.name_case),
                     extant=prop.extant,
                     type_path=type_path_of(prop.spec_type),
-                    ext_info=serialize_for_api(parts.ext_info),  # type: ignore[arg-type]
+                    ext_info=parts.ext_info,
                     desc=parts.desc,
                     default=prop.default,
                 )
-                map_type.properties[prop.name] = map_property
+                map_type.properties[OpaqueKey(key=prop.name)] = map_property
 
         return map_type
 
     if isinstance(stype, builder.SpecTypeDefnAlias):
+        ext_info = _parse_ext_info(stype.ext_info)
         return MapTypeAlias(
             type_name=stype.name,
             label=stype.label,
             desc=stype.desc,
             alias_type_path=type_path_of(stype.alias),
-            ext_info=_convert_ext_info(stype.ext_info),
+            ext_info=_parse_ext_info(stype.ext_info),
             discriminator=stype.discriminator,
         )
 
@@ -425,25 +439,27 @@ def _build_map_type(
         # Emit as a basic alias for now, as the front-end supports only those for now
         # IMPROVE: We should emit a proper union type and support that
         backing = stype.get_backing_type()
+        ext_info = _parse_ext_info(stype.ext_info)
         return MapTypeAlias(
             type_name=stype.name,
             label=stype.label,
             desc=stype.desc,
             alias_type_path=type_path_of(backing),
-            ext_info=_convert_ext_info(stype.ext_info),
+            ext_info=_parse_ext_info(stype.ext_info),
             discriminator=stype.discriminator,
         )
 
     if isinstance(stype, builder.SpecTypeDefnStringEnum):
+        ext_info = _parse_ext_info(stype.ext_info)
         return MapStringEnum(
             type_name=stype.name,
             label=stype.label,
             desc=stype.desc,
-            ext_info=_convert_ext_info(stype.ext_info),
+            ext_info=_parse_ext_info(stype.ext_info),
             # 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: StringEnumValue(
+                OpaqueKey(key=entry.value): StringEnumValue(
                     value=entry.value,
                     label=entry.label or entry.name,
                     deprecated=entry.deprecated,
@@ -476,9 +492,3 @@ def _parse_ext_info(in_ext: Any) -> type_info_t.ExtInfo | None:
     if "open_api" in mod_ext:
         del mod_ext["open_api"]
     return ext_info_parser.parse_storage(mod_ext)
-
-
-def _convert_ext_info(in_ext: Any) -> PureJsonValue | None:
-    # we need to convert this to API storage since it'll be used as-is in the UI
-    parsed = _parse_ext_info(in_ext)
-    return cast(PureJsonValue, serialize_for_api(parsed))

{uncountablepythonsdk-0.0.143 → uncountablepythonsdk-0.0.145}/pyproject.toml

@@ -76,7 +76,7 @@ dependencies = [
     "boto3-stubs[essential,ses]==1.*",
     "msgspec == 0.19.*",
     "tabulate == 0.9.0",
-    "types-psutil~=5.9.5",
+    "types-psutil~=7.0.0",
     "psutil>=5.9.0",
 ]
 dynamic = ["version"]

{uncountablepythonsdk-0.0.143 → uncountablepythonsdk-0.0.145}/uncountable/integration/cli.py

@@ -108,6 +108,13 @@ def register_list_queued_jobs(
         description="List all jobs queued on the integration server",
     )
 
+    list_queued_jobs_parser.add_argument(
+        "--status",
+        type=str,
+        default=None,
+        help="Status of the retrieved jobs",
+    )
+
     list_queued_jobs_parser.add_argument(
         "--offset",
         type=int,
@@ -123,6 +130,7 @@ def register_list_queued_jobs(
 
     def _handle_list_queued_jobs(args: argparse.Namespace) -> None:
         queued_jobs = send_list_queued_jobs_message(
+            status=args.status,
             offset=args.offset,
             limit=args.limit,
             host=args.host,

{uncountablepythonsdk-0.0.143 → uncountablepythonsdk-0.0.145}/uncountable/integration/executors/executors.py

@@ -92,7 +92,7 @@ def execute_job(
     with args.logger.push_scope(job_definition.name) as job_logger:
         job = resolve_executor(job_definition.executor, profile_metadata)
 
-        job_logger.log_info("running job")
+        job_logger.log_info(f"Started running job at `{job.__class__}`..")
 
         run_entity: entity_t.Entity | None = None
         try:

{uncountablepythonsdk-0.0.143 → uncountablepythonsdk-0.0.145}/uncountable/integration/queue_runner/command_server/command_client.py

@@ -120,6 +120,7 @@ def check_health(*, host: str = _LOCAL_RPC_HOST, port: int) -> bool:
 
 def send_list_queued_jobs_message(
     *,
+    status: queued_job_t.JobStatus | None,
     offset: int,
     limit: int,
     host: str = "localhost",
@@ -129,6 +130,7 @@ def send_list_queued_jobs_message(
         request = ListQueuedJobsRequest(
             offset=offset,
             limit=limit,
+            status=status,
         )
 
         try:

{uncountablepythonsdk-0.0.143 → uncountablepythonsdk-0.0.145}/uncountable/integration/queue_runner/command_server/command_server.py

@@ -135,8 +135,20 @@ async def serve(command_queue: CommandQueue, datastore: DatastoreSqlite) -> None
                     StatusCode.INVALID_ARGUMENT, "Offset cannot be negative."
                 )
 
+            try:
+                job_status = (
+                    queued_job_t.JobStatus(request.status)
+                    if request.status != ""
+                    else None
+                )
+            except ValueError:
+                await context.abort(
+                    StatusCode.INVALID_ARGUMENT,
+                    f"Invalid status: '{request.status}'",
+                )
+
             queued_job_metadata = datastore.list_queued_job_metadata(
-                offset=request.offset, limit=request.limit
+                status=job_status, limit=request.limit, offset=request.offset
             )
 
             response_list: list[ListQueuedJobsResult.ListQueuedJobsResultItem] = []

{uncountablepythonsdk-0.0.143 → uncountablepythonsdk-0.0.145}/uncountable/integration/queue_runner/command_server/protocol/command_server.proto

@@ -44,6 +44,7 @@ message CheckHealthResult {
 message ListQueuedJobsRequest {
 	uint32 offset = 1;
 	uint32 limit = 2;
+	string status = 3;
 }
 
 message ListQueuedJobsResult {