indico_toolkit 6.14.1__tar.gz → 6.14.2__tar.gz

{indico_toolkit-6.14.1 → indico_toolkit-6.14.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: indico-toolkit
-Version: 6.14.1
+Version: 6.14.2
 Summary: Classes, functions, and abstractions for Indico IPA
 License: MIT
 Author: Indico Solutions Engineering

{indico_toolkit-6.14.1 → indico_toolkit-6.14.2}/indico_toolkit/__init__.py

@@ -21,4 +21,4 @@ __all__ = (
     "ToolkitStaggeredLoopError",
     "ToolkitStatusError",
 )
-__version__ = "6.14.1"
+__version__ = "6.14.2"

{indico_toolkit-6.14.1 → indico_toolkit-6.14.2}/indico_toolkit/client.py

@@ -8,7 +8,7 @@ from .retry import retry
 
 
 @retry(IndicoRequestError, ConnectionError)
-def create_client(
+def create_client(  # type: ignore[no-any-unimported]
     host: str,
     api_token_path: "str | None" = None,
     api_token_string: "str | None" = None,

{indico_toolkit-6.14.1 → indico_toolkit-6.14.2}/indico_toolkit/indico_wrapper/__init__.py

@@ -1,15 +1,9 @@
-from .dataset import Datasets
-from .doc_extraction import DocExtraction
 from .download import Download
 from .indico_wrapper import IndicoWrapper
-from .reviewer import Reviewer
 from .workflow import Workflow
 
 __all__ = (
-    "Datasets",
-    "DocExtraction",
     "Download",
     "IndicoWrapper",
-    "Reviewer",
     "Workflow",
 )

{indico_toolkit-6.14.1 → indico_toolkit-6.14.2}/indico_toolkit/ocr/__init__.py

@@ -1,9 +1,7 @@
-from .customocr_object import CustomOcr
 from .ondoc_object import OnDoc
 from .standard_object import StandardOcr
 
 __all__ = (
-    "CustomOcr",
     "OnDoc",
     "StandardOcr",
 )

{indico_toolkit-6.14.1 → indico_toolkit-6.14.2}/indico_toolkit/polling/autoreview.py

@@ -3,8 +3,8 @@ import logging
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-from indico import AsyncIndicoClient, IndicoConfig  # type: ignore[import-untyped]
-from indico.queries import (  # type: ignore[import-untyped]
+from indico import AsyncIndicoClient, IndicoConfig
+from indico.queries import (
     GetSubmission,
     JobStatus,
     RetrieveStorageObject,
@@ -41,7 +41,7 @@ class AutoReviewPoller:
     and submits the review results concurrently.
     """
 
-    def __init__(
+    def __init__(  # type: ignore[no-any-unimported]
         self,
         config: IndicoConfig,
         workflow_id: int,

{indico_toolkit-6.14.1 → indico_toolkit-6.14.2}/indico_toolkit/polling/downstream.py

@@ -2,12 +2,12 @@ import asyncio
 import logging
 from typing import TYPE_CHECKING
 
-from indico import AsyncIndicoClient, IndicoConfig  # type: ignore[import-untyped]
-from indico.queries import (  # type: ignore[import-untyped]
+from indico import AsyncIndicoClient, IndicoConfig
+from indico.queries import (
     GetSubmission,
     UpdateSubmission,
 )
-from indico.types import Submission  # type: ignore[import-untyped]
+from indico.types import Submission
 
 from ..retry import retry
 from .queries import SubmissionIdsPendingDownstream
@@ -29,7 +29,7 @@ class DownstreamPoller:
     them concurrently, and marks them as retrieved.
     """
 
-    def __init__(
+    def __init__(  # type: ignore[no-any-unimported]
         self,
         config: IndicoConfig,
         workflow_id: int,

{indico_toolkit-6.14.1 → indico_toolkit-6.14.2}/indico_toolkit/polling/queries.py

@@ -1,12 +1,12 @@
 from typing import TYPE_CHECKING
 
-from indico.queries import GraphQLRequest  # type: ignore[import-untyped]
+from indico.queries import GraphQLRequest
 
 if TYPE_CHECKING:
     from typing import Any
 
 
-class SubmissionIdsPendingAutoReview(GraphQLRequest):  # type: ignore[misc]
+class SubmissionIdsPendingAutoReview(GraphQLRequest):  # type: ignore[misc, no-any-unimported]
     QUERY = """
     query SubmissionIdsPendingAutoReview($workflowIds: [Int]) {
         submissions(
@@ -33,7 +33,7 @@ class SubmissionIdsPendingAutoReview(GraphQLRequest):  # type: ignore[misc]
         }
 
 
-class SubmissionIdsPendingDownstream(GraphQLRequest):  # type: ignore[misc]
+class SubmissionIdsPendingDownstream(GraphQLRequest):  # type: ignore[misc, no-any-unimported]
     QUERY = """
     query SubmissionIdsPendingDownstream($workflowIds: [Int]) {
         submissions(

{indico_toolkit-6.14.1 → indico_toolkit-6.14.2}/indico_toolkit/results/__init__.py

@@ -101,4 +101,4 @@ def _load(result: object) -> Result:
     elif file_version == 3:
         return Result.from_v3_dict(result)
     else:
-        raise ResultError(f"unsupported file version `{file_version!r}`")
+        raise ResultError(f"unsupported file version `{file_version}`")

{indico_toolkit-6.14.1 → indico_toolkit-6.14.2}/indico_toolkit/results/document.py

@@ -12,13 +12,14 @@ class Document:
     error: str
     traceback: str
 
-    # Auto review changes must reproduce all model sections that were present in the
-    # original result file. This may not be possible from the predictions alone--if a
-    # model had an empty section because it didn't produce predictions or if all of
-    # the predictions were removed to reject them. As such, the models seen when
-    # parsing result files are tracked per-document so that the empty sections can be
-    # reproduced later.
+    # Auto review changes must reproduce all model and component sections that were
+    # present in the original result file. This may not be possible from the
+    # predictions alone--if a model or component had an empty section because it didn't
+    # produce predictions or if all of the predictions for that section were dropped.
+    # As such, the models and components seen when parsing a result file are tracked
+    # per-document so that the empty sections can be reproduced later.
     _model_sections: "frozenset[str]"
+    _component_sections: "frozenset[str]"
 
     @staticmethod
     def from_v1_dict(result: object) -> "Document":
@@ -38,6 +39,7 @@ class Document:
             error="",
             traceback="",
             _model_sections=model_names,
+            _component_sections=frozenset(),
         )
 
     @staticmethod
@@ -46,7 +48,9 @@ class Document:
         Create a `Document` from a v3 document dictionary.
         """
         model_results = get(document, dict, "model_results", "ORIGINAL")
+        component_results = get(document, dict, "component_results", "ORIGINAL")
         model_ids = frozenset(model_results.keys())
+        component_ids = frozenset(component_results.keys())
         etl_output_uri = get(document, str, "etl_output")
 
         return Document(
@@ -57,6 +61,7 @@ class Document:
             error="",
             traceback="",
             _model_sections=model_ids,
+            _component_sections=component_ids,
         )
 
     @staticmethod
@@ -75,4 +80,5 @@ class Document:
             error=error,
             traceback=traceback,
             _model_sections=frozenset(),
+            _component_sections=frozenset(),
         )

{indico_toolkit-6.14.1 → indico_toolkit-6.14.2}/indico_toolkit/results/normalization.py

@@ -1,4 +1,5 @@
 import re
+from itertools import chain
 from typing import TYPE_CHECKING
 
 from .utils import get, has
@@ -88,12 +89,18 @@ def normalize_v3_result(result: "Any") -> None:
     """
     task_type_by_model_group_id = {
         model_group_id: model_group["task_type"]
-        for model_group_id, model_group in result["modelgroup_metadata"].items()
+        for model_group_id, model_group in chain(
+            result["modelgroup_metadata"].items(),
+            result.get("component_metadata", {}).items(),
+        )
     }
     predictions_with_task_type: "Iterator[tuple[Any, str]]" = (
-        (prediction, task_type_by_model_group_id[model_group_id])
+        (prediction, task_type_by_model_group_id.get(model_group_id, ""))
         for submission_result in get(result, list, "submission_results")
-        for review_result in get(submission_result, dict, "model_results").values()
+        for review_result in chain(
+            get(submission_result, dict, "model_results").values(),
+            get(submission_result, dict, "component_results").values(),
+        )
         for model_group_id, model_results in review_result.items()
         for prediction in model_results
     )
@@ -139,6 +146,10 @@ def normalize_v3_result(result: "Any") -> None:
         if task_type == "summarization" and "citations" not in prediction:
             prediction["citations"] = []
 
+    # Prior to 7.2, v3 result files don't include a `component_metadata` section.
+    if not has(result, dict, "component_metadata"):
+        result["component_metadata"] = {}
+
     # Prior to 6.8, v3 result files don't include a `reviews` section.
     if not has(result, dict, "reviews"):
         result["reviews"] = {}

{indico_toolkit-6.14.1 → indico_toolkit-6.14.2}/indico_toolkit/results/predictionlist.py

@@ -337,7 +337,7 @@ class PredictionList(List[PredictionType]):
         elif result.version == 3:
             return self.to_v3_changes(result.documents)
         else:
-            raise ValueError(f"unsupported file version `{result.version!r}`")
+            raise ValueError(f"unsupported file version `{result.version}`")
 
     def to_v1_changes(self, document: "Document") -> "dict[str, Any]":
         """
@@ -370,13 +370,8 @@ class PredictionList(List[PredictionType]):
                 continue
 
             model_results: "dict[str, Any]" = {}
-            changes.append(
-                {
-                    "submissionfile_id": document.id,
-                    "model_results": model_results,
-                    "component_results": {},
-                }
-            )
+            component_results: "dict[str, Any]" = {}
+
             predictions_by_model = self.where(
                 document=document,
             ).groupby(
@@ -384,12 +379,30 @@ class PredictionList(List[PredictionType]):
             )
 
             for model, predictions in predictions_by_model.items():
-                model_results[str(model.id)] = [
+                model_id = str(model.id)
+                prediction_dicts = [
                     prediction.to_v3_dict() for prediction in predictions
                 ]
 
+                if model_id in document._model_sections:
+                    model_results[model_id] = prediction_dicts
+                elif model_id in document._component_sections:
+                    component_results[model_id] = prediction_dicts
+
             for model_id in document._model_sections:
                 if model_id not in model_results:
                     model_results[model_id] = []
 
+            for component_id in document._component_sections:
+                if component_id not in component_results:
+                    component_results[component_id] = []
+
+            changes.append(
+                {
+                    "submissionfile_id": document.id,
+                    "model_results": model_results,
+                    "component_results": component_results,
+                }
+            )
+
         return changes

{indico_toolkit-6.14.1 → indico_toolkit-6.14.2}/indico_toolkit/results/predictions/__init__.py

@@ -62,7 +62,7 @@ def from_v1_dict(
     elif model.type == FORM_EXTRACTION:
         return FormExtraction.from_v1_dict(document, model, review, prediction)
     else:
-        raise ResultError(f"unsupported v1 model type `{model.type!r}`")
+        raise ResultError(f"unsupported v1 model type {model.type!r}")
 
 
 def from_v3_dict(
@@ -85,4 +85,4 @@ def from_v3_dict(
     elif model.type == UNBUNDLING:
         return Unbundling.from_v3_dict(document, model, review, prediction)
     else:
-        raise ResultError(f"unsupported v3 model type `{model.type!r}`")
+        raise ResultError(f"unsupported v3 model type {model.type!r}")

{indico_toolkit-6.14.1 → indico_toolkit-6.14.2}/indico_toolkit/results/predictions/group.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from typing import TYPE_CHECKING
 
 from ..utils import get
@@ -13,6 +13,14 @@ class Group:
     name: str
     index: int
 
+    def __next__(self) -> "Group":
+        """
+        Return the `Group` with the next index.
+
+        Supports `group = next(group)`.
+        """
+        return replace(self, index=self.index + 1)
+
     @staticmethod
     def from_dict(group: object) -> "Group":
         return Group(

{indico_toolkit-6.14.1 → indico_toolkit-6.14.2}/indico_toolkit/results/predictions/unbundling.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING
 from ..review import Review
 from ..utils import get, omit
 from .prediction import Prediction
+from .span import Span
 
 if TYPE_CHECKING:
     from typing import Any
@@ -14,7 +15,14 @@ if TYPE_CHECKING:
 
 @dataclass
 class Unbundling(Prediction):
-    pages: "list[int]"
+    spans: "list[Span]"
+
+    @property
+    def pages(self) -> "tuple[int, ...]":
+        """
+        Return the pages covered by `self.spans`.
+        """
+        return tuple(span.page for span in self.spans)
 
     @staticmethod
     def from_v3_dict(
@@ -32,10 +40,7 @@ class Unbundling(Prediction):
             review=review,
             label=get(prediction, str, "label"),
             confidences=get(prediction, dict, "confidence"),
-            pages=[
-                get(span, int, "page_num")
-                for span in get(prediction, list, "spans")  # fmt: skip
-            ],
+            spans=sorted(map(Span.from_dict, get(prediction, list, "spans"))),
             extras=omit(prediction, "confidence", "label", "spans"),
         )
 
@@ -47,5 +52,5 @@ class Unbundling(Prediction):
             **self.extras,
             "label": self.label,
             "confidence": self.confidences,
-            "spans": [{"page_num": page} for page in self.pages],
+            "spans": [span.to_dict() for span in self.spans],
         }

{indico_toolkit-6.14.1 → indico_toolkit-6.14.2}/indico_toolkit/results/result.py

@@ -5,12 +5,13 @@ from typing import TYPE_CHECKING
 
 from . import predictions as prediction
 from .document import Document
+from .errors import ResultError
 from .model import ModelGroup
 from .normalization import normalize_v1_result, normalize_v3_result
 from .predictionlist import PredictionList
 from .predictions import Prediction
 from .review import Review, ReviewType
-from .utils import get
+from .utils import get, has
 
 if TYPE_CHECKING:
     from typing import Any
@@ -106,16 +107,33 @@ class Result:
         submission_id = get(result, int, "submission_id")
         submission_results = get(result, list, "submission_results")
         modelgroup_metadata = get(result, dict, "modelgroup_metadata")
+        component_metadata = get(result, dict, "component_metadata")
         review_metadata = get(result, dict, "reviews")
-
-        processed_documents = map(Document.from_v3_dict, submission_results)
         errored_files = get(result, dict, "errored_files").values()
-        failed_documents = map(Document.from_v3_errored_file, errored_files)
-        documents = sorted(chain(processed_documents, failed_documents))
-        models = sorted(map(ModelGroup.from_v3_dict, modelgroup_metadata.values()))
-        predictions: "PredictionList[Prediction]" = PredictionList()
+
+        static_model_components = filter(
+            lambda component: (
+                get(component, str, "component_type").casefold() == "static_model"
+            ),
+            component_metadata.values(),
+        )
+
+        documents = sorted(
+            chain(
+                map(Document.from_v3_dict, submission_results),
+                map(Document.from_v3_errored_file, errored_files),
+            )
+        )
+        models = sorted(
+            chain(
+                map(ModelGroup.from_v3_dict, modelgroup_metadata.values()),
+                map(ModelGroup.from_v3_dict, static_model_components),
+            )
+        )
         reviews = sorted(map(Review.from_dict, review_metadata.values()))
 
+        predictions: "PredictionList[Prediction]" = PredictionList()
+
         for document_dict in submission_results:
             document_id = get(document_dict, int, "submissionfile_id")
             document = next(
@@ -124,11 +142,17 @@ class Result:
             reviewed_model_predictions: "list[tuple[Review | None, Any]]" = [
                 (None, get(document_dict, dict, "model_results", "ORIGINAL"))
             ]
+            reviewed_component_predictions: "list[tuple[Review | None, Any]]" = [
+                (None, get(document_dict, dict, "component_results", "ORIGINAL"))
+            ]
 
             if reviews:
                 reviewed_model_predictions.append(
                     (reviews[-1], get(document_dict, dict, "model_results", "FINAL"))
                 )
+                reviewed_component_predictions.append(
+                    (reviews[-1], get(document_dict, dict, "component_results", "FINAL"))  # fmt: skip  # noqa: E501
+                )
 
             for review, model_section in reviewed_model_predictions:
                 for model_id, model_predictions in model_section.items():
@@ -142,6 +166,33 @@ class Result:
                         )
                     )
 
+            for review, component_section in reviewed_component_predictions:
+                for component_id, component_predictions in component_section.items():
+                    try:
+                        model = next(
+                            filter(lambda model: model.id == int(component_id), models)
+                        )
+                    except StopIteration:
+                        if has(component_metadata, str, component_id, "component_type"):
+                            component_type = get(
+                                component_metadata, str, component_id, "component_type"
+                            )
+                            raise ResultError(
+                                f"unsupported component type {component_type!r} "
+                                f"for component {component_id}"
+                            )
+                        else:
+                            raise ResultError(
+                                f"no component metadata for component {component_id}"
+                            )
+
+                    predictions.extend(
+                        map(
+                            partial(prediction.from_v3_dict, document, model, review),
+                            component_predictions,
+                        )
+                    )
+
         return Result(
             version=version,
             submission_id=submission_id,

{indico_toolkit-6.14.1 → indico_toolkit-6.14.2}/indico_toolkit/results/utils.py

@@ -1,33 +1,35 @@
 from collections.abc import Iterable, Iterator
 from typing import Callable, TypeVar
 
-from .errors import ResultError
-
 Value = TypeVar("Value")
 
 
 def get(result: object, value_type: "type[Value]", *keys: "str | int") -> Value:
     """
-    Return the value obtained by traversing `result` using `keys` as indices if that
-    value has type `value_type`. Raise a `ResultError` otherwise.
+    Return the value of type `value_type` obtained by traversing `result` using `keys`.
+    Raise an error if a key doesn't exist or the value has the wrong type.
     """
     for key in keys:
-        if isinstance(key, str) and isinstance(result, dict) and key in result:
-            result = result[key]
-        elif isinstance(key, int) and isinstance(result, list) and key < len(result):
-            result = result[key]
+        if isinstance(result, dict):
+            if key in result:
+                result = result[key]
+            else:
+                raise KeyError(f"{key!r} not in {result.keys()!r}")
+        elif isinstance(result, list):
+            if isinstance(key, int):
+                if 0 <= key < len(result):
+                    result = result[key]
+                else:
+                    raise IndexError(f"{key} out of range [0,{len(result)})")
+            else:
+                raise TypeError(f"list can't be indexed with {key!r}")
         else:
-            raise ResultError(
-                f"result object `{type(result)!r}` does not contain key `{key!r}`"
-            )
+            raise TypeError(f"{type(result)} can't be traversed")
 
     if isinstance(result, value_type):
         return result
     else:
-        raise ResultError(
-            f"result object `{type(result)!r}` does not have a value for "
-            f"key `{key!r}` of type `{value_type}`"
-        )
+        raise TypeError(f"value `{result!r}` doesn't have type {value_type}")
 
 
 def has(result: object, value_type: "type[Value]", *keys: "str | int") -> bool:
@@ -35,9 +37,9 @@ def has(result: object, value_type: "type[Value]", *keys: "str | int") -> bool:
     Check if `result` can be traversed using `keys` to a value of type `value_type`.
     """
     for key in keys:
-        if isinstance(key, str) and isinstance(result, dict) and key in result:
+        if isinstance(result, dict) and key in result:
             result = result[key]
-        elif isinstance(key, int) and isinstance(result, list) and key < len(result):
+        elif isinstance(result, list) and isinstance(key, int) and 0 <= key < len(result):  # fmt: skip  # noqa: E501
             result = result[key]
         else:
             return False

{indico_toolkit-6.14.1 → indico_toolkit-6.14.2}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 readme = "README.md"
 urls = { source = "https://github.com/IndicoDataSolutions/Indico-Solutions-Toolkit" }
 requires-python = ">=3.10"
-version = "6.14.1"
+version = "6.14.2"
 dependencies = ["indico-client (>=6.14.0,<7.0.0)"]
 
 [project.optional-dependencies]

indico_toolkit-6.14.1/indico_toolkit/auto_populate/__init__.py

@@ -1,3 +0,0 @@
-from .populator import AutoPopulator
-
-__all__ = ("AutoPopulator",)