synthgraph-sdk 0.1.0__py3-none-any.whl

synthgraph/__init__.py

@@ -0,0 +1,34 @@
+from .client import SynthGraphClient
+from .config import SynthGraphConfig
+from .http import SynthGraphHTTPClient, SynthGraphHTTPError
+from .models import (
+    AssetReference,
+    DataReference,
+    DatasetReference,
+    Experiment,
+    GenerationRun,
+    GenerationStatus,
+    Generator,
+    Project,
+    Reproducibility,
+)
+from .projects import ProjectsAPI
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "AssetReference",
+    "DataReference",
+    "DatasetReference",
+    "Experiment",
+    "GenerationRun",
+    "GenerationStatus",
+    "Generator",
+    "Project",
+    "ProjectsAPI",
+    "Reproducibility",
+    "SynthGraphClient",
+    "SynthGraphConfig",
+    "SynthGraphHTTPClient",
+    "SynthGraphHTTPError",
+]

synthgraph/client.py

@@ -0,0 +1,69 @@
+from types import TracebackType
+from typing import Any, Self
+
+from .config import SynthGraphConfig
+from .experiments import ExperimentsAPI
+from .generations import GenerationsAPI
+from .http import SynthGraphHTTPClient
+from .projects import ProjectsAPI
+
+
+class SynthGraphClient:
+    """Public client for interacting with the SynthGraph API."""
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        *,
+        api_url: str | None = None,
+        timeout: float | None = None,
+        config: SynthGraphConfig | None = None,
+        transport: Any | None = None,
+    ) -> None:
+        if config is not None:
+            if any(
+                value is not None
+                for value in (api_key, api_url, timeout)
+            ):
+                raise ValueError(
+                    "config cannot be combined with api_key, api_url, "
+                    "or timeout"
+                )
+            self.config = config
+        else:
+            config_kwargs: dict[str, Any] = {}
+
+            if api_key is not None:
+                config_kwargs["api_key"] = api_key
+
+            if api_url is not None:
+                config_kwargs["api_url"] = api_url
+
+            if timeout is not None:
+                config_kwargs["timeout"] = timeout
+
+            self.config = SynthGraphConfig(**config_kwargs)
+
+        self._http = SynthGraphHTTPClient(
+            self.config,
+            transport=transport,
+        )
+
+        self.projects = ProjectsAPI(self._http)
+        self.experiments = ExperimentsAPI(self._http)
+        self.generations = GenerationsAPI(self._http)
+
+    def close(self) -> None:
+        """Close the underlying HTTP client."""
+        self._http.close()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        self.close()

synthgraph/config.py

@@ -0,0 +1,23 @@
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+
+class SynthGraphConfig(BaseModel):
+    """Configuration for communicating with the SynthGraph backend."""
+
+    model_config = ConfigDict(frozen=True)
+
+    api_url: str = Field(
+        default="https://synthgraph.onrender.com",
+        min_length=1,
+    )
+    api_key: str | None = None
+    timeout: float = Field(
+        default=30.0,
+        gt=0,
+    )
+
+    @field_validator("api_url")
+    @classmethod
+    def normalize_api_url(cls, value: str) -> str:
+        """Remove trailing slashes from the API URL."""
+        return value.rstrip("/")

synthgraph/experiments.py

@@ -0,0 +1,52 @@
+from typing import Any
+
+from .http import SynthGraphHTTPClient
+from .models import Experiment
+
+
+class ExperimentsAPI:
+    """API operations for SynthGraph experiments."""
+
+    def __init__(self, http: SynthGraphHTTPClient) -> None:
+        self._http = http
+
+    def create(
+        self,
+        *,
+        project_id: str,
+        name: str,
+        description: str | None = None,
+    ) -> Experiment:
+        """Create a new experiment within a project."""
+        payload: dict[str, Any] = {
+            "name": name,
+        }
+
+        if description is not None:
+            payload["description"] = description
+
+        data = self._http.post(
+            f"/projects/{project_id}/experiments",
+            json=payload,
+        )
+
+        return Experiment.model_validate(data)
+
+    def get(self, experiment_id: str) -> Experiment:
+        """Retrieve an experiment by ID."""
+        data = self._http.get(
+            f"/experiments/{experiment_id}",
+        )
+
+        return Experiment.model_validate(data)
+
+    def list(self, *, project_id: str) -> list[Experiment]:
+        """List experiments belonging to a project."""
+        data = self._http.get_list(
+            f"/projects/{project_id}/experiments",
+        )
+
+        return [
+            Experiment.model_validate(item)
+            for item in data
+        ]

synthgraph/generations.py

@@ -0,0 +1,124 @@
+from typing import Any
+
+from .http import SynthGraphHTTPClient
+from .models import (
+    AssetReference,
+    DatasetReference,
+    GenerationRun,
+    GenerationStatus,
+    Generator,
+    Reproducibility,
+)
+
+
+class GenerationsAPI:
+    """API operations for generation runs."""
+
+    def __init__(self, http: SynthGraphHTTPClient) -> None:
+        self._http = http
+
+    def create(
+        self,
+        *,
+        experiment_id: str,
+        name: str,
+        generator: Generator,
+        parameters: dict[str, Any],
+        reproducibility: Reproducibility,
+        inputs: list[str | AssetReference | DatasetReference] | None = None,
+        outputs: list[str | AssetReference | DatasetReference] | None = None,
+    ) -> GenerationRun:
+        """Create a new generation run within an experiment."""
+        payload = {
+            "name": name,
+            "generator": generator.model_dump(
+                mode="json",
+                exclude_none=True,
+            ),
+            "parameters": parameters,
+            "reproducibility": reproducibility.model_dump(
+                mode="json",
+                exclude_none=True,
+                exclude_defaults=True,
+            ),
+            "inputs": [
+                reference.model_dump(mode="json")
+                if isinstance(
+                    reference,
+                    (AssetReference, DatasetReference),
+                )
+                else {"id": reference}
+                for reference in (inputs or [])
+            ],
+            "outputs": [
+                reference.model_dump(mode="json")
+                if isinstance(
+                    reference,
+                    (AssetReference, DatasetReference),
+                )
+                else {"id": reference}
+                for reference in (outputs or [])
+            ],
+        }
+
+        data = self._http.post(
+            f"/experiments/{experiment_id}/generations",
+            json=payload,
+        )
+
+        return GenerationRun.model_validate(data)
+
+    def get(self, generation_id: str) -> GenerationRun:
+        """Retrieve a generation run by ID."""
+        data = self._http.get(
+            f"/generations/{generation_id}",
+        )
+
+        return GenerationRun.model_validate(data)
+
+    def list(self, *, experiment_id: str) -> list[GenerationRun]:
+        """List generation runs belonging to an experiment."""
+        data = self._http.get_list(
+            f"/experiments/{experiment_id}/generations",
+        )
+
+        return [
+            GenerationRun.model_validate(item)
+            for item in data
+        ]
+
+    def start(self, generation_id: str) -> GenerationRun:
+        """Mark a generation run as running."""
+        return self._update_status(
+            generation_id,
+            GenerationStatus.RUNNING,
+        )
+
+    def complete(self, generation_id: str) -> GenerationRun:
+        """Mark a generation run as completed."""
+        return self._update_status(
+            generation_id,
+            GenerationStatus.COMPLETED,
+        )
+
+    def fail(self, generation_id: str) -> GenerationRun:
+        """Mark a generation run as failed."""
+        return self._update_status(
+            generation_id,
+            GenerationStatus.FAILED,
+        )
+
+    def _update_status(
+        self,
+        generation_id: str,
+        status: GenerationStatus,
+    ) -> GenerationRun:
+        """Update the lifecycle status of a generation run."""
+        data = self._http.patch(
+            f"/generations/{generation_id}",
+            json={
+                "status": status.value,
+            },
+        )
+
+        return GenerationRun.model_validate(data)

synthgraph/http.py

@@ -0,0 +1,174 @@
+from types import TracebackType
+from typing import Any, Self
+
+import httpx
+
+from .config import SynthGraphConfig
+
+
+class SynthGraphHTTPError(Exception):
+    """Raised when a SynthGraph API request fails."""
+
+    def __init__(self, status_code: int, message: str) -> None:
+        self.status_code = status_code
+        self.message = message
+
+        super().__init__(
+            f"SynthGraph API request failed with status "
+            f"{status_code}: {message}"
+        )
+
+
+class SynthGraphHTTPClient:
+    """Low-level HTTP client for the SynthGraph API."""
+
+    def __init__(
+        self,
+        config: SynthGraphConfig,
+        *,
+        transport: httpx.BaseTransport | None = None,
+    ) -> None:
+        self.config = config
+
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        if config.api_key is not None:
+            headers["Authorization"] = f"Bearer {config.api_key}"
+
+        self._client = httpx.Client(
+            base_url=config.api_url.rstrip("/"),
+            headers=headers,
+            timeout=config.timeout,
+            transport=transport,
+        )
+
+    def get(self, path: str) -> dict[str, Any]:
+        """Send a GET request expecting a JSON object response."""
+        response = self._client.get(path)
+
+        return self._handle_response(response)
+
+    def get_list(self, path: str) -> list[dict[str, Any]]:
+        """Send a GET request expecting a JSON array response."""
+        response = self._client.get(path)
+
+        return self._handle_list_response(response)
+
+    def post(
+        self,
+        path: str,
+        *,
+        json: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Send a POST request, optionally with a JSON body."""
+        if json is None:
+            response = self._client.post(path)
+        else:
+            response = self._client.post(path, json=json)
+
+        return self._handle_response(response)
+
+    def patch(
+        self,
+        path: str,
+        *,
+        json: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Send a PATCH request, optionally with a JSON body."""
+        if json is None:
+            response = self._client.patch(path)
+        else:
+            response = self._client.patch(path, json=json)
+
+        return self._handle_response(response)
+    
+    def close(self) -> None:
+        """Close the underlying HTTP client."""
+        self._client.close()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        self.close()
+
+    @staticmethod
+    def _handle_response(
+        response: httpx.Response,
+    ) -> dict[str, Any]:
+        """Validate and decode an API object response."""
+        if response.is_error:
+            raise SynthGraphHTTPClient._create_http_error(response)
+
+        if not response.content:
+            return {}
+
+        data = response.json()
+
+        if not isinstance(data, dict):
+            raise SynthGraphHTTPError(
+                status_code=response.status_code,
+                message="API response must be a JSON object",
+            )
+
+        return data
+
+    @staticmethod
+    def _handle_list_response(
+        response: httpx.Response,
+    ) -> list[dict[str, Any]]:
+        """Validate and decode an API list response."""
+        if response.is_error:
+            raise SynthGraphHTTPClient._create_http_error(response)
+
+        if not response.content:
+            return []
+
+        data = response.json()
+
+        if not isinstance(data, list):
+            raise SynthGraphHTTPError(
+                status_code=response.status_code,
+                message="API response must be a JSON array",
+            )
+
+        if not all(isinstance(item, dict) for item in data):
+            raise SynthGraphHTTPError(
+                status_code=response.status_code,
+                message="API response array must contain JSON objects",
+            )
+
+        return data
+
+    @staticmethod
+    def _create_http_error(
+        response: httpx.Response,
+    ) -> SynthGraphHTTPError:
+        """Create a consistent API error from an HTTP response."""
+        try:
+            data = response.json()
+
+            if isinstance(data, dict):
+                message = str(
+                    data.get(
+                        "detail",
+                        data.get("message", response.text),
+                    )
+                )
+            else:
+                message = response.text
+        except ValueError:
+            message = response.text
+
+        return SynthGraphHTTPError(
+            status_code=response.status_code,
+            message=message,
+        )

synthgraph/models/__init__.py

@@ -0,0 +1,16 @@
+from .experiment import Experiment
+from .generation import GenerationRun, GenerationStatus, Generator, Reproducibility
+from .project import Project
+from .reference import AssetReference, DataReference, DatasetReference
+
+__all__ = [
+    "AssetReference",
+    "DataReference",
+    "DatasetReference",
+    "Experiment",
+    "GenerationRun",
+    "GenerationStatus",
+    "Generator",
+    "Project",
+    "Reproducibility",
+]

synthgraph/models/experiment.py

@@ -0,0 +1,16 @@
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class Experiment(BaseModel):
+    """A research experiment belonging to a SynthGraph project."""
+
+    model_config = ConfigDict(frozen=True)
+
+    id: str
+    project_id: str
+    name: str = Field(min_length=1)
+    description: str | None = None
+    created_at: datetime
+    updated_at: datetime | None = None

synthgraph/models/generation.py

@@ -0,0 +1,76 @@
+from datetime import datetime
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .reference import DataReference
+
+
+class GenerationStatus(str, Enum):
+    """Lifecycle state of a generation run."""
+
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+class Generator(BaseModel):
+    """Information about the tool that produced a generation."""
+
+    model_config = ConfigDict(frozen=True)
+
+    name: str = Field(min_length=1)
+    version: str | None = None
+    type: str | None = None
+
+
+class Reproducibility(BaseModel):
+    """Information required to reproduce a generation."""
+
+    model_config = ConfigDict(frozen=True)
+
+    seed: int | None = Field(
+        default=None,
+        exclude_if=lambda value: value is None,
+    )
+    code_version: str | None = Field(
+        default=None,
+        exclude_if=lambda value: value is None,
+    )
+    environment: dict[str, Any] = Field(
+        default_factory=dict,
+        exclude_if=lambda value: not value,
+    )
+    configuration_hash: str | None = Field(
+        default=None,
+        exclude_if=lambda value: value is None,
+    )
+
+
+class GenerationRun(BaseModel):
+    """A single synthetic data generation execution."""
+
+    model_config = ConfigDict(frozen=True)
+
+    id: str = Field(min_length=1)
+    experiment_id: str = Field(min_length=1)
+    name: str = Field(min_length=1)
+    description: str | None = None
+
+    generator: Generator
+    parameters: dict[str, Any]
+
+    reproducibility: Reproducibility
+
+    inputs: list[DataReference] = Field(default_factory=list)
+    outputs: list[DataReference] = Field(default_factory=list)
+
+    status: GenerationStatus
+
+    started_at: datetime | None = None
+    completed_at: datetime | None = None
+    created_at: datetime
+
+    metadata: dict[str, Any] = Field(default_factory=dict)

synthgraph/models/project.py

@@ -0,0 +1,15 @@
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class Project(BaseModel):
+    """A top-level SynthGraph research project."""
+
+    model_config = ConfigDict(frozen=True)
+
+    id: str
+    name: str = Field(min_length=1)
+    description: str | None = None
+    created_at: datetime
+    updated_at: datetime | None = None

synthgraph/models/reference.py

@@ -0,0 +1,27 @@
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class DataReference(BaseModel):
+    """Reference to data managed outside or inside SynthGraph."""
+
+    model_config = ConfigDict(frozen=True)
+
+    id: str = Field(min_length=1)
+    uri: str = Field(min_length=1)
+    name: str = Field(min_length=1)
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class AssetReference(DataReference):
+    """Reference to a source or generated asset."""
+
+    type: str | None = None
+
+
+class DatasetReference(DataReference):
+    """Reference to a source or generated dataset."""
+
+    format: str | None = None
+    size: int | None = Field(default=None, ge=0)

synthgraph/projects.py

@@ -0,0 +1,40 @@
+from typing import Any
+
+from .http import SynthGraphHTTPClient
+from .models import Project
+
+
+class ProjectsAPI:
+    """API operations for SynthGraph projects."""
+
+    def __init__(self, http: SynthGraphHTTPClient) -> None:
+        self._http = http
+
+    def create(
+        self,
+        *,
+        name: str,
+        description: str | None = None,
+    ) -> Project:
+        """Create a new SynthGraph project."""
+        payload: dict[str, Any] = {
+            "name": name,
+        }
+
+        if description is not None:
+            payload["description"] = description
+
+        data = self._http.post(
+            "/projects",
+            json=payload,
+        )
+
+        return Project.model_validate(data)
+
+    def get(self, project_id: str) -> Project:
+        """Retrieve a SynthGraph project by ID."""
+        data = self._http.get(
+            f"/projects/{project_id}",
+        )
+
+        return Project.model_validate(data)

synthgraph/serialization/__init__.py

@@ -0,0 +1,3 @@
+from .json import model_to_dict, model_to_json
+
+__all__ = ["model_to_dict", "model_to_json"]

synthgraph/serialization/json.py

@@ -0,0 +1,14 @@
+import json
+from typing import Any
+
+from pydantic import BaseModel
+
+
+def model_to_dict(model: BaseModel) -> dict[str, Any]:
+    """Convert a SynthGraph model into JSON-compatible Python data."""
+    return model.model_dump(mode="json")
+
+
+def model_to_json(model: BaseModel) -> str:
+    """Convert a SynthGraph model into a JSON string."""
+    return json.dumps(model_to_dict(model))

synthgraph_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,322 @@
+Metadata-Version: 2.5
+Name: synthgraph-sdk
+Version: 0.1.0
+Summary: Python SDK for SynthGraph experiment provenance and lineage tracking.
+Author: SynthGraph
+License: Apache-2.0
+Requires-Python: >=3.11
+Requires-Dist: httpx<1.0,>=0.27
+Requires-Dist: pydantic<3.0,>=2.0
+Provides-Extra: dev
+Requires-Dist: mypy<2.0,>=1.11; extra == 'dev'
+Requires-Dist: pytest-cov<6.0,>=5.0; extra == 'dev'
+Requires-Dist: pytest<9.0,>=8.0; extra == 'dev'
+Requires-Dist: ruff<1.0,>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# SynthGraph Python SDK
+
+The official Python SDK for SynthGraph.
+
+SynthGraph allows researchers to capture experiment provenance and lineage from
+their existing research environments without moving their workflows into the
+SynthGraph platform.
+
+## Status
+
+Early development.
+
+The SDK is currently under active development and the public API is not yet
+stable.
+
+## Planned v1.0 capabilities
+
+- Project and experiment management
+- Synthetic-data generation provenance
+- Dataset references
+- Training-run provenance
+- Evaluation metrics
+- Asset references
+- Code and environment metadata
+- Experiment lineage
+- Cloud and self-hosted SynthGraph deployments
+
+## Installation
+
+Install the SDK from the project directory:
+
+```bash
+pip install -e .
+```
+
+For development:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Quick start
+
+A typical SynthGraph workflow is:
+
+```text
+Project
+  └── Experiment
+       └── Generation
+```
+
+### Create a project
+
+```python
+from synthgraph import SynthGraphClient
+
+with SynthGraphClient(api_key="your-api-key") as client:
+    project = client.projects.create(
+        name="Synthetic Research",
+        description="Synthetic-data research project",
+    )
+
+    print(project.id)
+    print(project.name)
+```
+
+### Create an experiment
+
+Experiments belong to projects:
+
+```python
+from synthgraph import SynthGraphClient
+
+with SynthGraphClient(api_key="your-api-key") as client:
+    experiment = client.experiments.create(
+        project_id="project_123",
+        name="Rainy Scene Study",
+        description="Study of synthetic rainy-scene generation",
+    )
+
+    print(experiment.id)
+```
+
+### Record a synthetic-data generation
+
+Use `Generator` to describe the software or tool that produced the result,
+and `Reproducibility` to capture information needed to reproduce the run.
+
+```python
+from synthgraph import (
+    Generator,
+    Reproducibility,
+    SynthGraphClient,
+)
+
+with SynthGraphClient(api_key="your-api-key") as client:
+    generation = client.generations.create(
+        experiment_id="experiment_123",
+        name="Rainy Scene Generation",
+        generator=Generator(
+            name="blender",
+            version="4.2.0",
+            type="3d_renderer",
+        ),
+        parameters={
+            "samples": 512,
+            "weather": "rain",
+        },
+        reproducibility=Reproducibility(
+            seed=42,
+        ),
+    )
+
+    print(generation.id)
+    print(generation.status)
+```
+
+### Record input and output references
+
+Generations can reference assets and datasets without moving the underlying
+data into SynthGraph.
+
+```python
+from synthgraph import (
+    AssetReference,
+    DatasetReference,
+    Generator,
+    Reproducibility,
+    SynthGraphClient,
+)
+
+input_asset = AssetReference(
+    id="asset_123",
+    uri="file:///data/model.blend",
+    name="model.blend",
+    type="3d_model",
+)
+
+input_dataset = DatasetReference(
+    id="dataset_123",
+    uri="s3://bucket/input-scenes",
+    name="input-scenes",
+    format="image",
+)
+
+output_dataset = DatasetReference(
+    id="dataset_456",
+    uri="s3://bucket/output-scenes",
+    name="output-scenes",
+    format="image",
+)
+
+with SynthGraphClient(api_key="your-api-key") as client:
+    generation = client.generations.create(
+        experiment_id="experiment_123",
+        name="Referenced Generation",
+        generator=Generator(name="blender", version="4.2.0"),
+        parameters={
+            "samples": 512,
+        },
+        reproducibility=Reproducibility(seed=42),
+        inputs=[input_asset, input_dataset],
+        outputs=[output_dataset],
+    )
+```
+
+References contain metadata about the data location and identity. The SDK
+does not upload the referenced files or datasets.
+
+## Reading existing resources
+
+Resources can be retrieved by ID.
+
+### Get a project
+
+```python
+with SynthGraphClient(api_key="your-api-key") as client:
+    project = client.projects.get("project_123")
+```
+
+### Get an experiment
+
+```python
+with SynthGraphClient(api_key="your-api-key") as client:
+    experiment = client.experiments.get("experiment_123")
+```
+
+### Get a generation
+
+```python
+with SynthGraphClient(api_key="your-api-key") as client:
+    generation = client.generations.get("generation_123")
+    print(generation.status)
+```
+
+## Listing resources
+
+### List experiments
+
+```python
+with SynthGraphClient(api_key="your-api-key") as client:
+    experiments = client.experiments.list(
+        project_id="project_123",
+    )
+
+    for experiment in experiments:
+        print(experiment.id, experiment.name)
+```
+
+### List generations
+
+```python
+with SynthGraphClient(api_key="your-api-key") as client:
+    generations = client.generations.list(
+        experiment_id="experiment_123",
+    )
+
+    for generation in generations:
+        print(generation.id, generation.status)
+```
+
+## Configuration
+
+The client can be configured directly:
+
+```python
+from synthgraph import SynthGraphClient
+
+client = SynthGraphClient(
+    api_key="your-api-key",
+    api_url="https://api.example.com",
+    timeout=30.0,
+)
+```
+
+Or through `SynthGraphConfig`:
+
+```python
+from synthgraph import SynthGraphClient, SynthGraphConfig
+
+config = SynthGraphConfig(
+    api_key="your-api-key",
+    api_url="https://api.example.com",
+    timeout=30.0,
+)
+
+with SynthGraphClient(config=config) as client:
+    project = client.projects.get("project_123")
+```
+
+Do not combine `config` with `api_key`, `api_url`, or `timeout` on the same
+`SynthGraphClient` instance.
+
+## Development
+
+From this directory:
+
+```bash
+pip install -e ".[dev]"
+```
+
+Run tests:
+
+```bash
+pytest
+```
+
+Run linting:
+
+```bash
+ruff check .
+```
+
+Run type checking:
+
+```bash
+mypy src
+```
+
+## Current SDK surface
+
+The current public client exposes:
+
+```python
+with SynthGraphClient(...) as client:
+    client.projects
+    client.experiments
+    client.generations
+```
+
+The SDK currently supports:
+
+- Project creation, retrieval, and listing
+- Experiment creation, retrieval, and listing
+- Generation creation, retrieval, and listing
+- Asset references
+- Dataset references
+- Generator metadata
+- Reproducibility metadata
+- HTTP error handling
+- Custom API URLs
+- Custom HTTP transports for testing
+
+## License
+
+Apache-2.0

synthgraph_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+synthgraph/__init__.py,sha256=IrMm4zmbCNo-d0D4fTJqhyevDs7Pf9jeTv0n0xUUuOY,736
+synthgraph/client.py,sha256=DsMTlD0OTSu1W5jLryQM1Ex1tpNPKL1nYgRxzUJMVuE,2023
+synthgraph/config.py,sha256=dIKy6c6x8LfNDljDjz7PafYqSXmlAqdlBOm-HNY9HXY,639
+synthgraph/experiments.py,sha256=QhPXf2qJKdclj5ab4F8V-89JUhiNlqz4-pCPHkTNk2w,1383
+synthgraph/generations.py,sha256=2EzBPdmaDSezz0dh28FL3MASkbVTphATOxI2h90qyog,3762
+synthgraph/http.py,sha256=kLnLZNm4FCjsS98xGeZIq9XeTAH4iAADf4v20RfKH4I,4991
+synthgraph/projects.py,sha256=jXRs207l_ZM70sYvTUIhAWZ9DfD9irjaDCHfY0LqpW0,974
+synthgraph/models/__init__.py,sha256=4kgit23Hx2ro0QUPSdhEn0cc2A3Las_EqRuyL_AM5v4,433
+synthgraph/models/experiment.py,sha256=02kJR3f_2M2wOQ1WbRCE3naB93FNLv8ls6Ld4cV1P-s,405
+synthgraph/models/generation.py,sha256=xZEEfAZiNqxliKmOuf5a-TGpmodl_GQAEuOYTWMc6Aw,1958
+synthgraph/models/project.py,sha256=A9vQb_hgIUzaoc--gXTzOYJNkkABqGM6Br5K0G5bOjA,365
+synthgraph/models/reference.py,sha256=V57a0wd_Q68Ix28BvimU9yYhiUT6OrFl0efFMypuaxU,703
+synthgraph/serialization/__init__.py,sha256=So31eYUfXRWX9Ys3TxQQ_f7plNrpQZG6zrmHkhUTpHo,94
+synthgraph/serialization/json.py,sha256=CnEi4BSKYqJzTObUvxcBHu0sxBAhFxlxdwxy1ALO-p8,395
+synthgraph_sdk-0.1.0.dist-info/METADATA,sha256=XxiZbJhTKdQqyfPWwduuVxfE_ECWpdfmWiLTqD8R8a4,6687
+synthgraph_sdk-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+synthgraph_sdk-0.1.0.dist-info/RECORD,,

synthgraph_sdk-0.1.0.dist-info/WHEEL

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