datachain 0.6.10__tar.gz → 0.6.11__tar.gz

{datachain-0.6.10/src/datachain.egg-info → datachain-0.6.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: datachain
-Version: 0.6.10
+Version: 0.6.11
 Summary: Wrangle unstructured AI data at scale
 Author-email: Dmitry Petrov <support@dvc.org>
 License: Apache-2.0

datachain-0.6.11/src/datachain/lib/models/__init__.py

@@ -0,0 +1,5 @@
+from . import yolo
+from .bbox import BBox
+from .pose import Pose, Pose3D
+
+__all__ = ["BBox", "Pose", "Pose3D", "yolo"]

datachain-0.6.11/src/datachain/lib/models/bbox.py

@@ -0,0 +1,45 @@
+from typing import Optional
+
+from pydantic import Field
+
+from datachain.lib.data_model import DataModel
+
+
+class BBox(DataModel):
+    """
+    A data model for representing bounding boxes.
+
+    Attributes:
+        title (str): The title of the bounding box.
+        x1 (float): The x-coordinate of the top-left corner of the bounding box.
+        y1 (float): The y-coordinate of the top-left corner of the bounding box.
+        x2 (float): The x-coordinate of the bottom-right corner of the bounding box.
+        y2 (float): The y-coordinate of the bottom-right corner of the bounding box.
+
+    The bounding box is defined by two points:
+        - (x1, y1): The top-left corner of the box.
+        - (x2, y2): The bottom-right corner of the box.
+    """
+
+    title: str = Field(default="")
+    x1: float = Field(default=0)
+    y1: float = Field(default=0)
+    x2: float = Field(default=0)
+    y2: float = Field(default=0)
+
+    @staticmethod
+    def from_xywh(bbox: list[float], title: Optional[str] = None) -> "BBox":
+        """
+        Converts a bounding box in (x, y, width, height) format
+        to a BBox data model instance.
+
+        Args:
+            bbox (list[float]): A bounding box, represented as a list
+                                of four floats [x, y, width, height].
+
+        Returns:
+            BBox2D: An instance of the BBox data model.
+        """
+        assert len(bbox) == 4, f"Bounding box must have 4 elements, got f{len(bbox)}"
+        x, y, w, h = bbox
+        return BBox(title=title or "", x1=x, y1=y, x2=x + w, y2=y + h)

datachain-0.6.11/src/datachain/lib/models/pose.py

@@ -0,0 +1,37 @@
+from pydantic import Field
+
+from datachain.lib.data_model import DataModel
+
+
+class Pose(DataModel):
+    """
+    A data model for representing pose keypoints.
+
+    Attributes:
+        x (list[float]): The x-coordinates of the keypoints.
+        y (list[float]): The y-coordinates of the keypoints.
+
+    The keypoints are represented as lists of x and y coordinates, where each index
+    corresponds to a specific body part.
+    """
+
+    x: list[float] = Field(default=None)
+    y: list[float] = Field(default=None)
+
+
+class Pose3D(DataModel):
+    """
+    A data model for representing 3D pose keypoints.
+
+    Attributes:
+        x (list[float]): The x-coordinates of the keypoints.
+        y (list[float]): The y-coordinates of the keypoints.
+        visible (list[float]): The visibility of the keypoints.
+
+    The keypoints are represented as lists of x, y, and visibility values,
+    where each index corresponds to a specific body part.
+    """
+
+    x: list[float] = Field(default=None)
+    y: list[float] = Field(default=None)
+    visible: list[float] = Field(default=None)

datachain-0.6.11/src/datachain/lib/models/yolo.py

@@ -0,0 +1,39 @@
+"""
+This module contains the YOLO models.
+
+YOLO stands for "You Only Look Once", a family of object detection models that
+are designed to be fast and accurate. The models are trained to detect objects
+in images by dividing the image into a grid and predicting the bounding boxes
+and class probabilities for each grid cell.
+
+More information about YOLO can be found here:
+- https://pjreddie.com/darknet/yolo/
+- https://docs.ultralytics.com/
+"""
+
+
+class PoseBodyPart:
+    """
+    An enumeration of body parts for YOLO pose keypoints.
+
+    More information about the body parts can be found here:
+    https://docs.ultralytics.com/tasks/pose/
+    """
+
+    nose = 0
+    left_eye = 1
+    right_eye = 2
+    left_ear = 3
+    right_ear = 4
+    left_shoulder = 5
+    right_shoulder = 6
+    left_elbow = 7
+    right_elbow = 8
+    left_wrist = 9
+    right_wrist = 10
+    left_hip = 11
+    right_hip = 12
+    left_knee = 13
+    right_knee = 14
+    left_ankle = 15
+    right_ankle = 16

{datachain-0.6.10 → datachain-0.6.11}/src/datachain/sql/sqlite/types.py

@@ -36,7 +36,14 @@ def convert_array(arr):
 
 
 def adapt_np_array(arr):
-    return orjson.dumps(arr, option=orjson.OPT_SERIALIZE_NUMPY).decode("utf-8")
+    def _json_serialize(obj):
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        return obj
+
+    return orjson.dumps(
+        arr, option=orjson.OPT_SERIALIZE_NUMPY, default=_json_serialize
+    ).decode("utf-8")
 
 
 def adapt_np_generic(val):

{datachain-0.6.10 → datachain-0.6.11/src/datachain.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: datachain
-Version: 0.6.10
+Version: 0.6.11
 Summary: Wrangle unstructured AI data at scale
 Author-email: Dmitry Petrov <support@dvc.org>
 License: Apache-2.0

{datachain-0.6.10 → datachain-0.6.11}/src/datachain.egg-info/SOURCES.txt

@@ -131,11 +131,7 @@ src/datachain/lib/func/func.py
 src/datachain/lib/models/__init__.py
 src/datachain/lib/models/bbox.py
 src/datachain/lib/models/pose.py
-src/datachain/lib/models/segment.py
-src/datachain/lib/models/ultralytics/__init__.py
-src/datachain/lib/models/ultralytics/bbox.py
-src/datachain/lib/models/ultralytics/pose.py
-src/datachain/lib/models/ultralytics/segment.py
+src/datachain/lib/models/yolo.py
 src/datachain/query/__init__.py
 src/datachain/query/batch.py
 src/datachain/query/dataset.py
@@ -263,4 +259,5 @@ tests/unit/sql/test_random.py
 tests/unit/sql/test_selectable.py
 tests/unit/sql/test_string.py
 tests/unit/sql/sqlite/__init__.py
+tests/unit/sql/sqlite/test_types.py
 tests/unit/sql/sqlite/test_utils.py

datachain-0.6.11/tests/unit/lib/test_models.py

@@ -0,0 +1,50 @@
+from datachain.lib import models
+
+
+def test_bbox():
+    bbox = models.BBox(title="BBox", x1=0.5, y1=1.5, x2=2.5, y2=3.5)
+    assert bbox.model_dump() == {
+        "title": "BBox",
+        "x1": 0.5,
+        "y1": 1.5,
+        "x2": 2.5,
+        "y2": 3.5,
+    }
+
+
+def test_bbox_from_xywh():
+    bbox = models.BBox.from_xywh([0.5, 1.5, 2.5, 3.5])
+    assert bbox.model_dump() == {"title": "", "x1": 0.5, "y1": 1.5, "x2": 3, "y2": 5}
+
+    bbox = models.BBox.from_xywh([0.5, 1.5, 2.5, 3.5], title="BBox")
+    assert bbox.model_dump() == {
+        "title": "BBox",
+        "x1": 0.5,
+        "y1": 1.5,
+        "x2": 3,
+        "y2": 5,
+    }
+
+
+def test_pose():
+    x = [x * 0.5 for x in range(17)]
+    y = [y * 1.5 for y in range(17)]
+    pose = models.Pose(x=x, y=y)
+    assert pose.model_dump() == {"x": x, "y": y}
+    assert pose.x[models.yolo.PoseBodyPart.nose] == 0
+    assert pose.x[models.yolo.PoseBodyPart.left_eye] == 0.5
+    assert pose.x[models.yolo.PoseBodyPart.right_eye] == 1
+    assert pose.x[models.yolo.PoseBodyPart.left_ear] == 1.5
+    assert pose.x[models.yolo.PoseBodyPart.right_ear] == 2
+    assert pose.x[models.yolo.PoseBodyPart.left_shoulder] == 2.5
+    assert pose.x[models.yolo.PoseBodyPart.right_shoulder] == 3
+    assert pose.x[models.yolo.PoseBodyPart.left_elbow] == 3.5
+    assert pose.x[models.yolo.PoseBodyPart.right_elbow] == 4
+    assert pose.x[models.yolo.PoseBodyPart.left_wrist] == 4.5
+    assert pose.x[models.yolo.PoseBodyPart.right_wrist] == 5
+    assert pose.x[models.yolo.PoseBodyPart.left_hip] == 5.5
+    assert pose.x[models.yolo.PoseBodyPart.right_hip] == 6
+    assert pose.x[models.yolo.PoseBodyPart.left_knee] == 6.5
+    assert pose.x[models.yolo.PoseBodyPart.right_knee] == 7
+    assert pose.x[models.yolo.PoseBodyPart.left_ankle] == 7.5
+    assert pose.x[models.yolo.PoseBodyPart.right_ankle] == 8

datachain-0.6.11/tests/unit/sql/sqlite/test_types.py

@@ -0,0 +1,19 @@
+import numpy as np
+import pytest
+
+from datachain.sql.sqlite.types import adapt_np_array
+
+
+@pytest.mark.parametrize(
+    "dtype,arr,expected",
+    (
+        (float, [], "[]"),
+        (float, [0.5, 0.6], "[0.5,0.6]"),
+        (float, [[0.5, 0.6], [0.7, 0.8]], "[[0.5,0.6],[0.7,0.8]]"),
+        (np.dtypes.ObjectDType, [], "[]"),
+        (np.dtypes.ObjectDType, [0.5, 0.6], "[0.5,0.6]"),
+        (np.dtypes.ObjectDType, [[0.5, 0.6], [0.7, 0.8]], "[[0.5,0.6],[0.7,0.8]]"),
+    ),
+)
+def test_adapt_np_array(dtype, arr, expected):
+    assert adapt_np_array(np.array(arr, dtype=dtype)) == expected

datachain-0.6.10/src/datachain/lib/models/__init__.py

@@ -1,6 +0,0 @@
-from . import ultralytics
-from .bbox import BBox, OBBox
-from .pose import Pose, Pose3D
-from .segment import Segments
-
-__all__ = ["BBox", "OBBox", "Pose", "Pose3D", "Segments", "ultralytics"]

datachain-0.6.10/src/datachain/lib/models/bbox.py

@@ -1,116 +0,0 @@
-from pydantic import Field
-
-from datachain.lib.data_model import DataModel
-
-
-class BBox(DataModel):
-    """
-    A data model for representing bounding boxes.
-
-    Attributes:
-        title (str): The title of the bounding box.
-        coords (list[int]): The coordinates of the bounding box.
-
-    The bounding box is defined by two points:
-        - (x1, y1): The top-left corner of the box.
-        - (x2, y2): The bottom-right corner of the box.
-    """
-
-    title: str = Field(default="")
-    coords: list[int] = Field(default=None)
-
-    @staticmethod
-    def from_list(coords: list[float], title: str = "") -> "BBox":
-        assert len(coords) == 4, "Bounding box coordinates must be a list of 4 floats."
-        assert all(
-            isinstance(value, (int, float)) for value in coords
-        ), "Bounding box coordinates must be integers or floats."
-        return BBox(
-            title=title,
-            coords=[round(c) for c in coords],
-        )
-
-    @staticmethod
-    def from_dict(coords: dict[str, float], title: str = "") -> "BBox":
-        assert (
-            len(coords) == 4
-        ), "Bounding box coordinates must be a dictionary of 4 floats."
-        assert set(coords) == {
-            "x1",
-            "y1",
-            "x2",
-            "y2",
-        }, "Bounding box coordinates must contain keys with coordinates."
-        assert all(
-            isinstance(value, (int, float)) for value in coords.values()
-        ), "Bounding box coordinates must be integers or floats."
-        return BBox(
-            title=title,
-            coords=[
-                round(coords["x1"]),
-                round(coords["y1"]),
-                round(coords["x2"]),
-                round(coords["y2"]),
-            ],
-        )
-
-
-class OBBox(DataModel):
-    """
-    A data model for representing oriented bounding boxes.
-
-    Attributes:
-        title (str): The title of the oriented bounding box.
-        coords (list[int]): The coordinates of the oriented bounding box.
-
-    The oriented bounding box is defined by four points:
-        - (x1, y1): The first corner of the box.
-        - (x2, y2): The second corner of the box.
-        - (x3, y3): The third corner of the box.
-        - (x4, y4): The fourth corner of the box.
-    """
-
-    title: str = Field(default="")
-    coords: list[int] = Field(default=None)
-
-    @staticmethod
-    def from_list(coords: list[float], title: str = "") -> "OBBox":
-        assert (
-            len(coords) == 8
-        ), "Oriented bounding box coordinates must be a list of 8 floats."
-        assert all(
-            isinstance(value, (int, float)) for value in coords
-        ), "Oriented bounding box coordinates must be integers or floats."
-        return OBBox(
-            title=title,
-            coords=[round(c) for c in coords],
-        )
-
-    @staticmethod
-    def from_dict(coords: dict[str, float], title: str = "") -> "OBBox":
-        assert set(coords) == {
-            "x1",
-            "y1",
-            "x2",
-            "y2",
-            "x3",
-            "y3",
-            "x4",
-            "y4",
-        }, "Oriented bounding box coordinates must contain keys with coordinates."
-        assert all(
-            isinstance(value, (int, float)) for value in coords.values()
-        ), "Oriented bounding box coordinates must be integers or floats."
-        return OBBox(
-            title=title,
-            coords=[
-                round(coords["x1"]),
-                round(coords["y1"]),
-                round(coords["x2"]),
-                round(coords["y2"]),
-                round(coords["x3"]),
-                round(coords["y3"]),
-                round(coords["x4"]),
-                round(coords["y4"]),
-            ],
-        )

datachain-0.6.10/src/datachain/lib/models/pose.py

@@ -1,108 +0,0 @@
-from pydantic import Field
-
-from datachain.lib.data_model import DataModel
-
-
-class Pose(DataModel):
-    """
-    A data model for representing pose keypoints.
-
-    Attributes:
-        x (list[int]): The x-coordinates of the keypoints.
-        y (list[int]): The y-coordinates of the keypoints.
-
-    The keypoints are represented as lists of x and y coordinates, where each index
-    corresponds to a specific body part.
-    """
-
-    x: list[int] = Field(default=None)
-    y: list[int] = Field(default=None)
-
-    @staticmethod
-    def from_list(points: list[list[float]]) -> "Pose":
-        assert len(points) == 2, "Pose coordinates must be a list of 2 lists."
-        points_x, points_y = points
-        assert (
-            len(points_x) == len(points_y) == 17
-        ), "Pose x and y coordinates must have the same length of 17."
-        assert all(
-            isinstance(value, (int, float)) for value in [*points_x, *points_y]
-        ), "Pose coordinates must be integers or floats."
-        return Pose(
-            x=[round(coord) for coord in points_x],
-            y=[round(coord) for coord in points_y],
-        )
-
-    @staticmethod
-    def from_dict(points: dict[str, list[float]]) -> "Pose":
-        assert set(points) == {
-            "x",
-            "y",
-        }, "Pose coordinates must contain keys 'x' and 'y'."
-        points_x, points_y = points["x"], points["y"]
-        assert (
-            len(points_x) == len(points_y) == 17
-        ), "Pose x and y coordinates must have the same length of 17."
-        assert all(
-            isinstance(value, (int, float)) for value in [*points_x, *points_y]
-        ), "Pose coordinates must be integers or floats."
-        return Pose(
-            x=[round(coord) for coord in points_x],
-            y=[round(coord) for coord in points_y],
-        )
-
-
-class Pose3D(DataModel):
-    """
-    A data model for representing 3D pose keypoints.
-
-    Attributes:
-        x (list[int]): The x-coordinates of the keypoints.
-        y (list[int]): The y-coordinates of the keypoints.
-        visible (list[float]): The visibility of the keypoints.
-
-    The keypoints are represented as lists of x, y, and visibility values,
-    where each index corresponds to a specific body part.
-    """
-
-    x: list[int] = Field(default=None)
-    y: list[int] = Field(default=None)
-    visible: list[float] = Field(default=None)
-
-    @staticmethod
-    def from_list(points: list[list[float]]) -> "Pose3D":
-        assert len(points) == 3, "Pose coordinates must be a list of 3 lists."
-        points_x, points_y, points_v = points
-        assert (
-            len(points_x) == len(points_y) == len(points_v) == 17
-        ), "Pose x, y, and visibility coordinates must have the same length of 17."
-        assert all(
-            isinstance(value, (int, float))
-            for value in [*points_x, *points_y, *points_v]
-        ), "Pose coordinates must be integers or floats."
-        return Pose3D(
-            x=[round(coord) for coord in points_x],
-            y=[round(coord) for coord in points_y],
-            visible=points_v,
-        )
-
-    @staticmethod
-    def from_dict(points: dict[str, list[float]]) -> "Pose3D":
-        assert set(points) == {
-            "x",
-            "y",
-            "visible",
-        }, "Pose coordinates must contain keys 'x', 'y', and 'visible'."
-        points_x, points_y, points_v = points["x"], points["y"], points["visible"]
-        assert (
-            len(points_x) == len(points_y) == len(points_v) == 17
-        ), "Pose x, y, and visibility coordinates must have the same length of 17."
-        assert all(
-            isinstance(value, (int, float))
-            for value in [*points_x, *points_y, *points_v]
-        ), "Pose coordinates must be integers or floats."
-        return Pose3D(
-            x=[round(coord) for coord in points_x],
-            y=[round(coord) for coord in points_y],
-            visible=points_v,
-        )

datachain-0.6.10/src/datachain/lib/models/segment.py

@@ -1,53 +0,0 @@
-from pydantic import Field
-
-from datachain.lib.data_model import DataModel
-
-
-class Segments(DataModel):
-    """
-    A data model for representing segments.
-
-    Attributes:
-        title (str): The title of the segments.
-        x (list[int]): The x-coordinates of the segments.
-        y (list[int]): The y-coordinates of the segments.
-
-    The segments are represented as lists of x and y coordinates, where each index
-    corresponds to a specific segment.
-    """
-
-    title: str = Field(default="")
-    x: list[int] = Field(default=None)
-    y: list[int] = Field(default=None)
-
-    @staticmethod
-    def from_list(points: list[list[float]], title: str = "") -> "Segments":
-        assert len(points) == 2, "Segments coordinates must be a list of 2 lists."
-        points_x, points_y = points
-        assert len(points_x) == len(
-            points_y
-        ), "Segments x and y coordinates must have the same length."
-        assert all(
-            isinstance(value, (int, float)) for value in [*points_x, *points_y]
-        ), "Segments coordinates must be integers or floats."
-        return Segments(
-            title=title,
-            x=[round(coord) for coord in points_x],
-            y=[round(coord) for coord in points_y],
-        )
-
-    @staticmethod
-    def from_dict(points: dict[str, list[float]], title: str = "") -> "Segments":
-        assert set(points) == {
-            "x",
-            "y",
-        }, "Segments coordinates must contain keys 'x' and 'y'."
-        points_x, points_y = points["x"], points["y"]
-        assert all(
-            isinstance(value, (int, float)) for value in [*points_x, *points_y]
-        ), "Segments coordinates must be integers or floats."
-        return Segments(
-            title=title,
-            x=[round(coord) for coord in points_x],
-            y=[round(coord) for coord in points_y],
-        )

datachain-0.6.10/src/datachain/lib/models/ultralytics/__init__.py

@@ -1,14 +0,0 @@
-from .bbox import YoloBBox, YoloBBoxes, YoloOBBox, YoloOBBoxes
-from .pose import YoloPose, YoloPoses
-from .segment import YoloSegment, YoloSegments
-
-__all__ = [
-    "YoloBBox",
-    "YoloBBoxes",
-    "YoloOBBox",
-    "YoloOBBoxes",
-    "YoloPose",
-    "YoloPoses",
-    "YoloSegment",
-    "YoloSegments",
-]