sixtyseven 0.1.0__cp312-cp312-macosx_11_0_arm64.whl

sixtyseven-0.1.0.data/purelib/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.data/purelib/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.data/purelib/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.data/purelib/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

sixtyseven-0.1.0.data/purelib/sixtyseven/exceptions.py

@@ -0,0 +1,40 @@
+"""Custom exceptions for the Sixtyseven SDK."""
+
+
+class SixtySevenError(Exception):
+    """Base exception for Sixtyseven SDK errors."""
+
+    pass
+
+
+class AuthenticationError(SixtySevenError):
+    """Raised when authentication fails."""
+
+    pass
+
+
+class APIError(SixtySevenError):
+    """Raised when an API request fails."""
+
+    def __init__(self, message: str, status_code: int = None, response: dict = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.response = response
+
+
+class ValidationError(SixtySevenError):
+    """Raised when validation fails."""
+
+    pass
+
+
+class ConnectionError(SixtySevenError):
+    """Raised when connection to the server fails."""
+
+    pass
+
+
+class ServerError(SixtySevenError):
+    """Raised when server management fails (e.g., binary not found, failed to start)."""
+
+    pass