datalier 0.1.0__tar.gz

datalier-0.1.0/LICENSE

@@ -0,0 +1,10 @@
+cat > ~/concave-platform/sdk/LICENSE << 'EOF'
+MIT License
+
+Copyright (c) 2026 Concave AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software" "Datalier by Concave AI"), to deal in the Software ("Datalier by Concave AI") without restriction, including without limitation the rightsto use, copy, modify, merge publish, distribute, sublicense, and/or sellcopies of the Software, and to permit persons to whom the Software ("Datalier by Concave AI") is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software ("Datalier by Concave AI").
+
+THE SOFTWARE ("Datalier by Concave AI") IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ORIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THEAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHERLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,OUT OF OR IN CONNECTION WITH THE SOFTWARE ("Datalier by Concave AI") OR THE USE OR OTHER DEALINGS IN THE SOFTWARE ("Datalier by Concave AI").EOF

datalier-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+include LICENSE

datalier-0.1.0/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: datalier
+Version: 0.1.0
+Summary: Datalier by Concave AI - data infrastructure for AI model training
+Author-email: Aniket Nerali <aniket.nerali@theconcaveai.com>
+License-Expression: MIT
+Project-URL: Homepage, https://theconcaveai.com
+Project-URL: Documentation, https://theconcaveai.com/docs
+Project-URL: Repository, https://github.com/thesineo/concave-platform
+Project-URL: Issues, https://github.com/thesineo/concave-platform/issues
+Keywords: datalier,concave-ai,ai,machine-learning,training-data,annotation,rlhf,rlaif,data-quality,data-infrastructure
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.27.0
+Dynamic: license-file
+
+# Datalier — by Concave AI
+
+Data infrastructure for AI model training. One SDK — raw data in, quality-assured training data out.
+
+## Installation
+
+```bash
+pip install datalier
+```
+
+## Quick Start
+
+```python
+from datalier import DatalierClient
+
+client = DatalierClient(
+    api_key="sk_concave_...",
+    base_url="https://api.theconcaveai.com",  # or http://localhost:8000 for local
+)
+
+# Upload a dataset
+dataset = client.upload("training_pairs.jsonl", dataset_type="rlhf")
+print(f"Uploaded: {dataset.id} — {dataset.row_count} rows")
+
+# Transform (validate, deduplicate, detect PII)
+result = client.transform(dataset.id, steps=["validate", "dedup", "pii_scan"])
+print(f"PII found: {result['pii_detection']['total_pii_found']}")
+
+# Label with RLAIF (AI handles 80-90%, humans review edge cases)
+result = client.label(dataset.id, dataset_type="rlhf", min_kappa=0.70)
+print(f"Auto-labeled: {result['ai_labeled']}/{result['total_tasks']}")
+
+# Check quality metrics
+quality = client.get_quality(dataset.id)
+print(f"Kappa: {quality.kappa} | Gold Accuracy: {quality.gold_accuracy}")
+
+# Approve and version
+client.approve(dataset.id)
+version = client.snapshot(dataset.id)
+print(f"Snapshot: {version['version']} — hash: {version['snapshot_hash'][:8]}...")
+
+# Export as DPO format for training
+download_url = client.export(dataset.id, fmt="dpo", version="v1.0")
+
+# Monitor model performance (Layer 5)
+model = client.register_model("my_model_v1", trained_on_dataset_id=dataset.id, trained_on_version="v1.0")
+client.submit_metrics(model["model_id"], accuracy=0.89, f1=0.85)
+drift = client.get_drift(model["model_id"])
+```
+
+## Platform Layers
+
+| Layer | Function | SDK Methods |
+|-------|----------|-------------|
+| **1 - Ingest** | Upload from any source | `upload()`, `list_datasets()`, `get_dataset()` |
+| **2 - Prepare** | Validate, dedup, PII scan | `transform()`, `get_profile()`, `get_pii_report()`, `redact()` |
+| **3 - Label** | RLAIF + human review | `label()`, `get_quality()`, `approve()` |
+| **4 - Version** | Snapshots + lineage | `snapshot()`, `list_versions()`, `get_lineage()`, `rollback()`, `export()` |
+| **5 - Observe** | Monitor + re-label loop | `register_model()`, `submit_metrics()`, `get_drift()`, `trigger_relabel()` |
+
+## Using with Local Dev Server
+
+```python
+client = DatalierClient(
+    api_key="your-jwt-token",
+    base_url="http://localhost:8000",
+)
+```
+
+## Links
+
+- **Website**: [theconcaveai.com](https://theconcaveai.com)
+- **Documentation**: [theconcaveai.com/docs](https://theconcaveai.com/docs)
+
+## License
+
+MIT — Concave AI 2026

datalier-0.1.0/README.md

@@ -0,0 +1,77 @@
+# Datalier — by Concave AI
+
+Data infrastructure for AI model training. One SDK — raw data in, quality-assured training data out.
+
+## Installation
+
+```bash
+pip install datalier
+```
+
+## Quick Start
+
+```python
+from datalier import DatalierClient
+
+client = DatalierClient(
+    api_key="sk_concave_...",
+    base_url="https://api.theconcaveai.com",  # or http://localhost:8000 for local
+)
+
+# Upload a dataset
+dataset = client.upload("training_pairs.jsonl", dataset_type="rlhf")
+print(f"Uploaded: {dataset.id} — {dataset.row_count} rows")
+
+# Transform (validate, deduplicate, detect PII)
+result = client.transform(dataset.id, steps=["validate", "dedup", "pii_scan"])
+print(f"PII found: {result['pii_detection']['total_pii_found']}")
+
+# Label with RLAIF (AI handles 80-90%, humans review edge cases)
+result = client.label(dataset.id, dataset_type="rlhf", min_kappa=0.70)
+print(f"Auto-labeled: {result['ai_labeled']}/{result['total_tasks']}")
+
+# Check quality metrics
+quality = client.get_quality(dataset.id)
+print(f"Kappa: {quality.kappa} | Gold Accuracy: {quality.gold_accuracy}")
+
+# Approve and version
+client.approve(dataset.id)
+version = client.snapshot(dataset.id)
+print(f"Snapshot: {version['version']} — hash: {version['snapshot_hash'][:8]}...")
+
+# Export as DPO format for training
+download_url = client.export(dataset.id, fmt="dpo", version="v1.0")
+
+# Monitor model performance (Layer 5)
+model = client.register_model("my_model_v1", trained_on_dataset_id=dataset.id, trained_on_version="v1.0")
+client.submit_metrics(model["model_id"], accuracy=0.89, f1=0.85)
+drift = client.get_drift(model["model_id"])
+```
+
+## Platform Layers
+
+| Layer | Function | SDK Methods |
+|-------|----------|-------------|
+| **1 - Ingest** | Upload from any source | `upload()`, `list_datasets()`, `get_dataset()` |
+| **2 - Prepare** | Validate, dedup, PII scan | `transform()`, `get_profile()`, `get_pii_report()`, `redact()` |
+| **3 - Label** | RLAIF + human review | `label()`, `get_quality()`, `approve()` |
+| **4 - Version** | Snapshots + lineage | `snapshot()`, `list_versions()`, `get_lineage()`, `rollback()`, `export()` |
+| **5 - Observe** | Monitor + re-label loop | `register_model()`, `submit_metrics()`, `get_drift()`, `trigger_relabel()` |
+
+## Using with Local Dev Server
+
+```python
+client = DatalierClient(
+    api_key="your-jwt-token",
+    base_url="http://localhost:8000",
+)
+```
+
+## Links
+
+- **Website**: [theconcaveai.com](https://theconcaveai.com)
+- **Documentation**: [theconcaveai.com/docs](https://theconcaveai.com/docs)
+
+## License
+
+MIT — Concave AI 2026

datalier-0.1.0/datalier/__init__.py

@@ -0,0 +1,7 @@
+from datalier.client import DatalierClient, DatasetInfo, QualityInfo, ModelInfo
+
+# backwards-compat alias
+JobInfo = ModelInfo
+
+__version__ = "0.1.0"
+__all__ = ["DatalierClient", "DatasetInfo", "QualityInfo", "ModelInfo", "JobInfo"]

datalier-0.1.0/datalier/client.py

@@ -0,0 +1,355 @@
+"""
+Datalier by Concave AI — Python SDK
+
+pip install datalier
+
+Usage:
+    from datalier import DatalierClient
+
+    client = DatalierClient(api_key="sk_concave_...", base_url="http://localhost:8000")
+
+    dataset = client.upload("data.jsonl", dataset_type="rlhf")
+    client.transform(dataset.id)
+    client.label(dataset.id)
+    quality = client.get_quality(dataset.id)
+    client.approve(dataset.id)
+    client.snapshot(dataset.id)
+    url = client.export(dataset.id, fmt="dpo")
+"""
+import httpx
+from typing import Optional, List
+from dataclasses import dataclass, field
+
+
+@dataclass
+class DatasetInfo:
+    id: str
+    name: str
+    type: str
+    status: str
+    file_format: str
+    row_count: int
+    schema: dict = field(default_factory=dict)
+
+
+@dataclass
+class QualityInfo:
+    dataset_id: str
+    kappa: float
+    gold_accuracy: float
+    bias_score: float
+    overall_status: str
+    automation_rate: float = 0.0
+
+
+@dataclass
+class ModelInfo:
+    model_id: str
+    name: str
+    status: str
+    drift_score: float = 0.0
+
+
+class DatalierClient:
+    """
+    Datalier by Concave AI — SDK Client.
+
+    Provides programmatic access to all 5 platform layers:
+      1. Ingest   — upload and connect data sources
+      2. Prepare  — validate, deduplicate, detect and redact PII
+      3. Label    — RLAIF pre-labeling with human review loop
+      4. Version  — immutable snapshots with full lineage
+      5. Observe  — model performance monitoring + drift detection
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://api.theconcaveai.com",
+    ):
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self._client = httpx.Client(
+            base_url=self.base_url,
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=120.0,
+        )
+
+    def _request(self, method: str, path: str, **kwargs) -> dict:
+        response = self._client.request(method, path, **kwargs)
+        if response.status_code >= 400:
+            try:
+                detail = response.json().get("detail", response.text)
+            except Exception:
+                detail = response.text
+            raise Exception(f"API Error {response.status_code}: {detail}")
+        return response.json()
+
+    def close(self):
+        self._client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    # ─── Layer 1: Ingest ──────────────────────────────────────────────────────
+
+    def upload(self, filepath: str, name: str = None,
+               dataset_type: str = "generic") -> DatasetInfo:
+        """Upload a local file and create a new dataset."""
+        with open(filepath, "rb") as f:
+            filename = filepath.split("/")[-1]
+            result = self._request(
+                "POST", "/api/v1/datasets/upload",
+                data={"name": name or filename, "dataset_type": dataset_type},
+                files={"file": (filename, f)},
+            )
+        return DatasetInfo(
+            id=result["dataset_id"],
+            name=result["name"],
+            type=dataset_type,
+            status=result["status"],
+            file_format=result["file_format"],
+            row_count=result["row_count"],
+            schema=result.get("schema_json", {}),
+        )
+
+    def get_dataset(self, dataset_id: str) -> DatasetInfo:
+        """Get dataset details."""
+        d = self._request("GET", f"/api/v1/datasets/{dataset_id}")
+        return DatasetInfo(
+            id=d["id"], name=d["name"], type=d.get("type", "generic"),
+            status=d["status"], file_format=d.get("file_format", ""),
+            row_count=d.get("row_count", 0), schema=d.get("schema_json", {}),
+        )
+
+    # ─── Layer 2: Prepare ─────────────────────────────────────────────────────
+
+    def transform(self, dataset_id: str,
+                  steps: Optional[List[str]] = None) -> dict:
+        """
+        Run the data preparation pipeline.
+        Returns full results: validation report, dedup stats, PII findings.
+        """
+        steps = steps or ["validate", "dedup", "pii_scan"]
+        return self._request(
+            "POST", f"/api/v1/datasets/{dataset_id}/transform",
+            json={"steps": steps},
+        )
+
+    def get_profile(self, dataset_id: str) -> dict:
+        """Get data profile — column types, null rates, unique counts."""
+        return self._request("GET", f"/api/v1/datasets/{dataset_id}/profile")
+
+    def get_pii_report(self, dataset_id: str) -> dict:
+        """Get PII detection report with findings per field."""
+        return self._request("GET", f"/api/v1/datasets/{dataset_id}/pii")
+
+    def redact(self, dataset_id: str, fields: List[str],
+               method: str = "mask") -> dict:
+        """Redact PII fields. method: 'mask' | 'hash' | 'remove'"""
+        return self._request(
+            "POST", f"/api/v1/datasets/{dataset_id}/redact",
+            json={"fields": fields, "method": method},
+        )
+
+    # ─── Layer 3: Label ───────────────────────────────────────────────────────
+
+    def label(self, dataset_id: str, dataset_type: str = "rlhf",
+              rlaif_model: str = "gpt-4o-mini",
+              confidence_threshold: float = 0.85,
+              min_kappa: float = 0.70) -> dict:
+        """
+        Start the RLAIF pre-labeling pipeline.
+        Returns: total_tasks, ai_labeled, human_review, automation_rate.
+        """
+        return self._request(
+            "POST", f"/api/v1/datasets/{dataset_id}/label",
+            json={
+                "type":                 dataset_type,
+                "rlaif_model":          rlaif_model,
+                "confidence_threshold": confidence_threshold,
+                "min_kappa":            min_kappa,
+            },
+        )
+
+    def get_quality(self, dataset_id: str) -> QualityInfo:
+        """Get real-time quality metrics: kappa, gold accuracy, bias score."""
+        q = self._request("GET", f"/api/v1/datasets/{dataset_id}/quality")
+        return QualityInfo(
+            dataset_id=q.get("dataset_id", dataset_id),
+            kappa=q.get("kappa", -1.0),
+            gold_accuracy=q.get("gold_accuracy", 0.0),
+            bias_score=q.get("bias_score", 0.0),
+            overall_status=q.get("overall_status", "pending_reviews"),
+            automation_rate=q.get("automation_rate", 0.0),
+        )
+
+    def list_tasks(self, dataset_id: str,
+                   status: Optional[str] = None) -> dict:
+        """List tasks, optionally filtered by status (e.g. 'human_review')."""
+        params = {}
+        if status:
+            params["status"] = status
+        return self._request("GET", f"/api/v1/datasets/{dataset_id}/tasks",
+                              params=params)
+
+    def submit_review(self, dataset_id: str, task_id: str,
+                      label: dict, reasoning: str = "") -> dict:
+        """Submit a human annotation for a task."""
+        body = {"label": label}
+        if reasoning:
+            body["reasoning"] = reasoning
+        return self._request(
+            "PUT", f"/api/v1/datasets/{dataset_id}/tasks/{task_id}",
+            json=body,
+        )
+
+    def approve(self, dataset_id: str) -> dict:
+        """Approve a labeled dataset — marks it ready for versioning."""
+        return self._request(
+            "POST", f"/api/v1/datasets/{dataset_id}/label/approve"
+        )
+
+    # ─── Layer 4: Version ─────────────────────────────────────────────────────
+
+    def snapshot(self, dataset_id: str, bump: str = "minor") -> dict:
+        """
+        Create an immutable versioned snapshot.
+        Returns: version, snapshot_hash, row_count, lineage_summary.
+        """
+        return self._request(
+            "POST", f"/api/v1/datasets/{dataset_id}/snapshot",
+            params={"bump": bump},
+        )
+
+    def list_versions(self, dataset_id: str) -> dict:
+        """List all versions with quality scores."""
+        return self._request("GET", f"/api/v1/datasets/{dataset_id}/versions")
+
+    def get_lineage(self, dataset_id: str, version: str) -> dict:
+        """Get full provenance for a dataset version."""
+        return self._request(
+            "GET", f"/api/v1/datasets/{dataset_id}/versions/{version}/lineage"
+        )
+
+    def rollback(self, dataset_id: str, version: str) -> dict:
+        """Rollback the active dataset to a previous version."""
+        return self._request(
+            "POST", f"/api/v1/datasets/{dataset_id}/rollback/{version}"
+        )
+
+    def diff(self, dataset_id: str, version_a: str, version_b: str) -> dict:
+        """Compare two versions — shows added, removed, unchanged rows."""
+        return self._request(
+            "GET", f"/api/v1/datasets/{dataset_id}/diff/{version_a}/{version_b}"
+        )
+
+    def export(self, dataset_id: str, fmt: str = "jsonl",
+               version: Optional[str] = None) -> str:
+        """
+        Export in training-ready format.
+        fmt: 'jsonl' | 'dpo' | 'conll' | 'coco' | 'csv' | 'json'
+        Returns the download URL.
+        """
+        params: dict = {"format": fmt}
+        if version:
+            params["version"] = version
+        result = self._request(
+            "POST", f"/api/v1/datasets/{dataset_id}/export",
+            params=params,
+        )
+        return result["download_url"]
+
+    # ─── Layer 5: Observe ─────────────────────────────────────────────────────
+
+    def register_model(self, name: str,
+                       trained_on_dataset_id: Optional[str] = None,
+                       trained_on_version: Optional[str] = None,
+                       min_accuracy: float = 0.80,
+                       max_drift_psi: float = 0.15) -> ModelInfo:
+        """Register a trained model for performance monitoring."""
+        result = self._request(
+            "POST", "/api/v1/models/register",
+            json={
+                "name":                  name,
+                "trained_on_dataset_id": trained_on_dataset_id,
+                "trained_on_version":    trained_on_version,
+                "min_accuracy":          min_accuracy,
+                "max_drift_psi":         max_drift_psi,
+            },
+        )
+        return ModelInfo(
+            model_id=result["model_id"],
+            name=result["name"],
+            status=result["status"],
+        )
+
+    def submit_metrics(self, model_id: str, **metrics) -> dict:
+        """
+        Submit performance metrics from your training platform.
+        Accepts any keyword args: accuracy=0.89, f1=0.85, loss=0.31, etc.
+        Automatically detects degradation and triggers re-labeling plan.
+        """
+        return self._request(
+            "POST", f"/api/v1/models/{model_id}/metrics",
+            json=metrics,
+        )
+
+    def ingest_webhook(self, model_id: str, payload: dict,
+                       source: str = "auto") -> dict:
+        """
+        Push metrics from MLflow, W&B, HuggingFace Evaluate, or generic.
+        source: 'auto' | 'mlflow' | 'wandb' | 'huggingface' | 'generic'
+        """
+        return self._request(
+            "POST", f"/api/v1/models/{model_id}/webhook-ingest",
+            json={"source": source, "payload": payload},
+        )
+
+    def submit_drift(self, model_id: str,
+                     training_distribution: dict,
+                     production_distribution: dict) -> dict:
+        """Submit training vs production distributions for PSI drift analysis."""
+        return self._request(
+            "POST", f"/api/v1/models/{model_id}/drift",
+            json={
+                "training_distribution":   training_distribution,
+                "production_distribution": production_distribution,
+            },
+        )
+
+    def get_drift(self, model_id: str) -> dict:
+        """Get latest drift score and history for a model."""
+        return self._request("GET", f"/api/v1/models/{model_id}/drift")
+
+    def get_performance(self, model_id: str) -> dict:
+        """Get full performance history with trend analysis."""
+        return self._request("GET", f"/api/v1/models/{model_id}/performance")
+
+    def trigger_relabel(self, model_id: str,
+                        categories: Optional[List[str]] = None) -> dict:
+        """Generate a re-labeling plan and get step-by-step loop instructions."""
+        body = {}
+        if categories:
+            body["categories"] = categories
+        return self._request(
+            "POST", f"/api/v1/models/{model_id}/trigger-relabel",
+            json=body,
+        )
+
+    def get_relabel_jobs(self, model_id: str) -> dict:
+        """Get full re-labeling job history for a model."""
+        return self._request(
+            "GET", f"/api/v1/models/{model_id}/relabel-jobs"
+        )
+
+    def dashboard(self) -> dict:
+        """Platform-wide health dashboard — all models, alerts, quality."""
+        return self._request("GET", "/api/v1/observe/dashboard")
+
+
+# Alias for backwards compatibility
+ConcaveClient = DatalierClient

datalier-0.1.0/datalier.egg-info/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: datalier
+Version: 0.1.0
+Summary: Datalier by Concave AI - data infrastructure for AI model training
+Author-email: Aniket Nerali <aniket.nerali@theconcaveai.com>
+License-Expression: MIT
+Project-URL: Homepage, https://theconcaveai.com
+Project-URL: Documentation, https://theconcaveai.com/docs
+Project-URL: Repository, https://github.com/thesineo/concave-platform
+Project-URL: Issues, https://github.com/thesineo/concave-platform/issues
+Keywords: datalier,concave-ai,ai,machine-learning,training-data,annotation,rlhf,rlaif,data-quality,data-infrastructure
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.27.0
+Dynamic: license-file
+
+# Datalier — by Concave AI
+
+Data infrastructure for AI model training. One SDK — raw data in, quality-assured training data out.
+
+## Installation
+
+```bash
+pip install datalier
+```
+
+## Quick Start
+
+```python
+from datalier import DatalierClient
+
+client = DatalierClient(
+    api_key="sk_concave_...",
+    base_url="https://api.theconcaveai.com",  # or http://localhost:8000 for local
+)
+
+# Upload a dataset
+dataset = client.upload("training_pairs.jsonl", dataset_type="rlhf")
+print(f"Uploaded: {dataset.id} — {dataset.row_count} rows")
+
+# Transform (validate, deduplicate, detect PII)
+result = client.transform(dataset.id, steps=["validate", "dedup", "pii_scan"])
+print(f"PII found: {result['pii_detection']['total_pii_found']}")
+
+# Label with RLAIF (AI handles 80-90%, humans review edge cases)
+result = client.label(dataset.id, dataset_type="rlhf", min_kappa=0.70)
+print(f"Auto-labeled: {result['ai_labeled']}/{result['total_tasks']}")
+
+# Check quality metrics
+quality = client.get_quality(dataset.id)
+print(f"Kappa: {quality.kappa} | Gold Accuracy: {quality.gold_accuracy}")
+
+# Approve and version
+client.approve(dataset.id)
+version = client.snapshot(dataset.id)
+print(f"Snapshot: {version['version']} — hash: {version['snapshot_hash'][:8]}...")
+
+# Export as DPO format for training
+download_url = client.export(dataset.id, fmt="dpo", version="v1.0")
+
+# Monitor model performance (Layer 5)
+model = client.register_model("my_model_v1", trained_on_dataset_id=dataset.id, trained_on_version="v1.0")
+client.submit_metrics(model["model_id"], accuracy=0.89, f1=0.85)
+drift = client.get_drift(model["model_id"])
+```
+
+## Platform Layers
+
+| Layer | Function | SDK Methods |
+|-------|----------|-------------|
+| **1 - Ingest** | Upload from any source | `upload()`, `list_datasets()`, `get_dataset()` |
+| **2 - Prepare** | Validate, dedup, PII scan | `transform()`, `get_profile()`, `get_pii_report()`, `redact()` |
+| **3 - Label** | RLAIF + human review | `label()`, `get_quality()`, `approve()` |
+| **4 - Version** | Snapshots + lineage | `snapshot()`, `list_versions()`, `get_lineage()`, `rollback()`, `export()` |
+| **5 - Observe** | Monitor + re-label loop | `register_model()`, `submit_metrics()`, `get_drift()`, `trigger_relabel()` |
+
+## Using with Local Dev Server
+
+```python
+client = DatalierClient(
+    api_key="your-jwt-token",
+    base_url="http://localhost:8000",
+)
+```
+
+## Links
+
+- **Website**: [theconcaveai.com](https://theconcaveai.com)
+- **Documentation**: [theconcaveai.com/docs](https://theconcaveai.com/docs)
+
+## License
+
+MIT — Concave AI 2026

datalier-0.1.0/datalier.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+datalier/__init__.py
+datalier/client.py
+datalier.egg-info/PKG-INFO
+datalier.egg-info/SOURCES.txt
+datalier.egg-info/dependency_links.txt
+datalier.egg-info/requires.txt
+datalier.egg-info/top_level.txt

datalier-0.1.0/datalier.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

datalier-0.1.0/datalier.egg-info/requires.txt

@@ -0,0 +1 @@
+httpx>=0.27.0

datalier-0.1.0/datalier.egg-info/top_level.txt

@@ -0,0 +1 @@
+datalier

datalier-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "datalier"
+version = "0.1.0"
+description = "Datalier by Concave AI - data infrastructure for AI model training"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+authors = [
+    {name = "Aniket Nerali", email = "aniket.nerali@theconcaveai.com"}
+]
+keywords = ["datalier", "concave-ai", "ai", "machine-learning", "training-data", "annotation", "rlhf", "rlaif", "data-quality", "data-infrastructure"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "httpx>=0.27.0",
+]
+
+[project.urls]
+Homepage = "https://theconcaveai.com"
+Documentation = "https://theconcaveai.com/docs"
+Repository = "https://github.com/thesineo/concave-platform"
+Issues = "https://github.com/thesineo/concave-platform/issues"

datalier-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

datalier-0.1.0/setup.py

@@ -0,0 +1,2 @@
+from setuptools import setup, find_packages
+setup(packages=find_packages())