sixtyseven 0.1.0__tar.gz

sixtyseven-0.1.0/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.2
+Name: sixtyseven
+Version: 0.1.0
+Summary: Python SDK for Sixtyseven ML experiment tracking
+Author: Sixtyseven Team
+License: MIT
+Project-URL: Homepage, https://github.com/sixtyseven/sixtyseven
+Project-URL: Documentation, https://docs.sixtyseven.ai
+Project-URL: Repository, https://github.com/sixtyseven/sixtyseven
+Keywords: ml,machine-learning,experiment-tracking,metrics,training
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+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: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Requires-Dist: websocket-client>=1.4.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: responses>=0.23.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+
+# Sixtyseven Python SDK
+
+Track ML experiments locally. No server setup required.
+
+## Install
+
+```bash
+pip install sixtyseven
+```
+
+## Usage
+
+```python
+from sixtyseven import Run
+
+with Run(project="my-project", name="experiment-1") as run:
+    run.log_config({"learning_rate": 0.001, "epochs": 10})
+
+    for epoch in range(10):
+        loss = train_one_epoch()
+        run.log_metrics({"loss": loss}, step=epoch)
+```
+
+## View Results
+
+```bash
+sixtyseven --logdir ~/.sixtyseven/logs
+```
+
+Opens a dashboard at http://localhost:6767
+
+## API
+
+```python
+run.log_metrics({"loss": 0.5, "accuracy": 0.85}, step=epoch)  # Log metrics
+run.log_config({"lr": 0.001})                                  # Log config
+run.add_tags(["baseline"])                                     # Add tags
+```
+
+## Environment Variables
+
+| Variable            | Description        | Default              |
+| ------------------- | ------------------ | -------------------- |
+| `SIXTYSEVEN_LOGDIR` | Where to save logs | `~/.sixtyseven/logs` |
+
+## License
+
+MIT

sixtyseven-0.1.0/README.md

@@ -0,0 +1,48 @@
+# Sixtyseven Python SDK
+
+Track ML experiments locally. No server setup required.
+
+## Install
+
+```bash
+pip install sixtyseven
+```
+
+## Usage
+
+```python
+from sixtyseven import Run
+
+with Run(project="my-project", name="experiment-1") as run:
+    run.log_config({"learning_rate": 0.001, "epochs": 10})
+
+    for epoch in range(10):
+        loss = train_one_epoch()
+        run.log_metrics({"loss": loss}, step=epoch)
+```
+
+## View Results
+
+```bash
+sixtyseven --logdir ~/.sixtyseven/logs
+```
+
+Opens a dashboard at http://localhost:6767
+
+## API
+
+```python
+run.log_metrics({"loss": 0.5, "accuracy": 0.85}, step=epoch)  # Log metrics
+run.log_config({"lr": 0.001})                                  # Log config
+run.add_tags(["baseline"])                                     # Add tags
+```
+
+## Environment Variables
+
+| Variable            | Description        | Default              |
+| ------------------- | ------------------ | -------------------- |
+| `SIXTYSEVEN_LOGDIR` | Where to save logs | `~/.sixtyseven/logs` |
+
+## License
+
+MIT

sixtyseven-0.1.0/pyproject.toml

@@ -0,0 +1,68 @@
+[build-system]
+requires = ["setuptools>=69,<77", "wheel", "packaging>=23.2"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sixtyseven"
+version = "0.1.0"
+description = "Python SDK for Sixtyseven ML experiment tracking"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.8"
+authors = [
+    { name = "Sixtyseven Team" }
+]
+keywords = ["ml", "machine-learning", "experiment-tracking", "metrics", "training"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "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",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+dependencies = [
+    "requests>=2.28.0",
+    "websocket-client>=1.4.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.21.0",
+    "responses>=0.23.0",
+    "black>=23.0.0",
+    "ruff>=0.1.0",
+    "mypy>=1.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/sixtyseven/sixtyseven"
+Documentation = "https://docs.sixtyseven.ai"
+Repository = "https://github.com/sixtyseven/sixtyseven"
+
+[project.scripts]
+sixtyseven = "sixtyseven.cli:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+packages = ["sixtyseven"]
+include-package-data = true
+
+[tool.setuptools.package-data]
+sixtyseven = ["bin/**"]
+
+[tool.mypy]
+python_version = "3.8"
+warn_return_any = true
+warn_unused_configs = true
+ignore_missing_imports = true

sixtyseven-0.1.0/setup.cfg

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

sixtyseven-0.1.0/setup.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from setuptools import setup
+
+
+try:
+    from wheel.bdist_wheel import bdist_wheel as _bdist_wheel
+
+    class bdist_wheel(_bdist_wheel):
+        def finalize_options(self) -> None:
+            super().finalize_options()
+            self.root_is_pure = False
+            if hasattr(self, "root_is_purelib"):
+                self.root_is_purelib = False
+
+        def get_tag(self) -> tuple[str, str, str]:
+            _, _, plat = super().get_tag()
+            # py3-none-<platform>: works with any Python 3, no ABI, platform-specific
+            return "py3", "none", plat
+
+except Exception:  # wheel not available
+    bdist_wheel = None  # type: ignore[assignment]
+
+
+setup(cmdclass={"bdist_wheel": bdist_wheel} if bdist_wheel else {})

sixtyseven-0.1.0/src/sixtyseven/__init__.py

@@ -0,0 +1,36 @@
+"""
+Sixtyseven - ML Experiment Tracking SDK
+
+A Python SDK for tracking machine learning experiments with Sixtyseven.
+
+Example usage:
+    from sixtyseven import Run
+
+    with Run(project="my-team/image-classifier") as run:
+        run.log_config({"learning_rate": 0.001})
+
+        for epoch in range(100):
+            loss = train()
+            run.log_metrics({"loss": loss}, step=epoch)
+"""
+
+from sixtyseven.config import configure
+from sixtyseven.exceptions import (
+    APIError,
+    AuthenticationError,
+    ServerError,
+    SixtySevenError,
+    ValidationError,
+)
+from sixtyseven.run import Run
+
+__version__ = "0.1.0"
+__all__ = [
+    "Run",
+    "configure",
+    "SixtySevenError",
+    "AuthenticationError",
+    "APIError",
+    "ValidationError",
+    "ServerError",
+]

sixtyseven-0.1.0/src/sixtyseven/cli.py

@@ -0,0 +1,64 @@
+"""Console entrypoint for the bundled sixtyseven CLI."""
+
+from __future__ import annotations
+
+import os
+import platform
+import shutil
+import sys
+from pathlib import Path
+from typing import Optional
+
+
+def _platform_id() -> Optional[str]:
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+
+    if machine in {"x86_64", "amd64"}:
+        arch = "amd64"
+    elif machine in {"aarch64", "arm64"}:
+        arch = "arm64"
+    else:
+        return None
+
+    if system == "darwin":
+        return f"darwin-{arch}"
+    if system == "linux":
+        return f"linux-{arch}"
+    if system == "windows":
+        return f"windows-{arch}"
+    return None
+
+
+def _bundled_binary_path() -> Optional[str]:
+    platform_id = _platform_id()
+    if not platform_id:
+        return None
+
+    binary_name = "sixtyseven.exe" if platform.system() == "Windows" else "sixtyseven"
+    base_dir = Path(__file__).resolve().parent
+    candidate = base_dir / "bin" / platform_id / binary_name
+    if candidate.is_file() and os.access(candidate, os.X_OK):
+        return str(candidate)
+    return None
+
+
+def _find_binary() -> Optional[str]:
+    bundled = _bundled_binary_path()
+    if bundled:
+        return bundled
+
+    binary_name = "sixtyseven.exe" if platform.system() == "Windows" else "sixtyseven"
+    return shutil.which(binary_name)
+
+
+def main() -> None:
+    binary = _find_binary()
+    if not binary:
+        print(
+            "Could not find 'sixtyseven' binary. Reinstall the package or set SIXTYSEVEN_BINARY.",
+            file=sys.stderr,
+        )
+        raise SystemExit(1)
+
+    os.execv(binary, [binary, *sys.argv[1:]])

sixtyseven-0.1.0/src/sixtyseven/client.py

@@ -0,0 +1,190 @@
+"""HTTP client for communicating with the Sixtyseven API."""
+
+import time
+from typing import Any, Dict, List, Optional
+from urllib.parse import urljoin
+
+import requests
+
+from sixtyseven.config import SDKConfig
+from sixtyseven.exceptions import APIError, AuthenticationError
+
+
+class SixtySevenClient:
+    """HTTP client for the Sixtyseven API."""
+
+    def __init__(self, config: SDKConfig, api_key: Optional[str] = None):
+        """
+        Initialize the client.
+
+        Args:
+            config: SDK configuration
+            api_key: API key (overrides config)
+        """
+        self.config = config
+        self.api_key = api_key or config.api_key
+        self.session = requests.Session()
+
+        if self.api_key:
+            self.session.headers["Authorization"] = f"Bearer {self.api_key}"
+
+        self.session.headers["Content-Type"] = "application/json"
+        self.session.headers["User-Agent"] = "sixtyseven-python/0.1.0"
+
+    def _url(self, path: str) -> str:
+        """Build full URL for an API endpoint."""
+        return urljoin(self.config.base_url, f"/api/v1{path}")
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        data: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Make an HTTP request with retry logic.
+
+        Args:
+            method: HTTP method
+            path: API path
+            data: Request body data
+            params: Query parameters
+
+        Returns:
+            Response JSON data
+
+        Raises:
+            AuthenticationError: If authentication fails
+            APIError: If the request fails
+        """
+        url = self._url(path)
+        last_error = None
+
+        for attempt in range(self.config.retry_count):
+            try:
+                response = self.session.request(
+                    method=method,
+                    url=url,
+                    json=data,
+                    params=params,
+                    timeout=self.config.timeout,
+                )
+
+                if response.status_code == 401:
+                    raise AuthenticationError("Invalid API key")
+
+                if response.status_code == 403:
+                    raise AuthenticationError("Insufficient permissions")
+
+                if response.status_code >= 400:
+                    error_data = response.json() if response.text else {}
+                    raise APIError(
+                        error_data.get(
+                            "error",
+                            f"Request failed with status {response.status_code}",
+                        ),
+                        status_code=response.status_code,
+                        response=error_data,
+                    )
+
+                if response.text:
+                    return response.json()
+                return {}
+
+            except requests.exceptions.RequestException as e:
+                last_error = e
+                if attempt < self.config.retry_count - 1:
+                    time.sleep(self.config.retry_delay * (attempt + 1))
+                continue
+
+        raise APIError(
+            f"Request failed after {self.config.retry_count} attempts: {last_error}"
+        )
+
+    def create_run(
+        self,
+        team_slug: str,
+        app_slug: str,
+        name: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        config: Optional[Dict[str, Any]] = None,
+        git_info: Optional[Dict[str, Any]] = None,
+        system_info: Optional[Dict[str, Any]] = None,
+    ) -> str:
+        """
+        Create a new run.
+
+        Returns:
+            The run ID
+        """
+        data = {
+            "name": name,
+            "tags": tags or [],
+            "config": config or {},
+        }
+
+        if git_info:
+            data["git_info"] = git_info
+        if system_info:
+            data["system_info"] = system_info
+
+        response = self._request(
+            "POST",
+            f"/teams/{team_slug}/apps/{app_slug}/runs",
+            data=data,
+        )
+
+        return response["id"]
+
+    def update_run_status(
+        self,
+        run_id: str,
+        status: str,
+        error: Optional[str] = None,
+    ) -> None:
+        """Update run status (completed, failed, aborted)."""
+        data = {"status": status}
+        if error:
+            data["error_message"] = error
+
+        self._request("PUT", f"/runs/{run_id}/status", data=data)
+
+    def update_run_config(self, run_id: str, config: Dict[str, Any]) -> None:
+        """Merge new config with existing run config."""
+        self._request("PUT", f"/runs/{run_id}/config", data=config)
+
+    def batch_log_metrics(
+        self,
+        run_id: str,
+        metrics: List[Dict[str, Any]],
+    ) -> None:
+        """
+        Log a batch of metrics.
+
+        Args:
+            run_id: The run ID
+            metrics: List of metric dictionaries with name, value, step, timestamp
+        """
+        self._request(
+            "POST",
+            f"/runs/{run_id}/metrics",
+            data={"metrics": metrics},
+        )
+
+    def add_run_tags(self, run_id: str, tags: List[str]) -> None:
+        """Add tags to a run."""
+        # This would need to be implemented via the update endpoint
+        pass
+
+    def upload_artifact(
+        self,
+        run_id: str,
+        path: str,
+        name: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Upload an artifact file."""
+        # Artifact upload would need multipart form handling
+        # For now, this is a placeholder
+        pass

sixtyseven-0.1.0/src/sixtyseven/config.py

@@ -0,0 +1,161 @@
+"""Configuration management for the Sixtyseven SDK."""
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Literal, Optional
+
+
+def _default_logdir() -> str:
+    """Get the default log directory based on platform."""
+    import platform
+
+    home = Path.home()
+    system = platform.system()
+
+    if system == "Darwin":
+        return str(home / "Library" / "Application Support" / "sixtyseven" / "logs")
+    elif system == "Windows":
+        appdata = os.environ.get("LOCALAPPDATA", str(home / "AppData" / "Local"))
+        return str(Path(appdata) / "sixtyseven" / "logs")
+    else:  # Linux and others
+        xdg_data = os.environ.get("XDG_DATA_HOME", str(home / ".local" / "share"))
+        return str(Path(xdg_data) / "sixtyseven" / "logs")
+
+
+@dataclass
+class SDKConfig:
+    """SDK configuration settings."""
+
+    # Mode: "local" or "remote"
+    mode: Literal["local", "remote"] = "local"
+
+    # Remote mode settings
+    base_url: str = "http://localhost:8080"
+    api_key: Optional[str] = None
+
+    # Local mode settings
+    logdir: str = field(default_factory=_default_logdir)
+
+    # Common settings
+    batch_size: int = 100
+    flush_interval: float = 5.0
+    capture_git: bool = True
+    capture_system: bool = True
+
+    # Remote-only settings
+    timeout: int = 30
+    retry_count: int = 3
+    retry_delay: float = 1.0
+
+
+# Global configuration instance
+_config = SDKConfig()
+
+
+def configure(
+    mode: Optional[Literal["local", "remote"]] = None,
+    base_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    logdir: Optional[str] = None,
+    batch_size: Optional[int] = None,
+    flush_interval: Optional[float] = None,
+    capture_git: Optional[bool] = None,
+    capture_system: Optional[bool] = None,
+    timeout: Optional[int] = None,
+    retry_count: Optional[int] = None,
+    retry_delay: Optional[float] = None,
+) -> SDKConfig:
+    """
+    Configure the SDK globally.
+
+    Args:
+        mode: Operating mode ("local" for file-based, "remote" for API server)
+        base_url: Base URL for the Sixtyseven API server (remote mode)
+        api_key: API key for authentication (remote mode)
+        logdir: Directory for storing logs (local mode)
+        batch_size: Number of metrics to batch before sending/writing
+        flush_interval: Seconds between automatic flushes
+        capture_git: Whether to capture git information
+        capture_system: Whether to capture system information
+        timeout: Request timeout in seconds (remote mode)
+        retry_count: Number of retries for failed requests (remote mode)
+        retry_delay: Delay between retries in seconds (remote mode)
+
+    Returns:
+        The updated configuration
+
+    Example (local mode - default):
+        from sixtyseven import configure
+
+        configure(logdir="./logs")  # Use local file storage
+
+    Example (remote mode):
+        from sixtyseven import configure
+
+        configure(
+            mode="remote",
+            base_url="https://api.sixtyseven.ai",
+            api_key="ss67_xxxx",
+        )
+    """
+    global _config
+
+    if mode is not None:
+        _config.mode = mode
+    if base_url is not None:
+        _config.base_url = base_url
+    if api_key is not None:
+        _config.api_key = api_key
+    if logdir is not None:
+        _config.logdir = logdir
+    if batch_size is not None:
+        _config.batch_size = batch_size
+    if flush_interval is not None:
+        _config.flush_interval = flush_interval
+    if capture_git is not None:
+        _config.capture_git = capture_git
+    if capture_system is not None:
+        _config.capture_system = capture_system
+    if timeout is not None:
+        _config.timeout = timeout
+    if retry_count is not None:
+        _config.retry_count = retry_count
+    if retry_delay is not None:
+        _config.retry_delay = retry_delay
+
+    return _config
+
+
+def _detect_mode() -> Literal["local", "remote"]:
+    """
+    Auto-detect the operating mode based on environment variables.
+
+    Priority:
+    1. SIXTYSEVEN_LOGDIR set -> local mode
+    2. SIXTYSEVEN_URL or SIXTYSEVEN_API_KEY set -> remote mode
+    3. Default -> local mode (zero config experience)
+    """
+    if os.environ.get("SIXTYSEVEN_LOGDIR"):
+        return "local"
+    if os.environ.get("SIXTYSEVEN_URL") or os.environ.get("SIXTYSEVEN_API_KEY"):
+        return "remote"
+    return "local"
+
+
+def get_config() -> SDKConfig:
+    """Get the current SDK configuration with environment variable overrides."""
+    global _config
+
+    # Auto-detect mode from environment
+    _config.mode = _detect_mode()
+
+    # Override with environment variables
+    if os.environ.get("SIXTYSEVEN_LOGDIR"):
+        _config.logdir = os.environ["SIXTYSEVEN_LOGDIR"]
+    if os.environ.get("SIXTYSEVEN_URL"):
+        _config.base_url = os.environ["SIXTYSEVEN_URL"]
+    if os.environ.get("SIXTYSEVEN_API_KEY"):
+        _config.api_key = os.environ["SIXTYSEVEN_API_KEY"]
+
+    return _config