denkproto 1.0.50__py3-none-any.whl → 1.0.51__py3-none-any.whl

denkproto/__about__.py

@@ -1 +1 @@
-__version__ = "1.0.50"
+__version__ = "1.0.51"

denkproto/json/classification_markup.py

@@ -0,0 +1,90 @@
+from uuid import UUID
+from typing import Any, List, TypeVar, Callable, Type, cast
+
+
+T = TypeVar("T")
+
+
+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 from_list(f: Callable[[Any], T], x: Any) -> List[T]:
+    assert isinstance(x, list)
+    return [f(y) for y in x]
+
+
+def from_int(x: Any) -> int:
+    assert isinstance(x, int) and not isinstance(x, bool)
+    return x
+
+
+def to_class(c: Type[T], x: Any) -> dict:
+    assert isinstance(x, c)
+    return cast(Any, x).to_dict()
+
+
+class Annotation:
+    id: UUID
+    label_id: UUID
+    value: float
+
+    def __init__(self, id: UUID, label_id: UUID, value: float) -> None:
+        self.id = id
+        self.label_id = label_id
+        self.value = value
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Annotation':
+        assert isinstance(obj, dict)
+        id = UUID(obj.get("id"))
+        label_id = UUID(obj.get("label_id"))
+        value = from_float(obj.get("value"))
+        return Annotation(id, label_id, value)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["id"] = str(self.id)
+        result["label_id"] = str(self.label_id)
+        result["value"] = to_float(self.value)
+        return result
+
+
+class ClassificationMarkup:
+    annotations: List[Annotation]
+    height: int
+    width: int
+
+    def __init__(self, annotations: List[Annotation], height: int, width: int) -> None:
+        self.annotations = annotations
+        self.height = height
+        self.width = width
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'ClassificationMarkup':
+        assert isinstance(obj, dict)
+        annotations = from_list(Annotation.from_dict, obj.get("annotations"))
+        height = from_int(obj.get("height"))
+        width = from_int(obj.get("width"))
+        return ClassificationMarkup(annotations, height, width)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["annotations"] = from_list(lambda x: to_class(Annotation, x), self.annotations)
+        result["height"] = from_int(self.height)
+        result["width"] = from_int(self.width)
+        return result
+
+
+def classification_markup_from_dict(s: Any) -> ClassificationMarkup:
+    return ClassificationMarkup.from_dict(s)
+
+
+def classification_markup_to_dict(x: ClassificationMarkup) -> Any:
+    return to_class(ClassificationMarkup, x)

denkproto/json/object_detection_markup.py

@@ -0,0 +1,153 @@
+from enum import Enum
+from typing import Optional, Any, List, TypeVar, Type, Callable, cast
+from uuid import UUID
+
+
+T = TypeVar("T")
+EnumT = TypeVar("EnumT", bound=Enum)
+
+
+def from_float(x: Any) -> float:
+    assert isinstance(x, (float, int)) and not isinstance(x, bool)
+    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
+
+
+def to_enum(c: Type[EnumT], x: Any) -> EnumT:
+    assert isinstance(x, c)
+    return x.value
+
+
+def from_list(f: Callable[[Any], T], x: Any) -> List[T]:
+    assert isinstance(x, list)
+    return [f(y) for y in x]
+
+
+def from_int(x: Any) -> int:
+    assert isinstance(x, int) and not isinstance(x, bool)
+    return x
+
+
+def to_class(c: Type[T], x: Any) -> dict:
+    assert isinstance(x, c)
+    return cast(Any, x).to_dict()
+
+
+class AnnotationType(Enum):
+    IGNORE = "IGNORE"
+    NEGATIVE = "NEGATIVE"
+    POSITIVE = "POSITIVE"
+    ROI = "ROI"
+
+
+class Annotation:
+    angle: Optional[float]
+    annotation_type: AnnotationType
+    average_width: float
+    bottom_right_x: float
+    bottom_right_y: float
+    full_orientation: Optional[bool]
+    id: UUID
+    label_id: UUID
+    top_left_x: float
+    top_left_y: float
+
+    def __init__(self, angle: Optional[float], annotation_type: AnnotationType, average_width: float, bottom_right_x: float, bottom_right_y: float, full_orientation: Optional[bool], id: UUID, label_id: UUID, top_left_x: float, top_left_y: float) -> None:
+        self.angle = angle
+        self.annotation_type = annotation_type
+        self.average_width = average_width
+        self.bottom_right_x = bottom_right_x
+        self.bottom_right_y = bottom_right_y
+        self.full_orientation = full_orientation
+        self.id = id
+        self.label_id = label_id
+        self.top_left_x = top_left_x
+        self.top_left_y = top_left_y
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Annotation':
+        assert isinstance(obj, dict)
+        angle = from_union([from_float, from_none], obj.get("angle"))
+        annotation_type = AnnotationType(obj.get("annotation_type"))
+        average_width = from_float(obj.get("average_width"))
+        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"))
+        id = UUID(obj.get("id"))
+        label_id = UUID(obj.get("label_id"))
+        top_left_x = from_float(obj.get("top_left_x"))
+        top_left_y = from_float(obj.get("top_left_y"))
+        return Annotation(angle, annotation_type, average_width, bottom_right_x, bottom_right_y, full_orientation, id, label_id, 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["annotation_type"] = to_enum(AnnotationType, self.annotation_type)
+        result["average_width"] = to_float(self.average_width)
+        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["id"] = str(self.id)
+        result["label_id"] = str(self.label_id)
+        result["top_left_x"] = to_float(self.top_left_x)
+        result["top_left_y"] = to_float(self.top_left_y)
+        return result
+
+
+class ObjectDetectionMarkup:
+    annotations: List[Annotation]
+    height: int
+    width: int
+
+    def __init__(self, annotations: List[Annotation], height: int, width: int) -> None:
+        self.annotations = annotations
+        self.height = height
+        self.width = width
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'ObjectDetectionMarkup':
+        assert isinstance(obj, dict)
+        annotations = from_list(Annotation.from_dict, obj.get("annotations"))
+        height = from_int(obj.get("height"))
+        width = from_int(obj.get("width"))
+        return ObjectDetectionMarkup(annotations, height, width)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["annotations"] = from_list(lambda x: to_class(Annotation, x), self.annotations)
+        result["height"] = from_int(self.height)
+        result["width"] = from_int(self.width)
+        return result
+
+
+def object_detection_markup_from_dict(s: Any) -> ObjectDetectionMarkup:
+    return ObjectDetectionMarkup.from_dict(s)
+
+
+def object_detection_markup_to_dict(x: ObjectDetectionMarkup) -> Any:
+    return to_class(ObjectDetectionMarkup, x)

denkproto/json/ocr_markup.py

@@ -0,0 +1,193 @@
+from typing import Any, List, Optional, TypeVar, Callable, Type, cast
+from uuid import UUID
+
+
+T = TypeVar("T")
+
+
+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 from_list(f: Callable[[Any], T], x: Any) -> List[T]:
+    assert isinstance(x, list)
+    return [f(y) for y in x]
+
+
+def to_class(c: Type[T], x: Any) -> dict:
+    assert isinstance(x, c)
+    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
+
+
+def from_int(x: Any) -> int:
+    assert isinstance(x, int) and not isinstance(x, bool)
+    return x
+
+
+class BoundingBox:
+    bottom_right_x: float
+    bottom_right_y: float
+    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:
+        self.bottom_right_x = bottom_right_x
+        self.bottom_right_y = bottom_right_y
+        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)
+        bottom_right_x = from_float(obj.get("bottom_right_x"))
+        bottom_right_y = from_float(obj.get("bottom_right_y"))
+        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)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["bottom_right_x"] = to_float(self.bottom_right_x)
+        result["bottom_right_y"] = to_float(self.bottom_right_y)
+        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 Polygon:
+    points: List[Point]
+
+    def __init__(self, points: List[Point]) -> None:
+        self.points = points
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Polygon':
+        assert isinstance(obj, dict)
+        points = from_list(Point.from_dict, obj.get("points"))
+        return Polygon(points)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["points"] = from_list(lambda x: to_class(Point, x), self.points)
+        return result
+
+
+class Annotation:
+    bounding_box: Optional[BoundingBox]
+    id: UUID
+    label_id: UUID
+    polygon: Optional[Polygon]
+    text: str
+
+    def __init__(self, bounding_box: Optional[BoundingBox], id: UUID, label_id: UUID, polygon: Optional[Polygon], text: str) -> None:
+        self.bounding_box = bounding_box
+        self.id = id
+        self.label_id = label_id
+        self.polygon = polygon
+        self.text = text
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Annotation':
+        assert isinstance(obj, dict)
+        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"))
+        text = from_str(obj.get("text"))
+        return Annotation(bounding_box, id, label_id, polygon, text)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        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)
+        result["text"] = from_str(self.text)
+        return result
+
+
+class OcrMarkup:
+    annotations: List[Annotation]
+    average_object_widths: List[float]
+    height: int
+    width: int
+
+    def __init__(self, annotations: List[Annotation], average_object_widths: List[float], height: int, width: int) -> None:
+        self.annotations = annotations
+        self.average_object_widths = average_object_widths
+        self.height = height
+        self.width = width
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'OcrMarkup':
+        assert isinstance(obj, dict)
+        annotations = from_list(Annotation.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)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["annotations"] = from_list(lambda x: to_class(Annotation, x), self.annotations)
+        result["average_object_widths"] = from_list(to_float, self.average_object_widths)
+        result["height"] = from_int(self.height)
+        result["width"] = from_int(self.width)
+        return result
+
+
+def ocr_markup_from_dict(s: Any) -> OcrMarkup:
+    return OcrMarkup.from_dict(s)
+
+
+def ocr_markup_to_dict(x: OcrMarkup) -> Any:
+    return to_class(OcrMarkup, x)

denkproto/json/segmentation_markup.py

@@ -0,0 +1,526 @@
+from enum import Enum
+from typing import Any, List, Optional, TypeVar, Callable, Type, cast
+from uuid import UUID
+
+
+T = TypeVar("T")
+EnumT = TypeVar("EnumT", bound=Enum)
+
+
+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 from_str(x: Any) -> str:
+    assert isinstance(x, str)
+    return x
+
+
+def from_list(f: Callable[[Any], T], x: Any) -> List[T]:
+    assert isinstance(x, list)
+    return [f(y) for y in x]
+
+
+def from_int(x: Any) -> int:
+    assert isinstance(x, int) and not isinstance(x, bool)
+    return x
+
+
+def to_class(c: Type[T], x: Any) -> dict:
+    assert isinstance(x, c)
+    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 to_enum(c: Type[EnumT], x: Any) -> EnumT:
+    assert isinstance(x, c)
+    return x.value
+
+
+class AnnotationType(Enum):
+    IGNORE = "IGNORE"
+    NEGATIVE = "NEGATIVE"
+    POSITIVE = "POSITIVE"
+    ROI = "ROI"
+
+
+class CircleAnnotation:
+    center_x: float
+    center_y: float
+    radius: float
+
+    def __init__(self, center_x: float, center_y: float, radius: float) -> None:
+        self.center_x = center_x
+        self.center_y = center_y
+        self.radius = radius
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'CircleAnnotation':
+        assert isinstance(obj, dict)
+        center_x = from_float(obj.get("center_x"))
+        center_y = from_float(obj.get("center_y"))
+        radius = from_float(obj.get("radius"))
+        return CircleAnnotation(center_x, center_y, radius)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["center_x"] = to_float(self.center_x)
+        result["center_y"] = to_float(self.center_y)
+        result["radius"] = to_float(self.radius)
+        return result
+
+
+class MagicwandAnnotationPoint:
+    x: float
+    y: float
+
+    def __init__(self, x: float, y: float) -> None:
+        self.x = x
+        self.y = y
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'MagicwandAnnotationPoint':
+        assert isinstance(obj, dict)
+        x = from_float(obj.get("x"))
+        y = from_float(obj.get("y"))
+        return MagicwandAnnotationPoint(x, y)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["x"] = to_float(self.x)
+        result["y"] = to_float(self.y)
+        return result
+
+
+class MagicwandAnnotation:
+    bottom_right_x: float
+    bottom_right_y: float
+    center_x: float
+    center_y: float
+    data_url: str
+    points: List[MagicwandAnnotationPoint]
+    threshold: int
+    top_left_x: float
+    top_left_y: float
+
+    def __init__(self, bottom_right_x: float, bottom_right_y: float, center_x: float, center_y: float, data_url: str, points: List[MagicwandAnnotationPoint], threshold: int, top_left_x: float, top_left_y: float) -> None:
+        self.bottom_right_x = bottom_right_x
+        self.bottom_right_y = bottom_right_y
+        self.center_x = center_x
+        self.center_y = center_y
+        self.data_url = data_url
+        self.points = points
+        self.threshold = threshold
+        self.top_left_x = top_left_x
+        self.top_left_y = top_left_y
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'MagicwandAnnotation':
+        assert isinstance(obj, dict)
+        bottom_right_x = from_float(obj.get("bottom_right_x"))
+        bottom_right_y = from_float(obj.get("bottom_right_y"))
+        center_x = from_float(obj.get("center_x"))
+        center_y = from_float(obj.get("center_y"))
+        data_url = from_str(obj.get("dataURL"))
+        points = from_list(MagicwandAnnotationPoint.from_dict, obj.get("points"))
+        threshold = from_int(obj.get("threshold"))
+        top_left_x = from_float(obj.get("top_left_x"))
+        top_left_y = from_float(obj.get("top_left_y"))
+        return MagicwandAnnotation(bottom_right_x, bottom_right_y, center_x, center_y, data_url, points, threshold, top_left_x, top_left_y)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["bottom_right_x"] = to_float(self.bottom_right_x)
+        result["bottom_right_y"] = to_float(self.bottom_right_y)
+        result["center_x"] = to_float(self.center_x)
+        result["center_y"] = to_float(self.center_y)
+        result["dataURL"] = from_str(self.data_url)
+        result["points"] = from_list(lambda x: to_class(MagicwandAnnotationPoint, x), self.points)
+        result["threshold"] = from_int(self.threshold)
+        result["top_left_x"] = to_float(self.top_left_x)
+        result["top_left_y"] = to_float(self.top_left_y)
+        return result
+
+
+class PenAnnotationPoint:
+    x: float
+    y: float
+
+    def __init__(self, x: float, y: float) -> None:
+        self.x = x
+        self.y = y
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'PenAnnotationPoint':
+        assert isinstance(obj, dict)
+        x = from_float(obj.get("x"))
+        y = from_float(obj.get("y"))
+        return PenAnnotationPoint(x, y)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["x"] = to_float(self.x)
+        result["y"] = to_float(self.y)
+        return result
+
+
+class PenAnnotation:
+    bottom_right_x: float
+    bottom_right_y: float
+    data_url: str
+    points: List[PenAnnotationPoint]
+    thickness: float
+    top_left_x: float
+    top_left_y: float
+
+    def __init__(self, bottom_right_x: float, bottom_right_y: float, data_url: str, points: List[PenAnnotationPoint], thickness: float, top_left_x: float, top_left_y: float) -> None:
+        self.bottom_right_x = bottom_right_x
+        self.bottom_right_y = bottom_right_y
+        self.data_url = data_url
+        self.points = points
+        self.thickness = thickness
+        self.top_left_x = top_left_x
+        self.top_left_y = top_left_y
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'PenAnnotation':
+        assert isinstance(obj, dict)
+        bottom_right_x = from_float(obj.get("bottom_right_x"))
+        bottom_right_y = from_float(obj.get("bottom_right_y"))
+        data_url = from_str(obj.get("dataURL"))
+        points = from_list(PenAnnotationPoint.from_dict, obj.get("points"))
+        thickness = from_float(obj.get("thickness"))
+        top_left_x = from_float(obj.get("top_left_x"))
+        top_left_y = from_float(obj.get("top_left_y"))
+        return PenAnnotation(bottom_right_x, bottom_right_y, data_url, points, thickness, top_left_x, top_left_y)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["bottom_right_x"] = to_float(self.bottom_right_x)
+        result["bottom_right_y"] = to_float(self.bottom_right_y)
+        result["dataURL"] = from_str(self.data_url)
+        result["points"] = from_list(lambda x: to_class(PenAnnotationPoint, x), self.points)
+        result["thickness"] = to_float(self.thickness)
+        result["top_left_x"] = to_float(self.top_left_x)
+        result["top_left_y"] = to_float(self.top_left_y)
+        return result
+
+
+class PixelAnnotation:
+    blob_id: UUID
+    bottom_right_x: float
+    bottom_right_y: float
+    top_left_x: float
+    top_left_y: float
+
+    def __init__(self, blob_id: UUID, bottom_right_x: float, bottom_right_y: float, top_left_x: float, top_left_y: float) -> None:
+        self.blob_id = blob_id
+        self.bottom_right_x = bottom_right_x
+        self.bottom_right_y = bottom_right_y
+        self.top_left_x = top_left_x
+        self.top_left_y = top_left_y
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'PixelAnnotation':
+        assert isinstance(obj, dict)
+        blob_id = UUID(obj.get("blob_id"))
+        bottom_right_x = from_float(obj.get("bottom_right_x"))
+        bottom_right_y = from_float(obj.get("bottom_right_y"))
+        top_left_x = from_float(obj.get("top_left_x"))
+        top_left_y = from_float(obj.get("top_left_y"))
+        return PixelAnnotation(blob_id, bottom_right_x, bottom_right_y, top_left_x, top_left_y)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["blob_id"] = str(self.blob_id)
+        result["bottom_right_x"] = to_float(self.bottom_right_x)
+        result["bottom_right_y"] = to_float(self.bottom_right_y)
+        result["top_left_x"] = to_float(self.top_left_x)
+        result["top_left_y"] = to_float(self.top_left_y)
+        return result
+
+
+class PolygonAnnotationPoint:
+    x: float
+    y: float
+
+    def __init__(self, x: float, y: float) -> None:
+        self.x = x
+        self.y = y
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'PolygonAnnotationPoint':
+        assert isinstance(obj, dict)
+        x = from_float(obj.get("x"))
+        y = from_float(obj.get("y"))
+        return PolygonAnnotationPoint(x, y)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["x"] = to_float(self.x)
+        result["y"] = to_float(self.y)
+        return result
+
+
+class PolygonAnnotation:
+    points: List[PolygonAnnotationPoint]
+
+    def __init__(self, points: List[PolygonAnnotationPoint]) -> None:
+        self.points = points
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'PolygonAnnotation':
+        assert isinstance(obj, dict)
+        points = from_list(PolygonAnnotationPoint.from_dict, obj.get("points"))
+        return PolygonAnnotation(points)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["points"] = from_list(lambda x: to_class(PolygonAnnotationPoint, x), self.points)
+        return result
+
+
+class RectangleAnnotation:
+    bottom_right_x: float
+    bottom_right_y: float
+    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:
+        self.bottom_right_x = bottom_right_x
+        self.bottom_right_y = bottom_right_y
+        self.top_left_x = top_left_x
+        self.top_left_y = top_left_y
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'RectangleAnnotation':
+        assert isinstance(obj, dict)
+        bottom_right_x = from_float(obj.get("bottom_right_x"))
+        bottom_right_y = from_float(obj.get("bottom_right_y"))
+        top_left_x = from_float(obj.get("top_left_x"))
+        top_left_y = from_float(obj.get("top_left_y"))
+        return RectangleAnnotation(bottom_right_x, bottom_right_y, top_left_x, top_left_y)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["bottom_right_x"] = to_float(self.bottom_right_x)
+        result["bottom_right_y"] = to_float(self.bottom_right_y)
+        result["top_left_x"] = to_float(self.top_left_x)
+        result["top_left_y"] = to_float(self.top_left_y)
+        return result
+
+
+class SausageAnnotationPoint:
+    x: float
+    y: float
+
+    def __init__(self, x: float, y: float) -> None:
+        self.x = x
+        self.y = y
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'SausageAnnotationPoint':
+        assert isinstance(obj, dict)
+        x = from_float(obj.get("x"))
+        y = from_float(obj.get("y"))
+        return SausageAnnotationPoint(x, y)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["x"] = to_float(self.x)
+        result["y"] = to_float(self.y)
+        return result
+
+
+class SausageAnnotation:
+    bottom_right_x: float
+    bottom_right_y: float
+    data_url: str
+    points: List[SausageAnnotationPoint]
+    radius: float
+    top_left_x: float
+    top_left_y: float
+
+    def __init__(self, bottom_right_x: float, bottom_right_y: float, data_url: str, points: List[SausageAnnotationPoint], radius: float, top_left_x: float, top_left_y: float) -> None:
+        self.bottom_right_x = bottom_right_x
+        self.bottom_right_y = bottom_right_y
+        self.data_url = data_url
+        self.points = points
+        self.radius = radius
+        self.top_left_x = top_left_x
+        self.top_left_y = top_left_y
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'SausageAnnotation':
+        assert isinstance(obj, dict)
+        bottom_right_x = from_float(obj.get("bottom_right_x"))
+        bottom_right_y = from_float(obj.get("bottom_right_y"))
+        data_url = from_str(obj.get("dataURL"))
+        points = from_list(SausageAnnotationPoint.from_dict, obj.get("points"))
+        radius = from_float(obj.get("radius"))
+        top_left_x = from_float(obj.get("top_left_x"))
+        top_left_y = from_float(obj.get("top_left_y"))
+        return SausageAnnotation(bottom_right_x, bottom_right_y, data_url, points, radius, top_left_x, top_left_y)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["bottom_right_x"] = to_float(self.bottom_right_x)
+        result["bottom_right_y"] = to_float(self.bottom_right_y)
+        result["dataURL"] = from_str(self.data_url)
+        result["points"] = from_list(lambda x: to_class(SausageAnnotationPoint, x), self.points)
+        result["radius"] = to_float(self.radius)
+        result["top_left_x"] = to_float(self.top_left_x)
+        result["top_left_y"] = to_float(self.top_left_y)
+        return result
+
+
+class Annotation:
+    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]
+
+    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:
+        self.annotation_type = annotation_type
+        self.average_width = average_width
+        self.circle_annotation = circle_annotation
+        self.id = id
+        self.label_id = label_id
+        self.magicwand_annotation = magicwand_annotation
+        self.pen_annotation = pen_annotation
+        self.pixel_annotation = pixel_annotation
+        self.polygon_annotation = polygon_annotation
+        self.rectangle_annotation = rectangle_annotation
+        self.sausage_annotation = sausage_annotation
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Annotation':
+        assert isinstance(obj, dict)
+        annotation_type = AnnotationType(obj.get("annotation_type"))
+        average_width = from_float(obj.get("average_width"))
+        circle_annotation = from_union([CircleAnnotation.from_dict, from_none], obj.get("circle_annotation"))
+        id = UUID(obj.get("id"))
+        label_id = UUID(obj.get("label_id"))
+        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"))
+        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 Annotation(annotation_type, average_width, circle_annotation, id, label_id, magicwand_annotation, pen_annotation, pixel_annotation, polygon_annotation, rectangle_annotation, sausage_annotation)
+
+    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.circle_annotation is not None:
+            result["circle_annotation"] = from_union([lambda x: to_class(CircleAnnotation, x), from_none], self.circle_annotation)
+        result["id"] = str(self.id)
+        result["label_id"] = str(self.label_id)
+        if self.magicwand_annotation is not None:
+            result["magicwand_annotation"] = from_union([lambda x: to_class(MagicwandAnnotation, x), from_none], self.magicwand_annotation)
+        if self.pen_annotation is not None:
+            result["pen_annotation"] = from_union([lambda x: to_class(PenAnnotation, x), from_none], self.pen_annotation)
+        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)
+        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:
+            result["sausage_annotation"] = from_union([lambda x: to_class(SausageAnnotation, x), from_none], self.sausage_annotation)
+        return result
+
+
+class SegmentationMap:
+    blob_id: UUID
+    label_id: UUID
+    thumbnail: str
+
+    def __init__(self, blob_id: UUID, label_id: UUID, thumbnail: str) -> None:
+        self.blob_id = blob_id
+        self.label_id = label_id
+        self.thumbnail = thumbnail
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'SegmentationMap':
+        assert isinstance(obj, dict)
+        blob_id = UUID(obj.get("blob_id"))
+        label_id = UUID(obj.get("label_id"))
+        thumbnail = from_str(obj.get("thumbnail"))
+        return SegmentationMap(blob_id, label_id, thumbnail)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["blob_id"] = str(self.blob_id)
+        result["label_id"] = str(self.label_id)
+        result["thumbnail"] = from_str(self.thumbnail)
+        return result
+
+
+class SegmentationMarkup:
+    annotations: List[Annotation]
+    average_object_widths: List[float]
+    height: int
+    segmentation_maps: List[SegmentationMap]
+    width: int
+
+    def __init__(self, annotations: List[Annotation], average_object_widths: List[float], height: int, segmentation_maps: List[SegmentationMap], width: int) -> None:
+        self.annotations = annotations
+        self.average_object_widths = average_object_widths
+        self.height = height
+        self.segmentation_maps = segmentation_maps
+        self.width = width
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'SegmentationMarkup':
+        assert isinstance(obj, dict)
+        annotations = from_list(Annotation.from_dict, obj.get("annotations"))
+        average_object_widths = from_list(from_float, obj.get("average_object_widths"))
+        height = from_int(obj.get("height"))
+        segmentation_maps = from_list(SegmentationMap.from_dict, obj.get("segmentation_maps"))
+        width = from_int(obj.get("width"))
+        return SegmentationMarkup(annotations, average_object_widths, height, segmentation_maps, width)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["annotations"] = from_list(lambda x: to_class(Annotation, x), self.annotations)
+        result["average_object_widths"] = from_list(to_float, self.average_object_widths)
+        result["height"] = from_int(self.height)
+        result["segmentation_maps"] = from_list(lambda x: to_class(SegmentationMap, x), self.segmentation_maps)
+        result["width"] = from_int(self.width)
+        return result
+
+
+def segmentation_markup_from_dict(s: Any) -> SegmentationMarkup:
+    return SegmentationMarkup.from_dict(s)
+
+
+def segmentation_markup_to_dict(x: SegmentationMarkup) -> Any:
+    return to_class(SegmentationMarkup, x)

{denkproto-1.0.50.dist-info → denkproto-1.0.51.dist-info}/METADATA

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

{denkproto-1.0.50.dist-info → denkproto-1.0.51.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=ivQ8IyvwjMW_-3_T-j00QfCvzI3_qYhyqsprmcClAWo,23
+denkproto/__about__.py,sha256=QX1ke24vMqdXVlwT-R7XbSu-SafqDs-7vhbUduaYw8E,23
 denkproto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 denkproto/denkcache_pb2.py,sha256=fvrIvDfK8ED_w0EfO0tIrLMsBh2T5yvVI-sNFCK7NEQ,6627
 denkproto/denkcache_pb2.pyi,sha256=qOzFOkddUapSJZz5d_mqcfHvWDAmM-70m_7FeM7n5fI,5595
@@ -22,6 +22,11 @@ denkproto/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 denkproto/results_pb2.py,sha256=rBZ4HIHgdKHdASDbF8mTmZ0_xi1ffq3YJ2g_cvzIlhk,14109
 denkproto/results_pb2.pyi,sha256=8l1v1QenLzWlYnQtnCBqzXMMHUagOTalq9xJKfK6FKo,26711
 denkproto/results_pb2_grpc.py,sha256=z-4qcDMjjuPRy7lDtECTtReByVEyz3fjIPES9dMlO58,888
-denkproto-1.0.50.dist-info/METADATA,sha256=WvGgk0BrZbwOkK5yCJ6c7bgyAjMLiDb5BXqIQMcywSE,110
-denkproto-1.0.50.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-denkproto-1.0.50.dist-info/RECORD,,
+denkproto/json/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+denkproto/json/classification_markup.py,sha256=vTu0H7Cb3gU6UUUSg1vDTRlFUorZrjMbcp_yx6UssZA,2461
+denkproto/json/object_detection_markup.py,sha256=T0hcFPq8F_galjDjRC9dbcRVwCSOYtu2jt9wpEeHlQs,4904
+denkproto/json/ocr_markup.py,sha256=IaWbTCcJbLnS0e4u0PB1m8F-UpEwaQNTexVYKdXUPHI,5771
+denkproto/json/segmentation_markup.py,sha256=AQLZ-m7hq1hMPc9kLwhETaFPmTXfV3Omah5CIi-cJF0,19893
+denkproto-1.0.51.dist-info/METADATA,sha256=1_vBw4w2UsvpWnDNiVUEQ8WiLusa-ljkSJJiDzRY3vA,110
+denkproto-1.0.51.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+denkproto-1.0.51.dist-info/RECORD,,