unitlab 3.0.2__tar.gz → 3.0.3__tar.gz

{unitlab-3.0.2 → unitlab-3.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: unitlab
-Version: 3.0.2
+Version: 3.0.3
 Summary: Python SDK for the Unitlab.ai data annotation platform
 Project-URL: Homepage, https://unitlab.ai
 Project-URL: Documentation, https://docs.unitlab.ai

{unitlab-3.0.2 → unitlab-3.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "unitlab"
-version = "3.0.2"
+version = "3.0.3"
 description = "Python SDK for the Unitlab.ai data annotation platform"
 readme = "README.md"
 license = "MIT"

{unitlab-3.0.2 → unitlab-3.0.3}/src/unitlab/_uploader.py

@@ -56,10 +56,12 @@ TILED_EXTENSIONS = (
 EXTENSIONS_BY_GENERIC_TYPE: dict[str, set[str]] = {
     "img": {"jpg", "png", "jpeg", "webp", "gif", "bmp", "ico", "svg"},
     "text": {"txt"},
+    "html": {"html", "htm"},
     "video": {"mp4", "avi", "mov", "webm", "mkv", "m4v", "wmv", "flv"},
     "audio": {"mp3", "wav", "ogg", "aac", "flac", "m4a"},
     "medical": {"dcm", "nii", "nii.gz", "nrrd"},
     "document": {"pdf"},
+    "timeseries": {"csv"},
     "geospatial": AMBIGUOUS_TIFF_EXTENSIONS | GEOSPATIAL_TILED_EXTENSIONS,
     "pathology": PATHOLOGY_TILED_EXTENSIONS,
 }
@@ -396,6 +398,7 @@ async def _finalize_medical_upload(client, endpoint: str, batch_queue_id: str) -
 def _project_files(
     source: str | Path,
     upload_info: dict[str, Any],
+    generic_type: str | None = None,
 ) -> tuple[list[Path], list[UploadFailure]]:
     accepted = {
         str(value).lower().lstrip(".")
@@ -411,8 +414,10 @@ def _project_files(
     result = []
     failures = []
     for path in files:
-        generic_type = detect_generic_type(path.name) or project_type
-        max_size = max_sizes.get(generic_type)
+        file_generic_type = (
+            generic_type or detect_generic_type(path.name) or project_type
+        )
+        max_size = max_sizes.get(file_generic_type)
         if max_size is None and project_type and fallback is not None:
             max_size = int(fallback)
         if max_size is None or path.stat().st_size <= max_size:
@@ -435,6 +440,8 @@ async def _upload_project_async(
     *,
     session_id: str,
     fps: float,
+    generic_type: str | None,
+    primary_column: str | None,
     batch_size: int,
     show_progress: bool,
 ) -> UploadResult:
@@ -455,11 +462,15 @@ async def _upload_project_async(
                 tasks = []
                 generic_types = []
                 for path in chunk:
-                    generic_type = detect_generic_type(path.name)
-                    generic_types.append(generic_type)
+                    file_generic_type = generic_type or detect_generic_type(path.name)
+                    generic_types.append(file_generic_type)
                     fields = {"session_id": session_id}
-                    if generic_type == "video":
+                    if file_generic_type == "video":
                         fields["fps"] = str(fps)
+                    if generic_type is not None:
+                        fields["generic_type"] = generic_type
+                    if primary_column is not None:
+                        fields["primary_column"] = primary_column
                     tasks.append(
                         _upload_file(
                             client,
@@ -533,13 +544,15 @@ def upload_project(
     source: str | Path,
     *,
     fps: float = 1.0,
+    generic_type: str | None = None,
+    primary_column: str | None = None,
     batch_size: int = 100,
     show_progress: bool = True,
 ) -> tuple[UploadResult, str]:
     if batch_size < 1:
         raise ValueError("batch_size must be at least 1")
     upload_info = api.get(f"/api/sdk/projects/{project_id}/upload-info/")
-    files, preflight_failures = _project_files(source, upload_info)
+    files, preflight_failures = _project_files(source, upload_info, generic_type)
     if not files and not preflight_failures:
         accepted = upload_info.get("accepted_formats") or sorted(known_extensions())
         raise ValueError(
@@ -560,6 +573,8 @@ def upload_project(
             files,
             session_id=session_id,
             fps=fps,
+            generic_type=generic_type,
+            primary_column=primary_column,
             batch_size=batch_size,
             show_progress=show_progress,
         )
@@ -576,6 +591,9 @@ def _asset_form_data(
     path: str | None,
     tags: list[str] | None,
     custom_metadata: dict[str, Any] | None,
+    defer_timeseries_configuration: bool,
+    generic_type: str | None,
+    primary_column: str | None,
 ) -> dict[str, str | list[str]]:
     fields: dict[str, str | list[str]] = {}
     if folder:
@@ -592,6 +610,12 @@ def _asset_form_data(
             ensure_ascii=False,
             separators=(",", ":"),
         )
+    if defer_timeseries_configuration:
+        fields["defer_timeseries_configuration"] = "true"
+    if generic_type is not None:
+        fields["generic_type"] = generic_type
+    if primary_column is not None:
+        fields["primary_column"] = primary_column
     return fields
 
 
@@ -640,6 +664,9 @@ async def _upload_assets_async(
     path: str | None,
     tags: list[str] | None,
     custom_metadata: dict[str, Any] | None,
+    defer_timeseries_configuration: bool,
+    generic_type: str | None,
+    primary_column: str | None,
     show_progress: bool,
 ) -> tuple[UploadResult, str, str]:
     failures: list[UploadFailure] = []
@@ -668,6 +695,9 @@ async def _upload_assets_async(
                         path=path,
                         tags=tags,
                         custom_metadata=custom_metadata,
+                        defer_timeseries_configuration=defer_timeseries_configuration,
+                        generic_type=generic_type,
+                        primary_column=primary_column,
                     ),
                     tiled_endpoint="/api/sdk/data-assets/tiled-uploads",
                     complete_fields=_asset_complete_data(
@@ -708,6 +738,9 @@ async def _upload_assets_async(
                                 path=path,
                                 tags=tags,
                                 custom_metadata=custom_metadata,
+                                defer_timeseries_configuration=defer_timeseries_configuration,
+                                generic_type=generic_type,
+                                primary_column=primary_column,
                             ),
                             tiled_endpoint="/api/sdk/data-assets/tiled-uploads",
                             complete_fields=_asset_complete_data(
@@ -756,6 +789,9 @@ def upload_assets(
     path: str | None = None,
     tags: list[str] | None = None,
     custom_metadata: dict[str, Any] | None = None,
+    defer_timeseries_configuration: bool = False,
+    generic_type: str | None = None,
+    primary_column: str | None = None,
     show_progress: bool = True,
 ) -> tuple[UploadResult, str, str]:
     if folder and folder_id:
@@ -774,6 +810,9 @@ def upload_assets(
             path=path,
             tags=tags,
             custom_metadata=custom_metadata,
+            defer_timeseries_configuration=defer_timeseries_configuration,
+            generic_type=generic_type,
+            primary_column=primary_column,
             show_progress=show_progress,
         )
     )

{unitlab-3.0.2 → unitlab-3.0.3}/src/unitlab/ontology.py

@@ -15,6 +15,8 @@ class Shape(str, Enum):
     CUBOID = "cuboid"
     TIME_RANGE = "time_range"
     TEXT = "text"
+    INTERVAL = "interval"
+    INSTANT = "instant"
 
 
 class OntologyClassificationLevel(str, Enum):

{unitlab-3.0.2 → unitlab-3.0.3}/src/unitlab/resources/assets.py

@@ -26,6 +26,9 @@ class AssetsNamespace(Namespace):
         path: str | None = None,
         tags: list[str] | None = None,
         custom_metadata: dict[str, Any] | None = None,
+        defer_timeseries_configuration: bool = False,
+        generic_type: str | None = None,
+        primary_column: str | None = None,
     ) -> AssetUploadResult:
         """Upload local files into workspace Assets.
 
@@ -36,6 +39,12 @@ class AssetsNamespace(Namespace):
             path: Logical path created below the destination folder.
             tags: Tags applied to uploaded Assets.
             custom_metadata: User-owned JSON metadata applied to every upload.
+            defer_timeseries_configuration: Keep the legacy deferred chart flow
+                when ``generic_type="timeseries"`` is explicitly selected.
+            generic_type: Explicit upload family, such as ``tabular`` for CSV
+                row mode. Omitted CSV Assets remain family-neutral until they
+                are attached to a project.
+            primary_column: Preferred row-mode CSV text column.
 
         Returns:
             Successful Assets and per-file failures without discarding partial
@@ -49,6 +58,9 @@ class AssetsNamespace(Namespace):
             path=path,
             tags=tags,
             custom_metadata=custom_metadata,
+            defer_timeseries_configuration=defer_timeseries_configuration,
+            generic_type=generic_type,
+            primary_column=primary_column,
             show_progress=sys.stderr.isatty(),
         )
         assets = [
@@ -269,9 +281,7 @@ class Asset:
         )
 
     def status(self) -> ProcessingStatus:
-        raw = self._client._api.get(
-            f"/api/sdk/data-assets/assets/{self.id}/tiled-status/"
-        )
+        raw = self._client._api.get(f"/api/sdk/data-assets/assets/{self.id}/status/")
         self.upload_status = str(raw.get("upload_status", self.upload_status))
         return ProcessingStatus._from_raw(raw)
 
@@ -284,7 +294,7 @@ class Asset:
     ) -> ProcessingStatus:
         status = wait_for_status(
             self._client._api,
-            f"/api/sdk/data-assets/assets/{self.id}/tiled-status/",
+            f"/api/sdk/data-assets/assets/{self.id}/status/",
             resource_name=f"Asset {self.id}",
             timeout=timeout,
             on_progress=on_progress,
@@ -302,6 +312,19 @@ class Asset:
         self.upload_status = str(raw.get("status", "processing"))
         return raw
 
+    def configure_timeseries(
+        self,
+        *,
+        x_column: str,
+        channels: list[str],
+    ) -> dict[str, Any]:
+        raw = self._client._api.post(
+            f"/api/sdk/data-assets/assets/{self.id}/timeseries-configuration/",
+            json={"x_column": x_column, "channels": channels},
+        )
+        self.upload_status = str(raw.get("upload_status", self.upload_status))
+        return raw
+
     def update_custom_metadata(
         self,
         custom_metadata: dict[str, Any] | None,

{unitlab-3.0.2 → unitlab-3.0.3}/src/unitlab/resources/projects.py

@@ -256,6 +256,8 @@ class Project:
         source: str | Path,
         *,
         fps: float = 1.0,
+        generic_type: str | None = None,
+        primary_column: str | None = None,
         batch_size: int = 100,
     ) -> UploadBatch:
         """Upload local files into this Project.
@@ -263,17 +265,25 @@ class Project:
         Args:
             source: File or directory to upload.
             fps: Frame rate used for uploaded video.
+            generic_type: Explicit upload family, such as ``tabular`` for CSV
+                row mode. Omitted CSV uploads remain pending until configured
+                in the target project.
+            primary_column: Preferred row-mode CSV text column.
             batch_size: Files scheduled per local upload batch.
 
         Returns:
             Local upload results and the server-side Batch Queue ID. Server
-            processing may still be running.
+            processing may still be running. Declared ``tabular`` uploads are
+            accepted asynchronously and their datasource IDs are returned
+            immediately.
         """
         result, session_id = _uploader.upload_project(
             self._client._api,
             self.id,
             source,
             fps=fps,
+            generic_type=generic_type,
+            primary_column=primary_column,
             batch_size=batch_size,
             show_progress=sys.stderr.isatty(),
         )

{unitlab-3.0.2 → unitlab-3.0.3}/tests/test_client.py

@@ -252,6 +252,18 @@ def test_ontology_builder_and_client_contract():
     client.close()
 
 
+@pytest.mark.parametrize("shape_value", ("interval", "instant"))
+def test_timeseries_ontology_shapes_round_trip(shape_value):
+    shape = Shape(shape_value)
+    structure = OntologyStructure()
+
+    created = structure.add_object("Chart event", shape)
+    restored = OntologyStructure.from_dict(structure.to_dict()).objects[0]
+
+    assert created.shape is shape
+    assert restored.shape is shape
+
+
 def test_release_detail_parses_and_downloads(monkeypatch):
     def handler(request):
         assert request.url.path == "/api/sdk/releases/r1/"

{unitlab-3.0.2 → unitlab-3.0.3}/tests/test_tiled_uploads.py

@@ -503,8 +503,45 @@ def test_asset_status_wait_and_retry_use_sdk_endpoints():
     assert asset.retry() == {"task_id": "task-2", "status": "processing"}
     assert asset.upload_status == "processing"
     assert requests == [
-        ("GET", "/api/sdk/data-assets/assets/asset-1/tiled-status/"),
-        ("GET", "/api/sdk/data-assets/assets/asset-1/tiled-status/"),
+        ("GET", "/api/sdk/data-assets/assets/asset-1/status/"),
+        ("GET", "/api/sdk/data-assets/assets/asset-1/status/"),
         ("POST", "/api/sdk/data-assets/assets/asset-1/tiled-retry/"),
     ]
     client.close()
+
+
+def test_html_asset_status_and_wait_use_general_status_endpoint():
+    requests = []
+
+    def handler(request):
+        requests.append((request.method, request.url.path))
+        return httpx.Response(
+            200,
+            json={
+                "status": "completed",
+                "upload_status": "completed",
+                "total": 1,
+                "completed": 1,
+                "processing": 0,
+                "failed": 0,
+            },
+        )
+
+    client = configured_client(handler)
+    asset = Asset._from_raw(
+        client,
+        {
+            "pk": "asset-html",
+            "file_name": "page.html",
+            "generic_type": "html",
+            "upload_status": "processing",
+        },
+    )
+
+    assert asset.status().status == "completed"
+    assert asset.wait(show_progress=False).completed == 1
+    assert requests == [
+        ("GET", "/api/sdk/data-assets/assets/asset-html/status/"),
+        ("GET", "/api/sdk/data-assets/assets/asset-html/status/"),
+    ]
+    client.close()

{unitlab-3.0.2 → unitlab-3.0.3}/tests/test_uploader.py

@@ -8,12 +8,25 @@ from unitlab import (
     AuthenticationError,
     ProcessingTimeoutError,
     UnitlabClient,
+    _uploader,
     tiles_from_template,
 )
 from unitlab.resources.assets import Asset
 from unitlab.resources.projects import BatchQueue, Project
 
 
+@pytest.mark.parametrize(
+    ("filename", "generic_type"),
+    (("page.html", "html"), ("page.htm", "html"), ("series.csv", "timeseries")),
+)
+def test_html_and_timeseries_files_are_uploadable(tmp_path, filename, generic_type):
+    path = tmp_path / filename
+    path.write_bytes(b"content")
+
+    assert _uploader.detect_generic_type(filename) == generic_type
+    assert _uploader.collect_files(path) == [path]
+
+
 def configured_client(handler):
     transport = httpx.MockTransport(handler)
     client = UnitlabClient(api_key="key", api_url="http://testserver")
@@ -79,6 +92,49 @@ def test_project_upload_uses_one_batch_queue_and_chunks(tmp_path):
     client.close()
 
 
+def test_project_upload_can_select_tabular_csv_row_mode(tmp_path):
+    upload_body = ""
+
+    def handler(request):
+        nonlocal upload_body
+        if request.method == "GET":
+            return httpx.Response(
+                200,
+                json={
+                    "accepted_formats": ["csv"],
+                    "max_file_sizes": {"timeseries": 1_000, "tabular": 1_000},
+                    "generic_type": None,
+                },
+            )
+        upload_body = request.content.decode("latin1")
+        return httpx.Response(
+            202,
+            json={
+                "datasource_id": "row-1",
+                "upload_session_id": "queue-1",
+                "generic_type": "tabular",
+                "upload_status": "processing",
+                "task_id": "tabular-task-1",
+            },
+        )
+
+    path = tmp_path / "feedback.csv"
+    path.write_text("id,comment\n1,Great product\n")
+    client = configured_client(handler)
+    project = Project("p1", "Project", {"pk": "p1"}, client)
+
+    batch = project.upload(path, generic_type="tabular", primary_column="comment")
+
+    assert batch.uploaded == 1
+    assert batch.raw[0]["upload_status"] == "processing"
+    assert batch.raw[0]["task_id"] == "tabular-task-1"
+    assert 'name="generic_type"' in upload_body
+    assert "tabular" in upload_body
+    assert 'name="primary_column"' in upload_body
+    assert "comment" in upload_body
+    client.close()
+
+
 def test_project_upload_reports_oversized_files(tmp_path):
     uploads = 0
 
@@ -291,6 +347,113 @@ def test_asset_upload_resolves_folder_once_then_reuses_id(tmp_path):
     client.close()
 
 
+def test_asset_upload_can_select_tabular_csv_row_mode(tmp_path):
+    upload_body = ""
+
+    def handler(request):
+        nonlocal upload_body
+        upload_body = request.content.decode("latin1")
+        return httpx.Response(
+            201,
+            json={
+                "folder_id": "folder-1",
+                "folder_name": "Feedback",
+                "asset": {
+                    "pk": "asset-1",
+                    "file_name": "feedback.csv",
+                    "generic_type": "tabular",
+                    "folder_id": "folder-1",
+                },
+            },
+        )
+
+    path = tmp_path / "feedback.csv"
+    path.write_text("id,comment\n1,Great product\n")
+    client = configured_client(handler)
+
+    result = client.assets.upload(
+        path,
+        folder="Feedback",
+        generic_type="tabular",
+        primary_column="comment",
+    )
+
+    assert result.uploaded == 1
+    assert 'name="generic_type"' in upload_body
+    assert "tabular" in upload_body
+    assert 'name="primary_column"' in upload_body
+    assert "comment" in upload_body
+    client.close()
+
+
+def test_deferred_timeseries_upload_can_be_completed(tmp_path):
+    upload_body = ""
+
+    def handler(request):
+        nonlocal upload_body
+        if request.url.path == "/api/sdk/data-assets/upload/":
+            upload_body = request.content.decode("latin1")
+            return httpx.Response(
+                202,
+                json={
+                    "folder_id": "folder-1",
+                    "folder_name": "Charts",
+                    "timeseries_configuration_required": True,
+                    "configuration": {
+                        "columns": ["time", "value"],
+                        "defaults": {"x_column": "time", "channels": ["value"]},
+                    },
+                    "asset": {
+                        "pk": "asset-1",
+                        "file_name": "chart.csv",
+                        "generic_type": "timeseries",
+                        "folder_id": "folder-1",
+                        "upload_status": "processing",
+                    },
+                },
+            )
+        assert request.url.path == (
+            "/api/sdk/data-assets/assets/asset-1/timeseries-configuration/"
+        )
+        assert json.loads(request.content) == {
+            "x_column": "time",
+            "channels": ["value"],
+        }
+        return httpx.Response(
+            200,
+            json={
+                "asset_id": "asset-1",
+                "upload_status": "completed",
+                "timeseries_configuration_required": False,
+                "configuration": None,
+                "timeseries": {"x_column": "time", "channels": ["value"]},
+            },
+        )
+
+    path = tmp_path / "chart.csv"
+    path.write_text("time,value\n0,1\n1,2\n")
+    client = configured_client(handler)
+
+    result = client.assets.upload(
+        path,
+        folder="Charts",
+        defer_timeseries_configuration=True,
+    )
+    assert 'name="defer_timeseries_configuration"' in upload_body
+    assert "true" in upload_body
+    assert result.raw[0]["configuration"]["defaults"]["x_column"] == "time"
+    asset = result.assets[0]
+
+    configuration = asset.configure_timeseries(
+        x_column="time",
+        channels=["value"],
+    )
+
+    assert configuration["timeseries_configuration_required"] is False
+    assert asset.upload_status == "completed"
+    client.close()
+
+
 def test_asset_updates_custom_metadata():
     def handler(request):
         assert request.method == "PATCH"