modelstudio-sdk 0.0.0.dev0__py3-none-any.whl

modelstudio/resources/split.py

@@ -0,0 +1,140 @@
+"""Split sub-resource with per-split operations."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+from uuid import UUID
+
+from modelstudio.models.annotations import AnnotationModel
+from modelstudio.models.exports import ExportCocoModel, SegmentationExportModel
+from modelstudio.models.images import DatasetImageModel
+from modelstudio.models.imports import (
+    ImportQueuedModel,
+    PreImportValidationModel,
+    ValidationStartedModel,
+)
+
+if TYPE_CHECKING:
+    from modelstudio._http import HttpTransport
+
+
+class Split:
+    """Operations on a specific split within a dataset.
+
+    Access via ``client.dataset("ds-id").split("split-id")``.
+    """
+
+    def __init__(self, transport: HttpTransport, dataset_id: str, split_id: str) -> None:
+        self._t = transport
+        self._ds = dataset_id
+        self._sid = split_id
+        self._base = f"/api/v1/datasets/{dataset_id}/splits/{split_id}"
+
+    # ── CRUD ──────────────────────────────────────────────────────────
+
+    def patch_tao_id(self, tao_id: str | UUID) -> None:
+        """Update the TAO ID for this split."""
+        self._t.patch(self._base, json={"tao_id": str(tao_id)})
+
+    # ── Images ────────────────────────────────────────────────────────
+
+    def add_images(self, image_ids: list[str | UUID]) -> list[DatasetImageModel]:
+        """Add images to this split."""
+        data = self._t.post(
+            f"{self._base}/images",
+            json={"images": [{"image_id": str(i)} for i in image_ids]},
+        )
+        return [DatasetImageModel.model_validate(item) for item in data]
+
+    def remove_image(self, dataset_image_id: str | UUID) -> None:
+        """Remove an image from this split."""
+        self._t.delete(f"{self._base}/images/{dataset_image_id}")
+
+    def move_image(self, image_id: str | UUID, new_split_id: str | UUID) -> None:
+        """Move an image to another split."""
+        self._t.patch(
+            f"{self._base}/images/{image_id}/move",
+            json={"new_split_id": str(new_split_id)},
+        )
+
+    def list_images(self) -> list[DatasetImageModel]:
+        """List all images in this split."""
+        data = self._t.get(f"{self._base}/images")
+        return [DatasetImageModel.model_validate(item) for item in data]
+
+    # ── Annotations ─────────────────────────────────────────────────────
+
+    def list_annotations(self) -> list[AnnotationModel]:
+        """List all annotations in this split."""
+        data = self._t.get(f"{self._base}/annotations")
+        return [AnnotationModel.model_validate(item) for item in data]
+
+    # ── DataFrame helpers ───────────────────────────────────────────────
+
+    def images_df(self) -> Any:
+        """Return images as a pandas DataFrame."""
+        from modelstudio._pandas import to_dataframe
+
+        return to_dataframe(self.list_images())
+
+    def annotations_df(self) -> Any:
+        """Return annotations as a pandas DataFrame."""
+        from modelstudio._pandas import to_dataframe
+
+        return to_dataframe(self.list_annotations())
+
+    # ── Import ────────────────────────────────────────────────────────
+
+    def import_from_source(
+        self, source: str, type: str, config: dict[str, Any]
+    ) -> ImportQueuedModel:
+        """Start an import from a data source adapter (s3, labelbox, etc).
+
+        Args:
+            source: The data source (e.g. "s3", "labelbox").
+            type: The import type (e.g. "coco", "segmentation").
+            config: Source-specific configuration.
+        """
+        data = self._t.post_accepted(f"{self._base}/import/{source}/{type}", json=config)
+        return ImportQueuedModel.model_validate(data)
+
+    def import_segmentation(self, config: dict[str, Any]) -> SegmentationExportModel:
+        """Import segmentation masks from S3."""
+        data = self._t.post(f"{self._base}/import/s3/segmentation", json=config)
+        return SegmentationExportModel.model_validate(data)
+
+    def validate_import(self, config: dict[str, Any]) -> ValidationStartedModel:
+        """Start pre-import validation."""
+        data = self._t.post_accepted(f"{self._base}/import/s3/validate", json=config)
+        return ValidationStartedModel.model_validate(data)
+
+    def validation_status(self, validation_id: str) -> PreImportValidationModel:
+        """Check validation status."""
+        data = self._t.get(f"{self._base}/import/validate/{validation_id}")
+        return PreImportValidationModel.model_validate(data)
+
+    # ── Export ─────────────────────────────────────────────────────────
+
+    def export_coco(
+        self,
+        reindex_images: bool = True,
+        reindex_annotations: bool = True,
+        reindex_categories: bool = True,
+        starting_id: int = 1,
+    ) -> ExportCocoModel:
+        """Export this split as COCO JSON."""
+        data = self._t.post(
+            f"{self._base}/export/coco",
+            json={
+                "reindex_images": reindex_images,
+                "reindex_annotations": reindex_annotations,
+                "reindex_categories": reindex_categories,
+                "starting_id": starting_id,
+            },
+        )
+        return ExportCocoModel.model_validate(data)
+
+    def export_segmentation(self) -> SegmentationExportModel:
+        """Export segmentation masks for this split."""
+        data = self._t.post(f"{self._base}/export/segmentation")
+        return SegmentationExportModel.model_validate(data)

modelstudio_sdk-0.0.0.dev0.dist-info/METADATA

@@ -0,0 +1,513 @@
+Metadata-Version: 2.4
+Name: modelstudio-sdk
+Version: 0.0.0.dev0
+Summary: Python SDK for the Model Studio REST API
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: httpx<1.0,>=0.25.0
+Requires-Dist: pydantic<3.0,>=2.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.8; extra == 'dev'
+Requires-Dist: pandas>=1.5.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest-httpx>=0.30.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Provides-Extra: pandas
+Requires-Dist: pandas>=1.5.0; extra == 'pandas'
+Description-Content-Type: text/markdown
+
+# Model Studio Python SDK
+
+Python SDK for the Model Studio REST API. Provides typed access to dataset management, annotation tooling, metrics, and ML workflow operations.
+
+## Installation
+
+```bash
+# From wheel (in notebook containers, pre-installed)
+pip install modelstudio-sdk
+
+# Development install
+git clone https://gitlab.com/orbitalinsight/elements/model-studio/modelstudio-sdk.git
+cd modelstudio-sdk
+pip install -e ".[dev]"
+
+# With pandas support
+pip install "modelstudio-sdk[pandas]"
+```
+
+## Quick Start
+
+```python
+from modelstudio import ModelStudioClient
+
+# Auto-configured inside notebooks (reads env vars)
+client = ModelStudioClient.from_env()
+
+# Or explicit
+client = ModelStudioClient(
+    base_url="http://localhost:8081",
+    jwt_token="eyJhbG...",
+)
+
+# List datasets
+for ds in client.datasets.list():
+    print(f"{ds.name} ({ds.dataset_type})")
+```
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `MODEL_STUDIO_API_URL` | Yes | API base URL |
+| `MODEL_STUDIO_JWT` | No | JWT authentication token |
+| `MODEL_STUDIO_ORG` | No | Organization name |
+
+## Usage Examples
+
+### Dataset Operations
+
+```python
+ds = client.dataset("dataset-uuid")
+
+# Get overview statistics
+overview = ds.overview()
+print(f"Images: {overview.summary.total_images}")
+print(f"Annotations: {overview.summary.total_annotations}")
+
+# List splits
+for split in ds.splits():
+    print(f"{split.name} ({split.split_type})")
+
+# List categories
+cats = ds.categories()
+for cat in cats.categories:
+    print(f"{cat.name}: {cat.annotation_count} annotations")
+```
+
+### Split Operations
+
+```python
+# Create algorithmic splits
+ds.create_algorithmic_splits(
+    splits={"train": 0.7, "val": 0.15, "test": 0.15},
+    seed=42,
+)
+
+# Smart redistribution
+result = ds.smart_redistribute(
+    ratios={"train": 0.8, "val": 0.2},
+    prevent_tile_leakage=True,
+)
+
+# Check for data leakage
+leakage = ds.check_leakage()
+if leakage.has_leakage:
+    print(f"Found {leakage.leakage_count} leaked images")
+```
+
+### Category Management
+
+```python
+# Merge categories
+ds.merge_categories(
+    source_categories=[1, 2, 3],
+    target_category="vehicle",
+)
+
+# Rename a category
+ds.rename_category(category_id=5, new_name="truck")
+
+# Remove a category
+ds.remove_category(category_id=10)
+
+# Consolidate labels
+ds.consolidate_labels({"car": "vehicle", "van": "vehicle"})
+```
+
+### Working with Split Data
+
+```python
+split = ds.split("split-uuid")
+
+# List images
+images = split.list_images()
+
+# List annotations
+annotations = split.list_annotations()
+
+# Import from S3
+queued = split.import_from_source("s3", {
+    "connection_id": "conn-uuid",
+    "bucket": "my-bucket",
+    "prefix": "datasets/coco/",
+})
+
+# Wait for import to complete
+poller = split.import_poller(interval=5.0)
+result = poller.wait(callback=lambda r: print(f"Progress: {r.get('progress')}%"))
+```
+
+### Cloning & Async Operations
+
+```python
+# Clone a dataset
+cloned = ds.clone(name="My Clone")
+
+# Poll until complete
+poller = ds.clone_poller(interval=2.0, max_wait=300.0)
+result = poller.wait()
+print(f"Clone status: {result['clone_status']}")
+```
+
+### Validation & Quality
+
+```python
+# Validate dataset
+result = ds.validate()
+print(f"Valid: {result.valid}")
+
+# Check for duplicates
+dupes = ds.check_duplicates()
+if dupes.has_duplicates:
+    print(f"{dupes.total_duplicate_images} duplicate images found")
+
+# Detect temporal conflicts
+conflicts = ds.detect_temporal_conflicts()
+```
+
+### Export
+
+```python
+# Export as COCO JSON
+coco = ds.export_coco()
+print(f"Exported {coco.image_count} images, {coco.annotation_count} annotations")
+
+# Per-split export
+split_coco = split.export_coco()
+```
+
+### Filtering
+
+```python
+from modelstudio.models.filters import DatasetFilterRequest, CategoryFilter
+
+# Filter to specific categories
+result = ds.filter(DatasetFilterRequest(
+    category_filter=CategoryFilter(keep_categories=["car", "truck"]),
+    new_dataset_name="filtered-cars",
+))
+print(f"New dataset: {result.new_dataset_id}")
+```
+
+### Few-Shot & Oversampling
+
+```python
+from modelstudio.models.few_shot import FewShotRequest
+from modelstudio.models.oversample import OversampleRequest
+
+# Create few-shot dataset
+result = ds.few_shot_create(FewShotRequest(
+    num_images=100,
+    method="MOST_CLASSES",
+    new_dataset_name="few-shot-100",
+))
+
+# Oversample minority classes
+result = ds.oversample_execute(OversampleRequest(
+    target_ratio=0.5,
+    strategy="PREFER_ANNOTATED",
+))
+```
+
+### Dataset Merge
+
+```python
+from modelstudio.models.merge import MergeDatasetRequest
+
+# Analyze conflicts before merging
+analysis = client.datasets.merge_analyze(["ds-1", "ds-2"])
+
+# Merge datasets
+result = client.datasets.merge(MergeDatasetRequest(
+    source_dataset_ids=["ds-1", "ds-2"],
+    target_name="merged-dataset",
+))
+```
+
+### Undo/Redo
+
+```python
+# View history
+history = ds.history()
+for entry in history.changes:
+    print(f"{entry.operation_type}: {entry.short_description}")
+
+# Undo
+result = ds.undo()
+print(f"Undid: {result.description}")
+```
+
+### DataFrame Integration
+
+```python
+# Requires: pip install "modelstudio-sdk[pandas]"
+
+# Images as DataFrame
+df = split.images_df()
+
+# Annotations as DataFrame
+df = split.annotations_df()
+
+# Categories as DataFrame
+df = ds.categories_df()
+
+# Class distribution as DataFrame
+df = ds.class_distribution_df()
+```
+
+## Error Handling
+
+```python
+from modelstudio.exceptions import NotFoundError, ConflictError, BadRequestError
+
+try:
+    ds = client.dataset("nonexistent")
+    ds.overview()
+except NotFoundError as e:
+    print(f"Dataset not found: {e.message}")
+except ConflictError as e:
+    print(f"Operation conflict: {e.message}")
+except BadRequestError as e:
+    print(f"Invalid request: {e.message}")
+```
+
+## Architecture
+
+### Related Repositories
+
+| Repo | Purpose |
+|------|---------|
+| [`model-studio-sdk`](https://gitlab.com/orbitalinsight/elements/model-studio/modelstudio-sdk) | This repo — Python SDK + Jupyter Server Docker |
+| [`frontend`](https://gitlab.com/orbitalinsight/frontend-2.0) | Model Studio React frontend (custom notebook UI lives here) |
+| [`model-studio-api`](https://gitlab.com/orbitalinsight/elements/model-studio/model-studio-api) | Backend REST API the SDK wraps |
+| [`model-studio-notebooks`](https://gitlab.com/orbitalinsight/elements/model-studio/model-studio-notebooks) | JupyterHub + KubeSpawner Helm chart (production multi-user) |
+| [`model-studio-agent`](https://gitlab.com/orbitalinsight/elements/model-studio/model-studio-agent) | Agent chat backend |
+| [`keycloak-config`](https://gitlab.com/orbitalinsight/elements/keycloak-config) | Keycloak realm/client configuration |
+
+### Local Development Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  Browser (http://localhost:5173)                            │
+│                                                             │
+│  ┌───────────────────────────────────────────────────────┐  │
+│  │  Model Studio Frontend (Vite)                         │  │
+│  │  ┌──────────────┐  ┌──────────────┐  ┌────────────┐  │  │
+│  │  │ Dataset Pages │  │ Notebook     │  │ Agent Chat │  │  │
+│  │  │              │  │ Panel        │  │ Panel      │  │  │
+│  │  └──────────────┘  └──────┬───────┘  └─────┬──────┘  │  │
+│  └───────────────────────────┼────────────────┼──────────┘  │
+│                              │                │             │
+│  Vite Dev Server Proxies:    │                │             │
+│  /jupyter/* ─────────────────┘                │             │
+│  /agent/* ────────────────────────────────────┘             │
+└──────────────────────────────┼────────────────┼─────────────┘
+                               │                │
+              ┌────────────────┘                │
+              ▼                                 ▼
+┌──────────────────────────┐    ┌──────────────────────────┐
+│  Jupyter Server (Docker) │    │  Agent API               │
+│  localhost:8889          │    │  localhost:8080           │
+│                          │    │  (model-studio-agent)     │
+│  ┌────────────────────┐  │    └──────────────────────────┘
+│  │ Python 3.10 Kernel │  │
+│  │ + Model Studio SDK │  │              ▲
+│  └────────┬───────────┘  │              │
+└───────────┼──────────────┘              │
+            │                             │
+            ▼                             │
+┌──────────────────────────────────────────────────────────┐
+│  Model Studio API                                        │
+│  https://model-studio-api.model-studio.privateer-dev.com │
+│  (model-studio-api repo)                                 │
+└──────────────────────────────────────────────────────────┘
+```
+
+**Data flow**: User writes Python in the Notebook Panel → CodeMirror editor sends code via WebSocket to Jupyter kernel → kernel executes using the SDK → SDK calls Model Studio API → results render in the panel.
+
+### Production Architecture
+
+```
+┌──────────────────────────────────────────────────────────┐
+│  Browser                                                 │
+│  Model Studio Frontend (static build on CDN/Nginx)       │
+│  ┌──────────────┐  ┌──────────────┐  ┌────────────────┐ │
+│  │ Dataset Pages │  │ Notebook     │  │ Agent Chat     │ │
+│  │              │  │ Panel        │  │ Panel          │ │
+│  └──────────────┘  └──────┬───────┘  └────────────────┘ │
+└────────────────────────────┼─────────────────────────────┘
+                             │
+                             ▼
+┌──────────────────────────────────────────────────────────┐
+│  JupyterHub (model-studio-notebooks repo)                │
+│  - Keycloak OIDC auth                                    │
+│  - KubeSpawner → per-user Jupyter Server pods            │
+│  - Helm chart for K8s deployment                         │
+│                                                          │
+│  ┌──────────────────────────────────────────────────┐    │
+│  │  Per-User Jupyter Server (K8s Pod)               │    │
+│  │  ┌────────────────────┐                          │    │
+│  │  │ Python 3.10 Kernel │                          │    │
+│  │  │ + Model Studio SDK │                          │    │
+│  │  └────────┬───────────┘                          │    │
+│  └───────────┼──────────────────────────────────────┘    │
+└──────────────┼───────────────────────────────────────────┘
+               │
+               ▼
+┌──────────────────────────────────────────────────────────┐
+│  Model Studio API (K8s service)                          │
+└──────────────────────────────────────────────────────────┘
+```
+
+**Key difference**: In production, JupyterHub (from `model-studio-notebooks` repo) manages multi-user server lifecycle, auth, and resource limits. The custom notebook UI replaces JupyterLab's frontend but JupyterHub still manages server spawning.
+
+---
+
+## Development
+
+### Prerequisites
+
+- [Miniconda](https://docs.conda.io/en/latest/miniconda.html) or Anaconda
+- Docker + Docker Compose (for notebook server)
+- `jq` and `curl` (for Keycloak token fetch)
+
+### Quick Start — SDK Development
+
+```bash
+./develop.sh --mode setup              # Create conda env, install deps
+./develop.sh --mode test               # Run unit tests
+./develop.sh --mode test-integration   # Fetch Keycloak token + run integration tests
+./develop.sh --mode lint               # Run ruff + mypy
+```
+
+This creates a `model-studio-sdk` conda environment with Python 3.10 and installs the SDK in editable mode with all dev dependencies.
+
+### Quick Start — Custom Notebook UI
+
+The notebook UI spans two repos: the Jupyter Server backend (this repo) and the React frontend (`frontend` repo).
+
+**Terminal 1 — Start Jupyter Server:**
+
+```bash
+# From this repo (model-studio-sdk)
+./develop.sh --mode notebook-server
+```
+
+This prompts for Keycloak credentials, starts a headless Jupyter Server on port 8889 with the SDK pre-installed. The `src/` and `notebooks/` directories are volume-mounted for live reloading.
+
+**Terminal 2 — Start frontend:**
+
+```bash
+# From the frontend repo
+cd ../frontend
+source .go-privateer-dev.env
+yarn build-consts
+
+# First time only — install CodeMirror dependencies:
+yarn add @codemirror/view @codemirror/state @codemirror/commands @codemirror/lang-python @codemirror/theme-one-dark
+
+yarn start
+```
+
+**Verify the setup:**
+
+1. Open http://localhost:5173
+2. Click the **Notebook** button in the AppBar (next to Agent)
+3. Type `print('hello')` in the cell and press **Shift+Enter**
+4. Output should appear below the cell
+
+**How the proxy works**: The frontend's `vite.config.ts` proxies `/jupyter/*` requests to `localhost:8889` (the Docker Jupyter Server). This includes both REST API calls and WebSocket connections for kernel communication. No environment variables are needed — the proxy is configured in code.
+
+### JupyterLab Mode (Full Lab UI)
+
+If you need the traditional JupyterLab interface (e.g., for notebook authoring):
+
+```bash
+./develop.sh --mode docker     # Starts full JupyterLab on port 8888
+# or
+make docker
+```
+
+Open http://localhost:8888 for the JupyterLab UI. Notebooks are in the `notebooks/` directory.
+
+### Integration Tests
+
+Integration tests run against the live dev API and require a Keycloak JWT:
+
+```bash
+./develop.sh --mode test-integration
+```
+
+This will prompt for your Keycloak credentials (same as your Model Studio login), fetch a JWT, and run the integration test suite.
+
+To skip the auth prompt (e.g. if you already have a token):
+
+```bash
+export MODEL_STUDIO_JWT="eyJhbG..."
+./develop.sh --mode test-integration --skip-auth
+```
+
+Or set credentials as env vars to skip the interactive prompts:
+
+```bash
+export KEYCLOAK_USERNAME="you"
+export KEYCLOAK_PASSWORD="secret"
+./develop.sh --mode test-integration
+```
+
+### Make Targets
+
+If you prefer to manage your own environment, the Makefile targets still work:
+
+```bash
+make install              # pip install -e ".[dev]"
+make test                 # Unit tests with coverage
+make test-unit            # Unit tests only (no integration)
+make lint                 # ruff + mypy
+make build                # Build wheel
+make notebook-server      # Start headless Jupyter Server (port 8889)
+make notebook-server-down # Stop Jupyter Server
+make docker               # Start full JupyterLab (port 8888)
+make docker-down          # Stop JupyterLab
+```
+
+For integration tests without `develop.sh`:
+
+```bash
+eval "$(scripts/get-token.sh)" && make test-integration
+```
+
+### Docker Services
+
+The `docker/docker-compose.yml` defines two services:
+
+| Service | Port | Purpose |
+|---------|------|---------|
+| `notebook` | 8888 | Full JupyterLab with Lab UI (for notebook authoring) |
+| `jupyter-server` | 8889 | Headless Jupyter Server (for custom notebook UI backend) |
+
+Both use the same `Dockerfile.dev` base image (`jupyter/scipy-notebook:python-3.10`) with the SDK installed in editable mode. The `src/` directory is volume-mounted so SDK changes are picked up without rebuilding.
+
+The `jupyter-server` service additionally configures:
+- CORS headers for `http://localhost:5173` (Vite dev server)
+- Disabled XSRF checks (local dev only — production uses JupyterHub auth)
+- No authentication token (local dev only)
+
+## Requirements
+
+- Python >= 3.10
+- httpx >= 0.25.0
+- pydantic >= 2.0
+- pandas >= 1.5.0 (optional)

modelstudio_sdk-0.0.0.dev0.dist-info/RECORD

@@ -0,0 +1,32 @@
+modelstudio/__init__.py,sha256=fUUWQWqRNr_Cr0m9ZcewVMnLAiQknH4N5dd09z_u5VE,520
+modelstudio/_http.py,sha256=hh60cpb4P8bOV-Uth3PebvLzgA8r3ys2poWSjjUhg2M,3640
+modelstudio/_pandas.py,sha256=hR1SrguXj24o0hCALscVS1TphT5u5dwIzXcxFj3ZcCg,803
+modelstudio/_polling.py,sha256=v736GSpkqW_JURx5cYqexy_fTJpVXFV1_XtVGS0wgUM,1974
+modelstudio/_version.py,sha256=VVFmX0b3faB1pUjdw28IIgO-vzaO6x4Y9leJ6S4ePT4,27
+modelstudio/client.py,sha256=jKkt6YYSodIuDFPSbh2V7lIx4PElZQs6isWJYaOEpeQ,3245
+modelstudio/exceptions.py,sha256=Fl35fjajCFIxq7CpBYcjrqoURz3YRU-93Ds65j1GnME,2563
+modelstudio/models/__init__.py,sha256=2jmDWsD0IW54hSuXa3iUGwg-7wE8MiJWk0p-Tno9bpE,2023
+modelstudio/models/annotations.py,sha256=3QU0fUIQhs3epj1zJmONfPV2yOP7EZYISOM051efWDQ,2002
+modelstudio/models/categories.py,sha256=mnYa5zhScskfYklKve6kry1AxHycWeivEH70mZQVg-8,2938
+modelstudio/models/common.py,sha256=qEyYSK9oTISvrWLZJpv5cs2rEL-q5u2E8raSSFrXF4w,409
+modelstudio/models/datasets.py,sha256=07JWd-OwfgtYjgAENVZqbYDsFlN3Pn5moT95xcp45Eg,1504
+modelstudio/models/deletion.py,sha256=T9QbSvEaK6FzvDjo69LJcZapmaaiPCClwUXL3XHZveg,659
+modelstudio/models/exports.py,sha256=C_6qmts07B31gdZVApEmhHyD4XC916-XhCbms1oPLvk,897
+modelstudio/models/few_shot.py,sha256=BSpvRNODt26LsMe2mZcQHj-46n9NqaPDqDAaEP5EkIY,1084
+modelstudio/models/filters.py,sha256=ERE197Sla_lsHMEA5J9T0N_kp_6Ha_WStVQrfHLhHhM,2353
+modelstudio/models/history.py,sha256=OpcYyAJMRdzlPvsiTNjiXNNRs07SMcjugdtvslWcWfc,1476
+modelstudio/models/images.py,sha256=7UW0QY19j6Eio7TwNNCs2aFDnn5dchIcc5v4T6k35kk,2462
+modelstudio/models/imports.py,sha256=VinLPsOCsmvmDFCkrKRw1aV6Wb42_PDRWlcnS-QIfQI,3934
+modelstudio/models/media.py,sha256=htzbaxMZ3-h7OiuEykg8LIkwzBQNKdty_-OvwrORRts,843
+modelstudio/models/merge.py,sha256=OTYqQRCnAg6-80i8R3mnOXuJSDGwwamIr3XtkzeY6SE,1372
+modelstudio/models/metrics.py,sha256=PzyOfuChqf7uK6qfvMr9BQ1nos522AgrMSXzkd29fE4,5018
+modelstudio/models/oversample.py,sha256=JwdfTXYmIs6XqzPt_ltRiY3nyPWCWwSD1tNy1dUFY2M,1044
+modelstudio/models/splits.py,sha256=3LtY9JZq7YozJxBTH1sDNfCGaBIH3lrNWK0GpNNEOqg,3107
+modelstudio/models/validation.py,sha256=ptfQj_dd4VJXASTs0cGj-DvVY0Vq_TWusaCVZce3yPA,2254
+modelstudio/resources/__init__.py,sha256=iAw4TV6x37px7HavYD8_l4R-j4giAnO3MBRYWjEUwGI,50
+modelstudio/resources/dataset.py,sha256=CPW5keep_2l_lT77XRqLr0XGmABT3xqz-TbiKuC_DLk,30748
+modelstudio/resources/split.py,sha256=Rh8WVUoKG-kVkxcTB0Mi0FRjypWBrbhpmBBs_gW9mkU,6087
+modelstudio_sdk-0.0.0.dev0.dist-info/METADATA,sha256=2rVFmj7mthxGcN6NIpyVBjNVefJ5d-5TlBhJ2BledMg,18781
+modelstudio_sdk-0.0.0.dev0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+modelstudio_sdk-0.0.0.dev0.dist-info/licenses/LICENSE,sha256=WjcHhhxFV5wPppVsbAdR0m2aq5qxESD4J3k2EZiK0cw,1072
+modelstudio_sdk-0.0.0.dev0.dist-info/RECORD,,

modelstudio_sdk-0.0.0.dev0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any