indico_toolkit 10.0.0__tar.gz → 10.2.0__tar.gz

{indico_toolkit-10.0.0 → indico_toolkit-10.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: indico-toolkit
-Version: 10.0.0
+Version: 10.2.0
 Summary: Indico Toolkit for Intake and Insights
 License-Expression: MIT
 Requires-Dist: asyncstdlib>=3.14.0,<4.0.0

{indico_toolkit-10.0.0 → indico_toolkit-10.2.0}/pyproject.toml

@@ -8,7 +8,7 @@ description = "Indico Toolkit for Intake and Insights"
 license = "MIT"
 readme = "README.md"
 requires-python = ">=3.11,<4"
-version = "10.0.0"
+version = "10.2.0"
 dependencies = [
     "asyncstdlib (>=3.14.0,<4.0.0)",
     "httpx (>=0.28.1,<0.29.0)",

{indico_toolkit-10.0.0 → indico_toolkit-10.2.0}/pyproject.toml.orig

@@ -9,7 +9,7 @@ license = "MIT"
 readme = "README.md"
 urls = { source = "https://github.com/IndicoDelivery/indico-toolkit-python" }
 requires-python = ">=3.11,<4"
-version = "10.0.0"
+version = "10.2.0"
 dependencies = [
     "asyncstdlib (>=3.14.0,<4.0.0)",
     "httpx (>=0.28.1,<0.29.0)",

{indico_toolkit-10.0.0 → indico_toolkit-10.2.0}/src/indico_toolkit/orm/__init__.py

@@ -5,10 +5,9 @@ from typing import Any
 from . import submissions, tables
 from .submissions import Submission
 from .tables import Table
-from .types import Categorical, GraphqlIterator, OrmType
+from .types import GraphqlIterator, OrmType
 
 __all__ = (
-    "Categorical",
     "init",
     "load",
     "save",

{indico_toolkit-10.0.0 → indico_toolkit-10.2.0}/src/indico_toolkit/orm/fields.py

@@ -1,13 +1,12 @@
 import dataclasses
 import typing
-from collections.abc import Callable, Collection
+from collections.abc import Collection
 from datetime import date, datetime
+from enum import StrEnum
 from functools import cache
 from types import NoneType, UnionType
 from typing import Any, Union
 
-from .types import Categorical
-
 
 @dataclasses.dataclass(frozen=True)
 class Field:
@@ -21,12 +20,15 @@ class Field:
 
 def validate_fields(
     orm: type,
-    supported_scalar_types: Collection[type | None],
+    supported_scalar_types: Collection[type],
     supported_collection_types: Collection[type | None],
 ) -> None:
     for field in get_fields(orm):
         if not (
-            field.scalar_type in supported_scalar_types
+            (
+                field.scalar_type in supported_scalar_types
+                or issubclass(field.scalar_type, supported_scalar_types)  # type: ignore[ty:invalid-argument-type]
+            )
             and field.collection_type in supported_collection_types
         ):
             raise TypeError(f"{field.attribute} is not a supported type")
@@ -37,10 +39,8 @@ def get_fields(orm: type) -> tuple[Field, ...]:
     return tuple(
         map(
             _get_field,
-            filter(
-                lambda field: field.init,
-                dataclasses.fields(orm),  # type: ignore[ty:invalid-argument-type]
-            ),
+            # Only include fields in the dataclass's generated `__init__()`.
+            filter(lambda field: field.init, dataclasses.fields(orm)),  # type: ignore[ty:invalid-argument-type]
         )
     )
 
@@ -60,7 +60,7 @@ def _get_field(field: dataclasses.Field[Any]) -> Field:
             raise TypeError(f"{attribute} must be a single collection type")
 
     scalar_type = next(arg for arg in args if arg is not NoneType)
-    scalar_parser = SCALAR_PARSER_SERIALZER_BY_TYPE.get(scalar_type)
+    scalar_parser = _SCALAR_PARSER_BY_TYPE.get(scalar_type, scalar_type)
     multi = collection_type not in (Union, UnionType)
 
     return Field(
@@ -73,12 +73,8 @@ def _get_field(field: dataclasses.Field[Any]) -> Field:
     )
 
 
-SCALAR_PARSER_SERIALZER_BY_TYPE: dict[type, Callable[[type], object]] = {  # type: ignore[ty:invalid-assignment]
-    bool: bool,
-    Categorical: Categorical,
+_SCALAR_PARSER_BY_TYPE = {
     date: date.fromisoformat,
     datetime: datetime.fromisoformat,
-    float: float,
-    int: int,
-    str: str,
+    StrEnum: str,
 }

{indico_toolkit-10.0.0 → indico_toolkit-10.2.0}/src/indico_toolkit/orm/submissions.py

@@ -3,25 +3,26 @@ import textwrap
 import typing
 from collections.abc import Iterable, Iterator
 from datetime import date, datetime
+from enum import StrEnum
 from typing import Any
 
 from .collections import WeakIdKeyDictionary
 from .fields import get_fields, validate_fields
-from .types import Categorical, GraphqlIterator, SubmissionType
+from .types import GraphqlIterator, SubmissionType
 
 _SUPPORTED_COLLECTION_TYPES = (
     list,
     set,
     None,
 )
-_SUPPORTED_SCALAR_TYPES: tuple[type, ...] = (  # type: ignore[ty:invalid-assignment]
+_SUPPORTED_SCALAR_TYPES = (
     bool,
-    Categorical,
     date,
     datetime,
     float,
     int,
     str,
+    StrEnum,
 )
 
 _INSTANCE_PREV_VALUES = WeakIdKeyDictionary()
@@ -45,25 +46,30 @@ def load(submission_class: type[Submission], submission_id: int) -> GraphqlItera
     Yield GraphQL queries to load the fields specified on dataclass `submission_class`
     for submission ID `submission_id`.
     """
+    fields = get_fields(submission_class)
     yield (
         textwrap.dedent("""
             query load(
                 $submissionId: ID!
                 $fieldIds: [String!]!
+                $limit: Int
             ) {
                 submission(id: $submissionId) {
-                    fields(fieldIds: $fieldIds) {
+                    fields(
+                        fieldIds: $fieldIds
+                        limit: $limit
+                    ) {
                         field {
                             fieldId
                         }
                         values(
-                            filters: [
-                                {
-                                    field: "status"
-                                    op: EQUAL
+                            filters: {
+                                match: {
+                                    property: "status"
+                                    operator: EQUAL
                                     textValues: ["ACCEPTED", "BUILTIN"]
                                 }
-                            ]
+                            }
                         ) {
                             id
                             value
@@ -74,7 +80,8 @@ def load(submission_class: type[Submission], submission_id: int) -> GraphqlItera
         """).strip(),
         {
             "submissionId": submission_id,
-            "fieldIds": [field.id for field in get_fields(submission_class)],
+            "fieldIds": [field.id for field in fields],
+            "limit": len(fields),
         },
     )
 
@@ -258,8 +265,6 @@ def _structured(scalar_type: type[Any], value: Any) -> dict[str, dict[str, Any]]
     """
     if scalar_type is bool:
         return {"boolean": {"value": value}}
-    elif scalar_type is Categorical:
-        return {"lookup": {"option": value}}
     elif scalar_type is date:
         return {"date": {"year": value.year, "month": value.month, "day": value.day}}
     elif scalar_type is datetime:
@@ -274,5 +279,7 @@ def _structured(scalar_type: type[Any], value: Any) -> dict[str, dict[str, Any]]
         return {"number": {"numberPrecise": str(value)}}
     elif scalar_type is str:
         return {"text": {"text": value}}
+    elif scalar_type is StrEnum or issubclass(scalar_type, StrEnum):
+        return {"lookup": {"option": value}}
     else:
         raise TypeError(f"unmapped scalar type {scalar_type}")

{indico_toolkit-10.0.0 → indico_toolkit-10.2.0}/src/indico_toolkit/orm/types.py

@@ -1,5 +1,5 @@
 from collections.abc import Iterator
-from typing import TYPE_CHECKING, Annotated, Any, TypeAlias, TypeVar
+from typing import TYPE_CHECKING, Any, TypeAlias, TypeVar
 
 if TYPE_CHECKING:
     from .submissions import Submission
@@ -17,4 +17,4 @@ TableType = TypeVar("TableType", bound="Table")
 OrmType = TypeVar("OrmType", bound="Submission | Table")
 
 # Scalar Field Types
-Categorical = Annotated[str, "CATEGORICAL"]
+# Price = ...

{indico_toolkit-10.0.0 → indico_toolkit-10.2.0}/src/indico_toolkit/results/result.py

@@ -71,9 +71,10 @@ class Result:
         review_metadata = get(result, dict, "reviews")
         errored_files = get(result, dict, "errored_files").values()
 
-        static_model_components = filter(
+        static_and_blueprint_components = filter(
             lambda component: (
-                get(component, str, "component_type").casefold() == "static_model"
+                get(component, str, "component_type").casefold()
+                in ("static_model", "custom_model")
             ),
             component_metadata.values(),
         )
@@ -87,7 +88,7 @@ class Result:
         tasks = sorted(
             chain(
                 map(Task.from_dict, modelgroup_metadata.values()),
-                map(Task.from_dict, static_model_components),
+                map(Task.from_dict, static_and_blueprint_components),
             )
         )
         reviews = sorted(map(Review.from_dict, review_metadata.values()))

{indico_toolkit-10.0.0 → indico_toolkit-10.2.0}/src/indico_toolkit/router/__init__.py

@@ -8,11 +8,13 @@ from .annotations import (
     ExportId,
     FieldIds,
     FileNameBytes,
+    MergedSubmissionId,
     OrmIter,
     SubmissionId,
     TableId,
 )
 from .create_submission import CreateSubmission, on_create_submission
+from .merge_submission import MergeSubmission, on_merge_submission
 from .start_export import (
     StartExport,
     on_start_custom_export,
@@ -30,7 +32,10 @@ __all__ = (
     "ExportId",
     "FieldIds",
     "FileNameBytes",
+    "MergedSubmissionId",
+    "MergeSubmission",
     "on_create_submission",
+    "on_merge_submission",
     "on_start_custom_export",
     "on_start_export",
     "on_start_json_export",
@@ -52,6 +57,7 @@ _ROUTE_MAPPING = {
     "new_submission": CreateSubmission,
     "status_change": UpdateStatus,
     "table_update": UpdateTable,
+    "submission_merge": MergeSubmission,
 }
 
 

{indico_toolkit-10.0.0 → indico_toolkit-10.2.0}/src/indico_toolkit/router/annotations.py

@@ -14,6 +14,7 @@ _AsyncKwargsIter: TypeAlias = AsyncIterator[tuple[str, Any]]
 DocumentId = NewType("DocumentId", int)
 ExportId = NewType("ExportId", int)
 FieldIds = NewType("FieldIds", frozenset[str])
+MergedSubmissionId = NewType("MergedSubmissionId", int)
 SubmissionId = NewType("SubmissionId", int)
 TableId = NewType("TableId", str)
 
@@ -48,6 +49,12 @@ def resolve_field(callback: Callback, signal: Any) -> _KwargsIter:
             )
 
 
+def resolve_merged_submission(callback: Callback, signal: Any) -> _KwargsIter:
+    for annotation_name, annotation_type in _annotations(callback):
+        if annotation_type is MergedSubmissionId:
+            yield annotation_name, signal["merged_submission_id"]
+
+
 def resolve_microclient(callback: Callback, client: MicroClient) -> _KwargsIter:
     for annotation_name, annotation_type in _annotations(callback):
         if annotation_type is MicroClient:

indico_toolkit-10.2.0/src/indico_toolkit/router/merge_submission.py

@@ -0,0 +1,43 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any, Awaitable, Self, TypeVar
+
+import asyncstdlib as a
+
+from .. import orm
+from ..microclient import MicroClient
+from . import annotations
+from .annotations import AsyncOrmIter, OrmIter
+from .routes import Callback, Route, register
+
+
+@dataclass(frozen=True)
+class MergeSubmission(Route):
+    @classmethod
+    def from_signal(cls, signal: Any) -> Self:
+        return cls()
+
+    def matches(self, other: Any) -> bool:
+        return isinstance(other, type(self))
+
+    async def run(self, callback: Callback, client: MicroClient, signal: Any) -> None:
+        kwargs = await a.dict(
+            a.chain(
+                annotations.resolve_merged_submission(callback, signal),
+                annotations.resolve_microclient(callback, client),
+                annotations.resolve_orm(callback, client, signal),
+                annotations.resolve_submission(callback, signal),
+            )
+        )
+
+        changes = await a.list((await a.sync(callback)(**kwargs)) or [])
+
+        for query, variables in orm.save(changes, signal["submission_id"]):
+            await client.graphql(query, variables)
+
+
+T = TypeVar("T", bound=Callable[..., OrmIter | AsyncOrmIter | None | Awaitable[None]])
+
+
+def on_merge_submission() -> Callable[[T], T]:
+    return register(MergeSubmission())