denkproto 1.0.93__py3-none-any.whl → 1.0.95__py3-none-any.whl

denkproto/__about__.py

@@ -1 +1 @@
-__version__ = "1.0.93"
+__version__ = "1.0.95"

denkproto/json/annotation_comparer_request.py

@@ -281,30 +281,46 @@ class ObjectDetectionMarkup:
 
 
 class BoundingBox:
+    """A bounding box with optional rotation information"""
+
+    angle: Optional[float]
+    """Optional rotation angle"""
+
     bottom_right_x: float
     bottom_right_y: float
+    full_orientation: Optional[bool]
+    """Optional full orientation flag"""
+
     top_left_x: float
     top_left_y: float
 
-    def __init__(self, bottom_right_x: float, bottom_right_y: float, top_left_x: float, top_left_y: float) -> None:
+    def __init__(self, angle: Optional[float], bottom_right_x: float, bottom_right_y: float, full_orientation: Optional[bool], top_left_x: float, top_left_y: float) -> None:
+        self.angle = angle
         self.bottom_right_x = bottom_right_x
         self.bottom_right_y = bottom_right_y
+        self.full_orientation = full_orientation
         self.top_left_x = top_left_x
         self.top_left_y = top_left_y
 
     @staticmethod
     def from_dict(obj: Any) -> 'BoundingBox':
         assert isinstance(obj, dict)
+        angle = from_union([from_float, from_none], obj.get("angle"))
         bottom_right_x = from_float(obj.get("bottom_right_x"))
         bottom_right_y = from_float(obj.get("bottom_right_y"))
+        full_orientation = from_union([from_bool, from_none], obj.get("full_orientation"))
         top_left_x = from_float(obj.get("top_left_x"))
         top_left_y = from_float(obj.get("top_left_y"))
-        return BoundingBox(bottom_right_x, bottom_right_y, top_left_x, top_left_y)
+        return BoundingBox(angle, bottom_right_x, bottom_right_y, full_orientation, top_left_x, top_left_y)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.angle is not None:
+            result["angle"] = from_union([to_float, from_none], self.angle)
         result["bottom_right_x"] = to_float(self.bottom_right_x)
         result["bottom_right_y"] = to_float(self.bottom_right_y)
+        if self.full_orientation is not None:
+            result["full_orientation"] = from_union([from_bool, from_none], self.full_orientation)
         result["top_left_x"] = to_float(self.top_left_x)
         result["top_left_y"] = to_float(self.top_left_y)
         return result
@@ -332,20 +348,26 @@ class RingPoint:
         return result
 
 
-class AnnotationComparerRequestSchema:
+class GeometrySchema:
+    """A single closed loop (ring) of a polygon, defining either an outer boundary or a hole."""
+
     hierarchy: int
+    """Nesting level: 0=outer, 1=hole in level 0, 2=poly in level 1 hole, etc. Even levels are
+    filled areas, odd levels are holes.
+    """
     points: List[RingPoint]
+    """Vertices of the ring."""
 
     def __init__(self, hierarchy: int, points: List[RingPoint]) -> None:
         self.hierarchy = hierarchy
         self.points = points
 
     @staticmethod
-    def from_dict(obj: Any) -> 'AnnotationComparerRequestSchema':
+    def from_dict(obj: Any) -> 'GeometrySchema':
         assert isinstance(obj, dict)
         hierarchy = from_int(obj.get("hierarchy"))
         points = from_list(RingPoint.from_dict, obj.get("points"))
-        return AnnotationComparerRequestSchema(hierarchy, points)
+        return GeometrySchema(hierarchy, points)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -355,20 +377,25 @@ class AnnotationComparerRequestSchema:
 
 
 class Polygon:
-    rings: List[AnnotationComparerRequestSchema]
+    """A polygon defined by one or more rings, allowing for holes and nested structures."""
+
+    rings: List[GeometrySchema]
+    """Array of polygon rings. The hierarchy field within each ring determines nesting and
+    fill/hole status.
+    """
 
-    def __init__(self, rings: List[AnnotationComparerRequestSchema]) -> None:
+    def __init__(self, rings: List[GeometrySchema]) -> None:
         self.rings = rings
 
     @staticmethod
     def from_dict(obj: Any) -> 'Polygon':
         assert isinstance(obj, dict)
-        rings = from_list(AnnotationComparerRequestSchema.from_dict, obj.get("rings"))
+        rings = from_list(GeometrySchema.from_dict, obj.get("rings"))
         return Polygon(rings)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["rings"] = from_list(lambda x: to_class(AnnotationComparerRequestSchema, x), self.rings)
+        result["rings"] = from_list(lambda x: to_class(GeometrySchema, x), self.rings)
         return result
 
 
@@ -408,7 +435,7 @@ class OcrMarkupAnnotation:
         return result
 
 
-class OcrMarkup:
+class OCRMarkup:
     annotations: List[OcrMarkupAnnotation]
     average_object_widths: List[float]
     height: int
@@ -421,13 +448,13 @@ class OcrMarkup:
         self.width = width
 
     @staticmethod
-    def from_dict(obj: Any) -> 'OcrMarkup':
+    def from_dict(obj: Any) -> 'OCRMarkup':
         assert isinstance(obj, dict)
         annotations = from_list(OcrMarkupAnnotation.from_dict, obj.get("annotations"))
         average_object_widths = from_list(from_float, obj.get("average_object_widths"))
         height = from_int(obj.get("height"))
         width = from_int(obj.get("width"))
-        return OcrMarkup(annotations, average_object_widths, height, width)
+        return OCRMarkup(annotations, average_object_widths, height, width)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -634,24 +661,6 @@ class PixelAnnotation:
         return result
 
 
-class PolygonAnnotation:
-    rings: List[AnnotationComparerRequestSchema]
-
-    def __init__(self, rings: List[AnnotationComparerRequestSchema]) -> None:
-        self.rings = rings
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'PolygonAnnotation':
-        assert isinstance(obj, dict)
-        rings = from_list(AnnotationComparerRequestSchema.from_dict, obj.get("rings"))
-        return PolygonAnnotation(rings)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["rings"] = from_list(lambda x: to_class(AnnotationComparerRequestSchema, x), self.rings)
-        return result
-
-
 class RectangleAnnotation:
     bottom_right_x: float
     bottom_right_y: float
@@ -755,11 +764,11 @@ class SegmentationMarkupAnnotation:
     magicwand_annotation: Optional[MagicwandAnnotation]
     pen_annotation: Optional[PenAnnotation]
     pixel_annotation: Optional[PixelAnnotation]
-    polygon_annotation: Optional[PolygonAnnotation]
+    polygon_annotation: Optional[Polygon]
     rectangle_annotation: Optional[RectangleAnnotation]
     sausage_annotation: Optional[SausageAnnotation]
 
-    def __init__(self, annotation_type: AnnotationType, average_width: float, circle_annotation: Optional[CircleAnnotation], id: UUID, label_id: UUID, magicwand_annotation: Optional[MagicwandAnnotation], pen_annotation: Optional[PenAnnotation], pixel_annotation: Optional[PixelAnnotation], polygon_annotation: Optional[PolygonAnnotation], rectangle_annotation: Optional[RectangleAnnotation], sausage_annotation: Optional[SausageAnnotation]) -> None:
+    def __init__(self, annotation_type: AnnotationType, average_width: float, circle_annotation: Optional[CircleAnnotation], id: UUID, label_id: UUID, magicwand_annotation: Optional[MagicwandAnnotation], pen_annotation: Optional[PenAnnotation], pixel_annotation: Optional[PixelAnnotation], polygon_annotation: Optional[Polygon], rectangle_annotation: Optional[RectangleAnnotation], sausage_annotation: Optional[SausageAnnotation]) -> None:
         self.annotation_type = annotation_type
         self.average_width = average_width
         self.circle_annotation = circle_annotation
@@ -783,7 +792,7 @@ class SegmentationMarkupAnnotation:
         magicwand_annotation = from_union([MagicwandAnnotation.from_dict, from_none], obj.get("magicwand_annotation"))
         pen_annotation = from_union([PenAnnotation.from_dict, from_none], obj.get("pen_annotation"))
         pixel_annotation = from_union([PixelAnnotation.from_dict, from_none], obj.get("pixel_annotation"))
-        polygon_annotation = from_union([PolygonAnnotation.from_dict, from_none], obj.get("polygon_annotation"))
+        polygon_annotation = from_union([Polygon.from_dict, from_none], obj.get("polygon_annotation"))
         rectangle_annotation = from_union([RectangleAnnotation.from_dict, from_none], obj.get("rectangle_annotation"))
         sausage_annotation = from_union([SausageAnnotation.from_dict, from_none], obj.get("sausage_annotation"))
         return SegmentationMarkupAnnotation(annotation_type, average_width, circle_annotation, id, label_id, magicwand_annotation, pen_annotation, pixel_annotation, polygon_annotation, rectangle_annotation, sausage_annotation)
@@ -803,7 +812,7 @@ class SegmentationMarkupAnnotation:
         if self.pixel_annotation is not None:
             result["pixel_annotation"] = from_union([lambda x: to_class(PixelAnnotation, x), from_none], self.pixel_annotation)
         if self.polygon_annotation is not None:
-            result["polygon_annotation"] = from_union([lambda x: to_class(PolygonAnnotation, x), from_none], self.polygon_annotation)
+            result["polygon_annotation"] = from_union([lambda x: to_class(Polygon, x), from_none], self.polygon_annotation)
         if self.rectangle_annotation is not None:
             result["rectangle_annotation"] = from_union([lambda x: to_class(RectangleAnnotation, x), from_none], self.rectangle_annotation)
         if self.sausage_annotation is not None:
@@ -919,10 +928,10 @@ class SegmentationMarkup:
 class Source:
     classification_markup: Optional[ClassificationMarkup]
     object_detection_markup: Optional[ObjectDetectionMarkup]
-    ocr_markup: Optional[OcrMarkup]
+    ocr_markup: Optional[OCRMarkup]
     segmentation_markup: Optional[SegmentationMarkup]
 
-    def __init__(self, classification_markup: Optional[ClassificationMarkup], object_detection_markup: Optional[ObjectDetectionMarkup], ocr_markup: Optional[OcrMarkup], segmentation_markup: Optional[SegmentationMarkup]) -> None:
+    def __init__(self, classification_markup: Optional[ClassificationMarkup], object_detection_markup: Optional[ObjectDetectionMarkup], ocr_markup: Optional[OCRMarkup], segmentation_markup: Optional[SegmentationMarkup]) -> None:
         self.classification_markup = classification_markup
         self.object_detection_markup = object_detection_markup
         self.ocr_markup = ocr_markup
@@ -933,7 +942,7 @@ class Source:
         assert isinstance(obj, dict)
         classification_markup = from_union([ClassificationMarkup.from_dict, from_none], obj.get("classification_markup"))
         object_detection_markup = from_union([ObjectDetectionMarkup.from_dict, from_none], obj.get("object_detection_markup"))
-        ocr_markup = from_union([OcrMarkup.from_dict, from_none], obj.get("ocr_markup"))
+        ocr_markup = from_union([OCRMarkup.from_dict, from_none], obj.get("ocr_markup"))
         segmentation_markup = from_union([SegmentationMarkup.from_dict, from_none], obj.get("segmentation_markup"))
         return Source(classification_markup, object_detection_markup, ocr_markup, segmentation_markup)
 
@@ -944,7 +953,7 @@ class Source:
         if self.object_detection_markup is not None:
             result["object_detection_markup"] = from_union([lambda x: to_class(ObjectDetectionMarkup, x), from_none], self.object_detection_markup)
         if self.ocr_markup is not None:
-            result["ocr_markup"] = from_union([lambda x: to_class(OcrMarkup, x), from_none], self.ocr_markup)
+            result["ocr_markup"] = from_union([lambda x: to_class(OCRMarkup, x), from_none], self.ocr_markup)
         if self.segmentation_markup is not None:
             result["segmentation_markup"] = from_union([lambda x: to_class(SegmentationMarkup, x), from_none], self.segmentation_markup)
         return result

denkproto/json/ocr_markup.py

@@ -1,4 +1,4 @@
-from typing import Any, List, Optional, TypeVar, Callable, Type, cast
+from typing import Optional, Any, List, TypeVar, Callable, Type, cast
 from uuid import UUID
 
 
@@ -10,6 +10,25 @@ def from_float(x: Any) -> float:
     return float(x)
 
 
+def from_none(x: Any) -> Any:
+    assert x is None
+    return x
+
+
+def from_union(fs, x):
+    for f in fs:
+        try:
+            return f(x)
+        except:
+            pass
+    assert False
+
+
+def from_bool(x: Any) -> bool:
+    assert isinstance(x, bool)
+    return x
+
+
 def to_float(x: Any) -> float:
     assert isinstance(x, (int, float))
     return x
@@ -30,50 +49,52 @@ def to_class(c: Type[T], x: Any) -> dict:
     return cast(Any, x).to_dict()
 
 
-def from_none(x: Any) -> Any:
-    assert x is None
-    return x
-
-
-def from_union(fs, x):
-    for f in fs:
-        try:
-            return f(x)
-        except:
-            pass
-    assert False
-
-
 def from_str(x: Any) -> str:
     assert isinstance(x, str)
     return x
 
 
 class BoundingBox:
+    """A bounding box with optional rotation information"""
+
+    angle: Optional[float]
+    """Optional rotation angle"""
+
     bottom_right_x: float
     bottom_right_y: float
+    full_orientation: Optional[bool]
+    """Optional full orientation flag"""
+
     top_left_x: float
     top_left_y: float
 
-    def __init__(self, bottom_right_x: float, bottom_right_y: float, top_left_x: float, top_left_y: float) -> None:
+    def __init__(self, angle: Optional[float], bottom_right_x: float, bottom_right_y: float, full_orientation: Optional[bool], top_left_x: float, top_left_y: float) -> None:
+        self.angle = angle
         self.bottom_right_x = bottom_right_x
         self.bottom_right_y = bottom_right_y
+        self.full_orientation = full_orientation
         self.top_left_x = top_left_x
         self.top_left_y = top_left_y
 
     @staticmethod
     def from_dict(obj: Any) -> 'BoundingBox':
         assert isinstance(obj, dict)
+        angle = from_union([from_float, from_none], obj.get("angle"))
         bottom_right_x = from_float(obj.get("bottom_right_x"))
         bottom_right_y = from_float(obj.get("bottom_right_y"))
+        full_orientation = from_union([from_bool, from_none], obj.get("full_orientation"))
         top_left_x = from_float(obj.get("top_left_x"))
         top_left_y = from_float(obj.get("top_left_y"))
-        return BoundingBox(bottom_right_x, bottom_right_y, top_left_x, top_left_y)
+        return BoundingBox(angle, bottom_right_x, bottom_right_y, full_orientation, top_left_x, top_left_y)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.angle is not None:
+            result["angle"] = from_union([to_float, from_none], self.angle)
         result["bottom_right_x"] = to_float(self.bottom_right_x)
         result["bottom_right_y"] = to_float(self.bottom_right_y)
+        if self.full_orientation is not None:
+            result["full_orientation"] = from_union([from_bool, from_none], self.full_orientation)
         result["top_left_x"] = to_float(self.top_left_x)
         result["top_left_y"] = to_float(self.top_left_y)
         return result
@@ -101,7 +122,7 @@ class Point:
         return result
 
 
-class OcrMarkupSchema:
+class GeometrySchema:
     """A single closed loop (ring) of a polygon, defining either an outer boundary or a hole."""
 
     hierarchy: int
@@ -116,11 +137,11 @@ class OcrMarkupSchema:
         self.points = points
 
     @staticmethod
-    def from_dict(obj: Any) -> 'OcrMarkupSchema':
+    def from_dict(obj: Any) -> 'GeometrySchema':
         assert isinstance(obj, dict)
         hierarchy = from_int(obj.get("hierarchy"))
         points = from_list(Point.from_dict, obj.get("points"))
-        return OcrMarkupSchema(hierarchy, points)
+        return GeometrySchema(hierarchy, points)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -132,23 +153,23 @@ class OcrMarkupSchema:
 class Polygon:
     """A polygon defined by one or more rings, allowing for holes and nested structures."""
 
-    rings: List[OcrMarkupSchema]
+    rings: List[GeometrySchema]
     """Array of polygon rings. The hierarchy field within each ring determines nesting and
     fill/hole status.
     """
 
-    def __init__(self, rings: List[OcrMarkupSchema]) -> None:
+    def __init__(self, rings: List[GeometrySchema]) -> None:
         self.rings = rings
 
     @staticmethod
     def from_dict(obj: Any) -> 'Polygon':
         assert isinstance(obj, dict)
-        rings = from_list(OcrMarkupSchema.from_dict, obj.get("rings"))
+        rings = from_list(GeometrySchema.from_dict, obj.get("rings"))
         return Polygon(rings)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["rings"] = from_list(lambda x: to_class(OcrMarkupSchema, x), self.rings)
+        result["rings"] = from_list(lambda x: to_class(GeometrySchema, x), self.rings)
         return result
 
 
@@ -157,8 +178,6 @@ class Annotation:
     id: UUID
     label_id: UUID
     polygon: Optional[Polygon]
-    """A polygon defined by one or more rings, allowing for holes and nested structures."""
-
     text: str
 
     def __init__(self, bounding_box: Optional[BoundingBox], id: UUID, label_id: UUID, polygon: Optional[Polygon], text: str) -> None:

denkproto/json/prediction_request.py

@@ -1,8 +1,10 @@
 from uuid import UUID
-from typing import Any, Dict, List, TypeVar, Callable, Type, cast
+from typing import Any, Dict, List, Optional, TypeVar, Callable, Type, cast
+from enum import Enum
 
 
 T = TypeVar("T")
+EnumT = TypeVar("EnumT", bound=Enum)
 
 
 def from_int(x: Any) -> int:
@@ -20,6 +22,11 @@ def from_bool(x: Any) -> bool:
     return x
 
 
+def from_str(x: Any) -> str:
+    assert isinstance(x, str)
+    return x
+
+
 def to_class(c: Type[T], x: Any) -> dict:
     assert isinstance(x, c)
     return cast(Any, x).to_dict()
@@ -30,11 +37,35 @@ def from_list(f: Callable[[Any], T], x: Any) -> List[T]:
     return [f(y) for y in x]
 
 
-def from_str(x: Any) -> str:
-    assert isinstance(x, str)
+def from_none(x: Any) -> Any:
+    assert x is None
     return x
 
 
+def from_union(fs, x):
+    for f in fs:
+        try:
+            return f(x)
+        except:
+            pass
+    assert False
+
+
+def from_float(x: Any) -> float:
+    assert isinstance(x, (float, int)) and not isinstance(x, bool)
+    return float(x)
+
+
+def to_float(x: Any) -> float:
+    assert isinstance(x, (int, float))
+    return x
+
+
+def to_enum(c: Type[EnumT], x: Any) -> EnumT:
+    assert isinstance(x, c)
+    return x.value
+
+
 class Image:
     blob_id: UUID
     height: int
@@ -65,7 +96,7 @@ class Image:
         return result
 
 
-class ClassLabel:
+class ClassLabelElement:
     id: UUID
     idx: int
 
@@ -74,11 +105,11 @@ class ClassLabel:
         self.idx = idx
 
     @staticmethod
-    def from_dict(obj: Any) -> 'ClassLabel':
+    def from_dict(obj: Any) -> 'ClassLabelElement':
         assert isinstance(obj, dict)
         id = UUID(obj.get("id"))
         idx = from_int(obj.get("idx"))
-        return ClassLabel(id, idx)
+        return ClassLabelElement(id, idx)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -109,29 +140,59 @@ class Config:
         return result
 
 
-class Onnx:
-    blob_id: UUID
-    owned_by_group_id: UUID
+class OcrCharacterRestrictionPreset:
+    characters: str
+    value: str
 
-    def __init__(self, blob_id: UUID, owned_by_group_id: UUID) -> None:
-        self.blob_id = blob_id
-        self.owned_by_group_id = owned_by_group_id
+    def __init__(self, characters: str, value: str) -> None:
+        self.characters = characters
+        self.value = value
 
     @staticmethod
-    def from_dict(obj: Any) -> 'Onnx':
+    def from_dict(obj: Any) -> 'OcrCharacterRestrictionPreset':
         assert isinstance(obj, dict)
-        blob_id = UUID(obj.get("blob_id"))
-        owned_by_group_id = UUID(obj.get("owned_by_group_id"))
-        return Onnx(blob_id, owned_by_group_id)
+        characters = from_str(obj.get("characters"))
+        value = from_str(obj.get("value"))
+        return OcrCharacterRestrictionPreset(characters, value)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["blob_id"] = str(self.blob_id)
-        result["owned_by_group_id"] = str(self.owned_by_group_id)
+        result["characters"] = from_str(self.characters)
+        result["value"] = from_str(self.value)
         return result
 
 
-class Pytorch:
+class OcrCharacterRestrictionElement:
+    allowed_characters: str
+    index: int
+    number_of_characters: int
+    ocr_character_restriction_preset: OcrCharacterRestrictionPreset
+
+    def __init__(self, allowed_characters: str, index: int, number_of_characters: int, ocr_character_restriction_preset: OcrCharacterRestrictionPreset) -> None:
+        self.allowed_characters = allowed_characters
+        self.index = index
+        self.number_of_characters = number_of_characters
+        self.ocr_character_restriction_preset = ocr_character_restriction_preset
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'OcrCharacterRestrictionElement':
+        assert isinstance(obj, dict)
+        allowed_characters = from_str(obj.get("allowed_characters"))
+        index = from_int(obj.get("index"))
+        number_of_characters = from_int(obj.get("number_of_characters"))
+        ocr_character_restriction_preset = OcrCharacterRestrictionPreset.from_dict(obj.get("ocr_character_restriction_preset"))
+        return OcrCharacterRestrictionElement(allowed_characters, index, number_of_characters, ocr_character_restriction_preset)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["allowed_characters"] = from_str(self.allowed_characters)
+        result["index"] = from_int(self.index)
+        result["number_of_characters"] = from_int(self.number_of_characters)
+        result["ocr_character_restriction_preset"] = to_class(OcrCharacterRestrictionPreset, self.ocr_character_restriction_preset)
+        return result
+
+
+class Onnx:
     blob_id: UUID
     owned_by_group_id: UUID
 
@@ -140,11 +201,11 @@ class Pytorch:
         self.owned_by_group_id = owned_by_group_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'Pytorch':
+    def from_dict(obj: Any) -> 'Onnx':
         assert isinstance(obj, dict)
         blob_id = UUID(obj.get("blob_id"))
         owned_by_group_id = UUID(obj.get("owned_by_group_id"))
-        return Pytorch(blob_id, owned_by_group_id)
+        return Onnx(blob_id, owned_by_group_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -155,9 +216,9 @@ class Pytorch:
 
 class Snapshot:
     onnx: Onnx
-    pytorch: Pytorch
+    pytorch: Onnx
 
-    def __init__(self, onnx: Onnx, pytorch: Pytorch) -> None:
+    def __init__(self, onnx: Onnx, pytorch: Onnx) -> None:
         self.onnx = onnx
         self.pytorch = pytorch
 
@@ -165,69 +226,262 @@ class Snapshot:
     def from_dict(obj: Any) -> 'Snapshot':
         assert isinstance(obj, dict)
         onnx = Onnx.from_dict(obj.get("onnx"))
-        pytorch = Pytorch.from_dict(obj.get("pytorch"))
+        pytorch = Onnx.from_dict(obj.get("pytorch"))
         return Snapshot(onnx, pytorch)
 
     def to_dict(self) -> dict:
         result: dict = {}
         result["onnx"] = to_class(Onnx, self.onnx)
-        result["pytorch"] = to_class(Pytorch, self.pytorch)
+        result["pytorch"] = to_class(Onnx, self.pytorch)
         return result
 
 
 class NetworkExperiment:
-    class_labels: List[ClassLabel]
+    class_labels: List[ClassLabelElement]
     config: Config
     flavor: str
+    id: UUID
     network_typename: str
+    ocr_character_restrictions: Optional[List[OcrCharacterRestrictionElement]]
+    """Only present for OCR prediction requests"""
+
     snapshot: Snapshot
 
-    def __init__(self, class_labels: List[ClassLabel], config: Config, flavor: str, network_typename: str, snapshot: Snapshot) -> None:
+    def __init__(self, class_labels: List[ClassLabelElement], config: Config, flavor: str, id: UUID, network_typename: str, ocr_character_restrictions: Optional[List[OcrCharacterRestrictionElement]], snapshot: Snapshot) -> None:
         self.class_labels = class_labels
         self.config = config
         self.flavor = flavor
+        self.id = id
         self.network_typename = network_typename
+        self.ocr_character_restrictions = ocr_character_restrictions
         self.snapshot = snapshot
 
     @staticmethod
     def from_dict(obj: Any) -> 'NetworkExperiment':
         assert isinstance(obj, dict)
-        class_labels = from_list(ClassLabel.from_dict, obj.get("class_labels"))
+        class_labels = from_list(ClassLabelElement.from_dict, obj.get("class_labels"))
         config = Config.from_dict(obj.get("config"))
         flavor = from_str(obj.get("flavor"))
+        id = UUID(obj.get("id"))
         network_typename = from_str(obj.get("network_typename"))
+        ocr_character_restrictions = from_union([lambda x: from_list(OcrCharacterRestrictionElement.from_dict, x), from_none], obj.get("ocr_character_restrictions"))
         snapshot = Snapshot.from_dict(obj.get("snapshot"))
-        return NetworkExperiment(class_labels, config, flavor, network_typename, snapshot)
+        return NetworkExperiment(class_labels, config, flavor, id, network_typename, ocr_character_restrictions, snapshot)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["class_labels"] = from_list(lambda x: to_class(ClassLabel, x), self.class_labels)
+        result["class_labels"] = from_list(lambda x: to_class(ClassLabelElement, x), self.class_labels)
         result["config"] = to_class(Config, self.config)
         result["flavor"] = from_str(self.flavor)
+        result["id"] = str(self.id)
         result["network_typename"] = from_str(self.network_typename)
+        if self.ocr_character_restrictions is not None:
+            result["ocr_character_restrictions"] = from_union([lambda x: from_list(lambda x: to_class(OcrCharacterRestrictionElement, x), x), from_none], self.ocr_character_restrictions)
         result["snapshot"] = to_class(Snapshot, self.snapshot)
         return result
 
 
+class AnnotationType(Enum):
+    IGNORE = "IGNORE"
+    NEGATIVE = "NEGATIVE"
+    POSITIVE = "POSITIVE"
+    ROI = "ROI"
+
+
+class BoundingBox:
+    """A bounding box with optional rotation information"""
+
+    angle: Optional[float]
+    """Optional rotation angle"""
+
+    bottom_right_x: float
+    bottom_right_y: float
+    full_orientation: Optional[bool]
+    """Optional full orientation flag"""
+
+    top_left_x: float
+    top_left_y: float
+
+    def __init__(self, angle: Optional[float], bottom_right_x: float, bottom_right_y: float, full_orientation: Optional[bool], top_left_x: float, top_left_y: float) -> None:
+        self.angle = angle
+        self.bottom_right_x = bottom_right_x
+        self.bottom_right_y = bottom_right_y
+        self.full_orientation = full_orientation
+        self.top_left_x = top_left_x
+        self.top_left_y = top_left_y
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'BoundingBox':
+        assert isinstance(obj, dict)
+        angle = from_union([from_float, from_none], obj.get("angle"))
+        bottom_right_x = from_float(obj.get("bottom_right_x"))
+        bottom_right_y = from_float(obj.get("bottom_right_y"))
+        full_orientation = from_union([from_bool, from_none], obj.get("full_orientation"))
+        top_left_x = from_float(obj.get("top_left_x"))
+        top_left_y = from_float(obj.get("top_left_y"))
+        return BoundingBox(angle, bottom_right_x, bottom_right_y, full_orientation, top_left_x, top_left_y)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.angle is not None:
+            result["angle"] = from_union([to_float, from_none], self.angle)
+        result["bottom_right_x"] = to_float(self.bottom_right_x)
+        result["bottom_right_y"] = to_float(self.bottom_right_y)
+        if self.full_orientation is not None:
+            result["full_orientation"] = from_union([from_bool, from_none], self.full_orientation)
+        result["top_left_x"] = to_float(self.top_left_x)
+        result["top_left_y"] = to_float(self.top_left_y)
+        return result
+
+
+class Point:
+    x: float
+    y: float
+
+    def __init__(self, x: float, y: float) -> None:
+        self.x = x
+        self.y = y
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Point':
+        assert isinstance(obj, dict)
+        x = from_float(obj.get("x"))
+        y = from_float(obj.get("y"))
+        return Point(x, y)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["x"] = to_float(self.x)
+        result["y"] = to_float(self.y)
+        return result
+
+
+class GeometrySchema:
+    """A single closed loop (ring) of a polygon, defining either an outer boundary or a hole."""
+
+    hierarchy: int
+    """Nesting level: 0=outer, 1=hole in level 0, 2=poly in level 1 hole, etc. Even levels are
+    filled areas, odd levels are holes.
+    """
+    points: List[Point]
+    """Vertices of the ring."""
+
+    def __init__(self, hierarchy: int, points: List[Point]) -> None:
+        self.hierarchy = hierarchy
+        self.points = points
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'GeometrySchema':
+        assert isinstance(obj, dict)
+        hierarchy = from_int(obj.get("hierarchy"))
+        points = from_list(Point.from_dict, obj.get("points"))
+        return GeometrySchema(hierarchy, points)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["hierarchy"] = from_int(self.hierarchy)
+        result["points"] = from_list(lambda x: to_class(Point, x), self.points)
+        return result
+
+
+class Polygon:
+    """A polygon defined by one or more rings, allowing for holes and nested structures."""
+
+    rings: List[GeometrySchema]
+    """Array of polygon rings. The hierarchy field within each ring determines nesting and
+    fill/hole status.
+    """
+
+    def __init__(self, rings: List[GeometrySchema]) -> None:
+        self.rings = rings
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Polygon':
+        assert isinstance(obj, dict)
+        rings = from_list(GeometrySchema.from_dict, obj.get("rings"))
+        return Polygon(rings)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["rings"] = from_list(lambda x: to_class(GeometrySchema, x), self.rings)
+        return result
+
+
+class ObjectElement:
+    annotation_type: AnnotationType
+    average_width: float
+    bounding_box: Optional[BoundingBox]
+    id: UUID
+    label_id: UUID
+    polygon: Optional[Polygon]
+
+    def __init__(self, annotation_type: AnnotationType, average_width: float, bounding_box: Optional[BoundingBox], id: UUID, label_id: UUID, polygon: Optional[Polygon]) -> None:
+        self.annotation_type = annotation_type
+        self.average_width = average_width
+        self.bounding_box = bounding_box
+        self.id = id
+        self.label_id = label_id
+        self.polygon = polygon
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'ObjectElement':
+        assert isinstance(obj, dict)
+        annotation_type = AnnotationType(obj.get("annotation_type"))
+        average_width = from_float(obj.get("average_width"))
+        bounding_box = from_union([BoundingBox.from_dict, from_none], obj.get("bounding_box"))
+        id = UUID(obj.get("id"))
+        label_id = UUID(obj.get("label_id"))
+        polygon = from_union([Polygon.from_dict, from_none], obj.get("polygon"))
+        return ObjectElement(annotation_type, average_width, bounding_box, id, label_id, polygon)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["annotation_type"] = to_enum(AnnotationType, self.annotation_type)
+        result["average_width"] = to_float(self.average_width)
+        if self.bounding_box is not None:
+            result["bounding_box"] = from_union([lambda x: to_class(BoundingBox, x), from_none], self.bounding_box)
+        result["id"] = str(self.id)
+        result["label_id"] = str(self.label_id)
+        if self.polygon is not None:
+            result["polygon"] = from_union([lambda x: to_class(Polygon, x), from_none], self.polygon)
+        return result
+
+
+class RequestType(Enum):
+    """Discriminator field to identify the type of prediction request"""
+
+    OCR = "ocr"
+    STANDARD = "standard"
+
+
 class PredictionRequest:
     created_by_user_id: UUID
     hasura_url: str
     id: UUID
     image: Image
     network_experiment: NetworkExperiment
+    objects: Optional[List[ObjectElement]]
+    """Only present for OCR prediction requests"""
+
     owned_by_group_id: UUID
     prediction_priority: int
-    request_classification_interpretation: bool
+    request_classification_interpretation: Optional[bool]
+    """Only present for standard prediction requests"""
+
+    request_type: RequestType
+    """Discriminator field to identify the type of prediction request"""
 
-    def __init__(self, created_by_user_id: UUID, hasura_url: str, id: UUID, image: Image, network_experiment: NetworkExperiment, owned_by_group_id: UUID, prediction_priority: int, request_classification_interpretation: bool) -> None:
+    def __init__(self, created_by_user_id: UUID, hasura_url: str, id: UUID, image: Image, network_experiment: NetworkExperiment, objects: Optional[List[ObjectElement]], owned_by_group_id: UUID, prediction_priority: int, request_classification_interpretation: Optional[bool], request_type: RequestType) -> None:
         self.created_by_user_id = created_by_user_id
         self.hasura_url = hasura_url
         self.id = id
         self.image = image
         self.network_experiment = network_experiment
+        self.objects = objects
         self.owned_by_group_id = owned_by_group_id
         self.prediction_priority = prediction_priority
         self.request_classification_interpretation = request_classification_interpretation
+        self.request_type = request_type
 
     @staticmethod
     def from_dict(obj: Any) -> 'PredictionRequest':
@@ -237,10 +491,12 @@ class PredictionRequest:
         id = UUID(obj.get("id"))
         image = Image.from_dict(obj.get("image"))
         network_experiment = NetworkExperiment.from_dict(obj.get("network_experiment"))
+        objects = from_union([lambda x: from_list(ObjectElement.from_dict, x), from_none], obj.get("objects"))
         owned_by_group_id = UUID(obj.get("owned_by_group_id"))
         prediction_priority = from_int(obj.get("prediction_priority"))
-        request_classification_interpretation = from_bool(obj.get("request_classification_interpretation"))
-        return PredictionRequest(created_by_user_id, hasura_url, id, image, network_experiment, owned_by_group_id, prediction_priority, request_classification_interpretation)
+        request_classification_interpretation = from_union([from_bool, from_none], obj.get("request_classification_interpretation"))
+        request_type = RequestType(obj.get("request_type"))
+        return PredictionRequest(created_by_user_id, hasura_url, id, image, network_experiment, objects, owned_by_group_id, prediction_priority, request_classification_interpretation, request_type)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -249,9 +505,13 @@ class PredictionRequest:
         result["id"] = str(self.id)
         result["image"] = to_class(Image, self.image)
         result["network_experiment"] = to_class(NetworkExperiment, self.network_experiment)
+        if self.objects is not None:
+            result["objects"] = from_union([lambda x: from_list(lambda x: to_class(ObjectElement, x), x), from_none], self.objects)
         result["owned_by_group_id"] = str(self.owned_by_group_id)
         result["prediction_priority"] = from_int(self.prediction_priority)
-        result["request_classification_interpretation"] = from_bool(self.request_classification_interpretation)
+        if self.request_classification_interpretation is not None:
+            result["request_classification_interpretation"] = from_union([from_bool, from_none], self.request_classification_interpretation)
+        result["request_type"] = to_enum(RequestType, self.request_type)
         return result
 
 

denkproto/json/segmentation_markup.py

@@ -281,7 +281,7 @@ class RingPoint:
         return result
 
 
-class SegmentationMarkupSchema:
+class GeometrySchema:
     """A single closed loop (ring) of a polygon, defining either an outer boundary or a hole."""
 
     hierarchy: int
@@ -296,11 +296,11 @@ class SegmentationMarkupSchema:
         self.points = points
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SegmentationMarkupSchema':
+    def from_dict(obj: Any) -> 'GeometrySchema':
         assert isinstance(obj, dict)
         hierarchy = from_int(obj.get("hierarchy"))
         points = from_list(RingPoint.from_dict, obj.get("points"))
-        return SegmentationMarkupSchema(hierarchy, points)
+        return GeometrySchema(hierarchy, points)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -312,23 +312,23 @@ class SegmentationMarkupSchema:
 class PolygonAnnotation:
     """A polygon defined by one or more rings, allowing for holes and nested structures."""
 
-    rings: List[SegmentationMarkupSchema]
+    rings: List[GeometrySchema]
     """Array of polygon rings. The hierarchy field within each ring determines nesting and
     fill/hole status.
     """
 
-    def __init__(self, rings: List[SegmentationMarkupSchema]) -> None:
+    def __init__(self, rings: List[GeometrySchema]) -> None:
         self.rings = rings
 
     @staticmethod
     def from_dict(obj: Any) -> 'PolygonAnnotation':
         assert isinstance(obj, dict)
-        rings = from_list(SegmentationMarkupSchema.from_dict, obj.get("rings"))
+        rings = from_list(GeometrySchema.from_dict, obj.get("rings"))
         return PolygonAnnotation(rings)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["rings"] = from_list(lambda x: to_class(SegmentationMarkupSchema, x), self.rings)
+        result["rings"] = from_list(lambda x: to_class(GeometrySchema, x), self.rings)
         return result
 
 

{denkproto-1.0.93.dist-info → denkproto-1.0.95.dist-info}/METADATA

@@ -1,5 +1,5 @@
 Metadata-Version: 2.3
 Name: denkproto
-Version: 1.0.93
+Version: 1.0.95
 Requires-Python: >=3.10
 Requires-Dist: protobuf>=3.20.3

{denkproto-1.0.93.dist-info → denkproto-1.0.95.dist-info}/RECORD

@@ -4,7 +4,7 @@ denkproto/DENKbuffer_pb2_grpc.py,sha256=-CPJPM4FOqwvwV8-f1iJlD18UD9juVIIHfdWUecu
 denkproto/ImageAnalysis_ProtobufMessages_pb2.py,sha256=iEY0j9ySGUThnqTdYD4uAVr9P3GiC5R02iK53zEOXUQ,21015
 denkproto/ImageAnalysis_ProtobufMessages_pb2.pyi,sha256=5LFtxrmYpJHizDDNGFTkL7-NQ_TkwqCSdq7vcv3lg-c,36243
 denkproto/ImageAnalysis_ProtobufMessages_pb2_grpc.py,sha256=l3agtDjgu4jay6P9TRnHhyhJ-7UdoII27ywhw3k84oo,911
-denkproto/__about__.py,sha256=BTvw8DmB4FrGsu9dg34XOAthT2XrdjaaYC_7bKzDlE4,23
+denkproto/__about__.py,sha256=pJbxmrSaZdlmxBIORIdVrmW_p012oX6Otld4fhk0Tnc,23
 denkproto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 denkproto/denkcache_pb2.py,sha256=u0O26m7t4kfu4R1nx1ZcTst4n6pG32pMbhl2PGYivXE,7161
 denkproto/denkcache_pb2.pyi,sha256=8K_Ebyy4mgXrxqJenN8f8LXLvVKOiaZxhmGeYjFZVpY,6357
@@ -26,14 +26,14 @@ denkproto/validate_pb2.py,sha256=CuGAaHir9X9jniW3QsRKAESjYzoS2U6dLk_J55XmNqU,136
 denkproto/validate_pb2.pyi,sha256=fWsdVOR3NJDioCKkCKfxfl4qaEb5xqXXU_WlEbdQx6E,23077
 denkproto/validate_pb2_grpc.py,sha256=XvjuWEgJFJtH1E7HWm7SKpV10PMpOSbonKa2VPHpYy8,889
 denkproto/json/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-denkproto/json/annotation_comparer_request.py,sha256=2vUi2IZaRLF_oqNgGTyOxw0aFaLHMPikocnvjmJ5KMs,39633
+denkproto/json/annotation_comparer_request.py,sha256=tnoriGgQrth9KqgcrFe5lVql4aSiYhT4SROEYpSrsvY,40138
 denkproto/json/classification_markup.py,sha256=vTu0H7Cb3gU6UUUSg1vDTRlFUorZrjMbcp_yx6UssZA,2461
 denkproto/json/inference_graph_models_generated.py,sha256=GfsGk4bKbL8gyqOScA4x13P8sJrAmv3tEhNU36rbIDs,6313
 denkproto/json/object_detection_markup.py,sha256=T0hcFPq8F_galjDjRC9dbcRVwCSOYtu2jt9wpEeHlQs,4904
-denkproto/json/ocr_markup.py,sha256=KyOpth9evOekyhTJdZSnYyB9EIyoWbY33sqncb_jBgw,7069
+denkproto/json/ocr_markup.py,sha256=xZs321ZqOUPK-VzWhy3gKCdqt_EyKOs-6FbaJdSvEMQ,7824
 denkproto/json/ocr_prediction_request.py,sha256=PXY_1hmPQcKpHHZyikMFG_S0HKiwbXtRv5oW5x1zHRM,17783
-denkproto/json/prediction_request.py,sha256=N7KZaKr9FW8RGme86O9xb2JjNBaJDv1TW2ffCugckj0,8839
-denkproto/json/segmentation_markup.py,sha256=EvniRksF2KaQolm6zZ6UKSiGwnqc8wR2sHB1iv05RTE,19911
-denkproto-1.0.93.dist-info/METADATA,sha256=o__s_qTRs9Iqj-Dg0AsZLF0jHHoiAndRHNKtBdNRwSw,110
-denkproto-1.0.93.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-denkproto-1.0.93.dist-info/RECORD,,
+denkproto/json/prediction_request.py,sha256=9AE7KZgQPciRJwMIMkRUMCY85tY6zaaV_Z75XxEF2KQ,18894
+denkproto/json/segmentation_markup.py,sha256=ZU2qYuN1IkZDCjAjr0vEn6nRVdZv24EwRYlmrGEzeVg,19841
+denkproto-1.0.95.dist-info/METADATA,sha256=DsP02yp_tKPj9fLCDlebvs-PUZxDrDLV5w8ybOsq-SQ,110
+denkproto-1.0.95.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+denkproto-1.0.95.dist-info/RECORD,,