UncountablePythonSDK 0.0.185__py3-none-any.whl → 0.0.187__py3-none-any.whl

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

@@ -0,0 +1,150 @@
+import asyncio
+import json
+import random
+from dataclasses import dataclass
+from decimal import Decimal
+
+from uncountable.core.client import Client
+from uncountable.integration.service import Service, ServiceArguments, register_service
+from uncountable.types import entity_t, identifier_t, listing_t, sockets_t
+from uncountable.types.base_t import ObjectId
+from uncountable.types.integration_session_t import IntegrationSessionInstrument
+from websockets.asyncio.client import connect
+
+from pkgs.serialization_util import serialize_for_api
+
+SCALE_EQUIPMENT_NAMES = [
+    "Instrument Scale One",
+    "Instrument Scale Two",
+    "Instrument Scale Three",
+]
+EQUIPMENT_ID_COLUMN_REF_NAME = "id"
+EQUIPMENT_NAME_COLUMN_REF_NAME = "name"
+SOCKET_URL = "ws://host.docker.internal:8765"
+READING_INTERVAL_SECONDS = 1.0
+
+
+@dataclass(kw_only=True)
+class InstrumentRoom:
+    equipment_name: str
+    token: str
+    room_key: str
+
+
+@dataclass(kw_only=True)
+class InstrumentReading:
+    equipment_name: str
+    value: Decimal
+
+
+def _build_equipment_column(ref_name: str) -> listing_t.ColumnIdentifierEntityRefName:
+    return listing_t.ColumnIdentifierEntityRefName(
+        entity_type=entity_t.EntityType.EQUIPMENT, ref_name=ref_name
+    )
+
+
+def _resolve_equipment_id(*, client: Client, equipment_name: str) -> ObjectId:
+    id_column = _build_equipment_column(EQUIPMENT_ID_COLUMN_REF_NAME)
+    name_column = _build_equipment_column(EQUIPMENT_NAME_COLUMN_REF_NAME)
+    results = client.fetch_listing(
+        entity_type=entity_t.EntityType.EQUIPMENT,
+        columns=[id_column],
+        filters=listing_t.FilterNodeColumnAnd(
+            filters=(
+                listing_t.FilterSpecEquals(
+                    relation=listing_t.FilterRelation.EQUALS,
+                    column=name_column,
+                    value=equipment_name,
+                ),
+            )
+        ),
+    ).results
+    if len(results) != 1:
+        raise Exception(
+            f"expected exactly one equipment named {equipment_name}, found {len(results)}"
+        )
+    equipment_id = results[0].column_values[0]
+    if not isinstance(equipment_id, int):
+        raise Exception(
+            f"expected an integer id for equipment named {equipment_name}, found {equipment_id!r}"
+        )
+    return ObjectId(equipment_id)
+
+
+@register_service
+class ScaleConnectionService(Service):
+    def run(self, args: ServiceArguments) -> None:
+        rooms = [
+            self._register_room(args=args, equipment_name=equipment_name)
+            for equipment_name in SCALE_EQUIPMENT_NAMES
+        ]
+        asyncio.run(self._stream_readings(args=args, rooms=rooms))
+
+    def _register_room(
+        self, *, args: ServiceArguments, equipment_name: str
+    ) -> InstrumentRoom:
+        equipment_id = _resolve_equipment_id(
+            client=args.client, equipment_name=equipment_name
+        )
+        registration = args.client.register_sockets_token(
+            socket_request=sockets_t.SocketRequestIntegrationSession(
+                integration_session=IntegrationSessionInstrument(
+                    equipment_key=identifier_t.IdentifierKeyId(id=equipment_id)
+                )
+            )
+        ).response
+        return InstrumentRoom(
+            equipment_name=equipment_name,
+            token=registration.token,
+            room_key=registration.room_key,
+        )
+
+    async def _stream_readings(
+        self, *, args: ServiceArguments, rooms: list[InstrumentRoom]
+    ) -> None:
+        rooms_by_name = {room.equipment_name: room for room in rooms}
+        async with connect(
+            SOCKET_URL, additional_headers={"X-UNC-EXTERNAL": "true"}
+        ) as ws:
+            for room in rooms:
+                await ws.send(
+                    json.dumps(
+                        serialize_for_api(
+                            sockets_t.JoinRoomWithTokenSocketClientMessage(
+                                token=room.token
+                            )
+                        )
+                    )
+                )
+                args.logger.log_info(f"Joined room for instrument {room.equipment_name}")
+
+            readings: asyncio.Queue[InstrumentReading] = asyncio.Queue()
+            emit_task = asyncio.create_task(
+                self._emit_readings(rooms=rooms, readings=readings)
+            )
+            try:
+                while True:
+                    reading = await readings.get()
+                    room = rooms_by_name[reading.equipment_name]
+                    await ws.send(
+                        json.dumps(
+                            serialize_for_api(
+                                sockets_t.SendInstrumentReadingClientMessage(
+                                    value=reading.value, room_key=room.room_key
+                                )
+                            )
+                        )
+                    )
+            finally:
+                emit_task.cancel()
+
+    async def _emit_readings(
+        self, *, rooms: list[InstrumentRoom], readings: asyncio.Queue[InstrumentReading]
+    ) -> None:
+        while True:
+            room = random.choice(rooms)
+            value = Decimal(str(round(random.uniform(0, 500), 2)))
+            await readings.put(
+                InstrumentReading(equipment_name=room.equipment_name, value=value)
+            )
+            await asyncio.sleep(READING_INTERVAL_SECONDS)

examples/integration-server/jobs/materials_auto/profile.yaml

@@ -117,3 +117,8 @@ jobs:
     executor:
       type: script
       import_path: example_parse
+services:
+  - id: example_scale_connection
+    name: Example Scale Connection
+    import_path: example_scale_connection
+    enabled: true

pkgs/argument_parser/parser_inner.py

@@ -5,6 +5,7 @@ import datetime
 import math
 import types
 import typing
+from collections.abc import Mapping
 from datetime import date
 from decimal import Decimal
 from enum import Enum
@@ -140,18 +141,32 @@ def _build_parser_discriminated_union(
         else discriminator_raw
     )
 
+    accepted = ", ".join(sorted(discriminator_map))
+
     def parse(value: typing.Any) -> typing.Any:
         if context.options.allow_direct_type and dataclasses.is_dataclass(value):
             discriminant = getattr(value, discriminator)
-        else:
+        elif isinstance(value, Mapping):
             discriminant = value.get(discriminator)
+        else:
+            raise ParserError(
+                f"expected-object-for-union; found {type(value).__name__} where an "
+                f"object with {discriminator} set to one of: {accepted} was expected",
+                value=value,
+            )
         if discriminant is None:
-            raise ParserError("missing-union-discriminant")
+            raise ParserError(
+                f"missing-union-discriminant; set {discriminator} to one of: {accepted}"
+            )
         if not isinstance(discriminant, str):
             raise ParserError("union-discriminant-is-not-string", value=discriminant)
         parser = discriminator_map.get(discriminant)
         if parser is None:
-            raise ParserError("missing-type-for-union-discriminant", value=discriminant)
+            raise ParserError(
+                f"missing-type-for-union-discriminant; {discriminator} must be one of: "
+                f"{accepted}",
+                value=discriminant,
+            )
         return parser(value)
 
     return parse

pkgs/serialization_util/_get_type_for_serialization.py

@@ -17,11 +17,11 @@ class SerializationType(StrEnum):
 
 
 @functools.lru_cache(maxsize=500000)
-def get_serialization_type(type: Any) -> SerializationType:
-    super_classes = set(type.__mro__)
+def get_serialization_type(obj_type: Any) -> SerializationType:
+    super_classes = set(obj_type.__mro__)
 
     # check is named tuple
-    if tuple in super_classes and hasattr(type, "_fields"):
+    if tuple in super_classes and hasattr(obj_type, "_fields"):
         return SerializationType.NAMED_TUPLE
 
     if list in super_classes or set in super_classes or tuple in super_classes:
@@ -30,7 +30,7 @@ def get_serialization_type(type: Any) -> SerializationType:
     if dict in super_classes:
         return SerializationType.DICT
 
-    if dataclasses.is_dataclass(type):
+    if dataclasses.is_dataclass(obj_type):
         return SerializationType.DATACLASS
 
     if Enum in super_classes and str in super_classes:

pkgs/type_spec/emit_python.py

@@ -1,4 +1,5 @@
 import dataclasses
+import functools
 import io
 import os
 from decimal import Decimal
@@ -1148,6 +1149,17 @@ def refer_to(ctx: TrackingContext, stype: builder.SpecType) -> str:
 SpecEndpoint = builder.SpecEndpoint
 
 
+def _route_identifier(
+    endpoint: SpecEndpoint, *, endpoint_root: str
+) -> tuple[str, str, str]:
+    endpoint_specific_path = endpoint.path_per_api_endpoint[endpoint_root]
+    return (
+        endpoint_specific_path.path_dirname,
+        endpoint_specific_path.path_basename,
+        endpoint.method,
+    )
+
+
 def _emit_routes(*, builder: builder.SpecBuilder, config: PythonConfig) -> None:
     for endpoint_root in builder.api_endpoints:
         endpoints: list[SpecEndpoint] = []
@@ -1188,17 +1200,13 @@ from main.site.framework.types import {static_route_imports}
 """
         )
 
-        def _route_identifier(endpoint: SpecEndpoint) -> tuple[str, str, str]:
-            endpoint_specific_path = endpoint.path_per_api_endpoint[endpoint_root]
-            return (
-                endpoint_specific_path.path_dirname,
-                endpoint_specific_path.path_basename,
-                endpoint.method,
-            )
+        route_identifier = functools.partial(
+            _route_identifier, endpoint_root=endpoint_root
+        )
 
-        sorted_endpoints = sorted(endpoints, key=_route_identifier)
+        sorted_endpoints = sorted(endpoints, key=route_identifier)
 
-        assert len(endpoints) == len(set(map(_route_identifier, endpoints))), (
+        assert len(endpoints) == len(set(map(route_identifier, endpoints))), (
             "Endpoints are not unique"
         )
 
@@ -1309,39 +1317,64 @@ def _emit_namespace_imports(
 
 def _emit_id_source(*, builder: builder.SpecBuilder, config: PythonConfig) -> None:
     """
-    Create a map of full-type-name to enums for use in id-source.
+    Create a map of full-type-name to enum data for use in id-source. The values are
+    plain data (member values, labels, deprecated) so importing this file does not pull
+    in the generated type modules.
     """
     id_source_output = config.id_source_output
     if id_source_output is None:
         return
-    enum_out = io.StringIO()
-    enum_out.write(f"{LINT_HEADER}{MODIFY_NOTICE}\n")
-    enum_out.write("import typing\n")
-    enum_out.write("from enum import StrEnum\n")
 
-    ctx = TrackingContext()
-    # In this context the propername
     named_enums = {
-        builder.resolve_proper_name(string_enum): refer_to(ctx, string_enum)
+        builder.resolve_proper_name(string_enum): string_enum
         for string_enum in builder.emit_id_source_enums
     }
 
-    _emit_namespace_imports(
-        out=enum_out, namespaces=ctx.namespaces, from_namespace=None, config=config
-    )
-
+    body = io.StringIO()
     known_keys = []
-    enum_out.write("\nENUM_MAP: dict[str, type[StrEnum]] = {\n")
+    any_labels = False
+    body.write("\nENUM_MAP: dict[str, EnumRegistryEntry] = {\n")
     for key in sorted(named_enums.keys()):
-        enum_out.write(f'{INDENT}"{key}": {named_enums[key]},\n')
+        string_enum = named_enums[key]
+        entries = list(string_enum.values.values())
+        member_values = [f'"{entry.value}"' for entry in entries]
+        members = ", ".join(member_values)
+        single_element_comma = "," if len(member_values) == 1 else ""
+        labels = {
+            entry.value: entry.label for entry in entries if entry.label is not None
+        }
+        deprecated = [entry.value for entry in entries if entry.deprecated is True]
+        body.write(f'{INDENT}"{key}": EnumRegistryEntry(\n')
+        body.write(f"{2 * INDENT}members=({members}{single_element_comma}),\n")
+        if labels:
+            any_labels = True
+            body.write(f"{2 * INDENT}labels=MappingProxyType({{\n")
+            for value, label in labels.items():
+                body.write(f'{3 * INDENT}"{value}": "{label}",\n')
+            body.write(f"{2 * INDENT}}}),\n")
+        if deprecated:
+            dep = ", ".join(f'"{value}"' for value in deprecated)
+            body.write(f"{2 * INDENT}deprecated=frozenset({{{dep}}}),\n")
+        body.write(f"{INDENT}),\n")
         known_keys.append(f'"{key}"')
-    enum_out.write(f"}}\n{MODIFY_NOTICE}\n")
+    body.write(f"}}\n{MODIFY_NOTICE}\n")
+
+    enum_out = io.StringIO()
+    enum_out.write(f"{LINT_HEADER}{MODIFY_NOTICE}\n")
+    enum_out.write("import typing\n")
+    if any_labels:
+        enum_out.write("from types import MappingProxyType\n")
+    enum_out.write(
+        "from main.unc.materials.id_source_construct.enum_registry import "
+        "EnumRegistryEntry\n"
+    )
+    enum_out.write(body.getvalue())
 
     enum_out.write(f"\nKnownEnumsType = typing.Literal[\n{INDENT}")
     enum_out.write(f",\n{INDENT}".join(known_keys))
     enum_out.write(f"\n]\n{MODIFY_NOTICE}\n")
 
-    enum_out.write(f'\n{MODIFY_NOTICE}\n__all__ = ["ENUM_MAP"]\n')
+    enum_out.write(f'\n{MODIFY_NOTICE}\n__all__ = ["ENUM_MAP", "KnownEnumsType"]\n')
     enum_out.write(f"{MODIFY_NOTICE}\n{LINT_FOOTER}")
 
     util.rewrite_file(id_source_output, enum_out.getvalue())

pkgs/type_spec/non_discriminated_union_exceptions.py

@@ -2,8 +2,6 @@ NON_DISCRIMINATED_UNION_EXCEPTIONS = [
     "audit_log.AuditLogDataValues",
     "generate_tool_parameters.UnionWithoutDiscrim",
     "output_calculation_entities.ConditionParameterFilterCondition",
-    "output_parameters.AnalyticalMethodParameterOptions",
-    "output_parameters.AnalyticalMethodLinkedOptionValue",
     "recipes_redirect.RecipesRedirectResult",
     "value_spec.ResolvedPathAll",
     "deprecated_calculation_types.DeprecatedWeightedSumEntitiesV0",

pkgs/type_spec/test.py

@@ -2,11 +2,11 @@ from .util import format_parsed_type, parse_type_str
 
 
 def test_parse() -> None:
-    def check(input: str) -> None:
-        pt = parse_type_str(input)
+    def check(type_str: str) -> None:
+        pt = parse_type_str(type_str)
         fmt = format_parsed_type(pt)
-        assert input == fmt
-        print(input, "=", fmt)
+        assert type_str == fmt
+        print(type_str, "=", fmt)
 
     check("Simple.path.more")
     check("path.List<Integer>")

pkgs/type_spec/ui_entry_actions/generate_ui_entry_actions.py

@@ -53,12 +53,12 @@ def ui_entry_variable_to_type_spec_type(
 
 
 def construct_inputs_type_data(
-    vars: dict[str, ui_entry_actions_t.UiEntryActionVariable],
+    action_vars: dict[str, ui_entry_actions_t.UiEntryActionVariable],
 ) -> RawDict:
-    if len(vars) == 0:
+    if len(action_vars) == 0:
         return {"type": BaseTypeName.s_object}
     properties: dict[str, dict[str, str]] = {}
-    for input_name, input_defn in (vars).items():
+    for input_name, input_defn in (action_vars).items():
         properties[f"{input_name}"] = {
             "type": ui_entry_variable_to_type_spec_type(input_defn)
         }
@@ -66,12 +66,12 @@ def construct_inputs_type_data(
 
 
 def construct_outputs_type_data(
-    vars: dict[str, ui_entry_actions_t.UiEntryActionOutput],
+    action_vars: dict[str, ui_entry_actions_t.UiEntryActionOutput],
 ) -> RawDict:
-    if len(vars) == 0:
+    if len(action_vars) == 0:
         return {"type": BaseTypeName.s_object}
     properties: dict[str, dict[str, str]] = {}
-    for output_name, output_defn in (vars).items():
+    for output_name, output_defn in (action_vars).items():
         # All outputs are optional
         properties[f"{output_name}"] = {
             "type": f"Optional<{convert_from_value_spec_type(output_defn.vs_type)}>"
@@ -82,7 +82,7 @@ def construct_outputs_type_data(
 def construct_outputs_type(
     *,
     action_scope: ui_entry_actions_t.ActionScope,
-    vars: dict[str, ui_entry_actions_t.UiEntryActionOutput],
+    action_vars: dict[str, ui_entry_actions_t.UiEntryActionOutput],
     builder: SpecBuilder,
     namespace: SpecNamespace,
 ) -> SpecTypeDefnObject:
@@ -93,7 +93,7 @@ def construct_outputs_type(
     namespace.types[stype.name] = stype
     stype.process(
         builder=builder,
-        data=construct_outputs_type_data(vars=vars),
+        data=construct_outputs_type_data(action_vars=action_vars),
     )
     return stype
 
@@ -101,7 +101,7 @@ def construct_outputs_type(
 def construct_inputs_type(
     *,
     action_scope: ui_entry_actions_t.ActionScope,
-    vars: dict[str, ui_entry_actions_t.UiEntryActionVariable],
+    action_vars: dict[str, ui_entry_actions_t.UiEntryActionVariable],
     builder: SpecBuilder,
     namespace: SpecNamespace,
 ) -> SpecTypeDefnObject:
@@ -109,7 +109,7 @@ def construct_inputs_type(
         namespace=namespace,
         name=emit_typescript_util.ts_type_name(f"{action_scope}_inputs"),
     )
-    stype.process(builder=builder, data=construct_inputs_type_data(vars))
+    stype.process(builder=builder, data=construct_inputs_type_data(action_vars))
     namespace.types[stype.name] = stype
     return stype
 
@@ -140,13 +140,13 @@ def emit_entry_action_definition(
 ) -> EntryActionTypeInfo:
     inputs_type = construct_inputs_type(
         action_scope=action_scope,
-        vars=defn.inputs,
+        action_vars=defn.inputs,
         builder=builder,
         namespace=ctx.namespace,
     )
     outputs_type = construct_outputs_type(
         action_scope=action_scope,
-        vars=defn.outputs,
+        action_vars=defn.outputs,
         builder=builder,
         namespace=ctx.namespace,
     )
@@ -158,12 +158,12 @@ def emit_entry_action_definition(
     )
 
 
-def _validate_input(input: ui_entry_actions_t.UiEntryActionVariable) -> None:
-    if "_" in input.vs_var_name:
-        raise ValueError(f"Expected camelCase for variable {input.vs_var_name}")
-    if not re.fullmatch(base_t.REF_NAME_STRICT_REGEX, input.vs_var_name):
+def _validate_input(variable: ui_entry_actions_t.UiEntryActionVariable) -> None:
+    if "_" in variable.vs_var_name:
+        raise ValueError(f"Expected camelCase for variable {variable.vs_var_name}")
+    if not re.fullmatch(base_t.REF_NAME_STRICT_REGEX, variable.vs_var_name):
         raise ValueError(
-            f"Variable {input.vs_var_name} has invalid syntax. See REF_NAME_STRICT_REGEX"
+            f"Variable {variable.vs_var_name} has invalid syntax. See REF_NAME_STRICT_REGEX"
         )
 
 

uncountable/integration/scan_profiles.py

@@ -21,7 +21,7 @@ def load_profiles() -> list[job_definition_t.ProfileMetadata]:
         if entry.is_dir() and entry.name not in _IGNORED_PROFILE_FOLDERS
     ]
     profile_details: list[job_definition_t.ProfileMetadata] = []
-    seen_job_ids: set[str] = set()
+    seen_ids: set[str] = set()
     for profile_file in profiles:
         profile_name = profile_file.name
         try:
@@ -30,9 +30,14 @@ def load_profiles() -> list[job_definition_t.ProfileMetadata]:
                 resource="profile.yaml",
             )
             for job in definition.jobs:
-                if job.id in seen_job_ids:
-                    raise Exception(f"multiple jobs with id {job.id}")
-                seen_job_ids.add(job.id)
+                if job.id in seen_ids:
+                    raise Exception(f"multiple jobs or services with id {job.id}")
+                seen_ids.add(job.id)
+            services = definition.services if definition.services is not None else []
+            for service in services:
+                if service.id in seen_ids:
+                    raise Exception(f"multiple jobs or services with id {service.id}")
+                seen_ids.add(service.id)
 
             if definition.environments is not None:
                 for integration_env in integration_envs:
@@ -42,6 +47,7 @@ def load_profiles() -> list[job_definition_t.ProfileMetadata]:
                             job_definition_t.ProfileMetadata(
                                 name=profile_name,
                                 jobs=definition.jobs,
+                                services=services,
                                 base_url=environment_config.base_url,
                                 integration_server_base_url=environment_config.integration_server_base_url,
                                 app_base_url=environment_config.app_base_url,
@@ -58,6 +64,7 @@ def load_profiles() -> list[job_definition_t.ProfileMetadata]:
                     job_definition_t.ProfileMetadata(
                         name=profile_name,
                         jobs=definition.jobs,
+                        services=services,
                         base_url=definition.base_url,
                         integration_server_base_url=definition.integration_server_base_url,
                         app_base_url=definition.app_base_url,