synth-ai 0.2.0__py3-none-any.whl → 0.2.1.dev0__py3-none-any.whl

synth_ai/__init__.py

@@ -2,7 +2,33 @@
 Synth AI - Software for aiding the best and multiplying the will.
 """
 
-from synth_ai.zyk import LM  # Assuming LM is in zyk.py in the same directory
+from synth_ai.lm.core.main import LM  # Moved from zyk to lm for better organization
+
+# Tracing exports - moved from synth-sdk
+from synth_ai.tracing import *  # noqa
+from synth_ai.tracing.abstractions import (
+    EventPartitionElement,
+    SystemTrace,
+    TrainingQuestion,
+    RewardSignal,
+)
+from synth_ai.tracing.decorators import trace_event_async, trace_event_sync
+from synth_ai.tracing.upload import upload
+
+# Provider support exports - moved from synth-sdk to synth_ai/lm
+from synth_ai.lm.provider_support.openai import OpenAI, AsyncOpenAI
+from synth_ai.lm.provider_support.anthropic import Anthropic, AsyncAnthropic
+
+# Environment exports - moved from synth-env
+from synth_ai.environments import *  # noqa
 
 __version__ = "0.1.9"
-__all__ = ["LM"]  # Explicitly define public API
+__all__ = [
+    "LM",
+    "tracing",
+    "OpenAI",
+    "AsyncOpenAI",
+    "Anthropic",
+    "AsyncAnthropic",
+    "environments",
+]  # Explicitly define public API

synth_ai/core/system.py

@@ -0,0 +1,4 @@
+
+
+class System:
+    pass

synth_ai/environments/__init__.py

@@ -0,0 +1,35 @@
+"""Synth Environment Package - A framework for reinforcement learning environments."""
+
+__version__ = "0.1.5"
+
+# Import key modules for easier access
+from . import environment
+from . import service
+from . import stateful
+from . import tasks
+from . import examples
+
+__all__ = [
+    "environment",
+    "service",
+    "stateful",
+    "tasks",
+    "examples",
+]
+
+import sys
+import types
+
+# ---------------------------------------------------------------------------
+# Compatibility Shim
+# Some older code imports synth_env via the namespace prefix 'src.synth_env'.
+# Rather than requiring consumers to update import paths (or adding try/except
+# imports which violates project style rules), we register an alias module so
+# that both import styles resolve to the same package instance.
+# ---------------------------------------------------------------------------
+if "src" not in sys.modules:
+    sys.modules["src"] = types.ModuleType("src")
+
+# Expose this package as src.synth_env
+sys.modules["src.synth_env"] = sys.modules[__name__]
+setattr(sys.modules["src"], "synth_env", sys.modules[__name__])

synth_ai/environments/environment/__init__.py

@@ -0,0 +1 @@
+"""Environment core module."""

synth_ai/environments/environment/artifacts/__init__.py

@@ -0,0 +1 @@
+# artifacts package

synth_ai/environments/environment/artifacts/base.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from pathlib import Path
+from pydantic import BaseModel
+import shutil
+
+
+class Artifact(BaseModel, ABC):
+    """Generic artifact representation."""
+
+    artifact_type: str
+    filename: str
+
+    @abstractmethod
+    def bytes(self) -> bytes:
+        """Return raw bytes of the artifact."""
+        ...
+
+    def save(self, root: Path) -> None:
+        """Save artifact bytes to `root/filename`."""
+        p = root / self.filename
+        p.write_bytes(self.bytes())
+
+
+class FileArtifact(Artifact):
+    """Artifact representing a file's contents."""
+
+    artifact_type: str = "file"
+    content: bytes
+
+    def bytes(self) -> bytes:
+        return self.content
+
+
+class ArtifactStore:
+    """Filesystem-based store for artifacts."""
+
+    def __init__(self, root: Path):
+        self.root = root
+        self.root.mkdir(parents=True, exist_ok=True)
+
+    def add(self, art: Artifact) -> None:
+        art.save(self.root)
+
+    def list(self) -> list[Path]:
+        return list(self.root.iterdir())
+
+    def export_tar(self, out: Path) -> None:
+        """Generate `out.tar.gz` from artifact directory."""
+        shutil.make_archive(out.with_suffix(""), "gztar", self.root)

synth_ai/environments/environment/core.py

@@ -0,0 +1,22 @@
+from synth_ai.core.system import System
+
+class Environment(System):
+    """
+    Base class for all environments, providing a name attribute.
+    """
+
+    _default_name: str
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        # Set a default name for the subclass based on its class name
+        cls._default_name = cls.__name__
+
+    @property
+    def name(self) -> str:
+        """Return the environment name, defaulting to the subclass name."""
+        return getattr(self, "_name", self._default_name)
+
+    @name.setter
+    def name(self, value: str):
+        self._name = value

synth_ai/environments/environment/db/__init__.py

@@ -0,0 +1 @@
+# db package

synth_ai/environments/environment/db/sqlite.py

@@ -0,0 +1,45 @@
+import sqlite3
+import threading
+import contextlib
+from pathlib import Path
+
+
+class SQLiteManager:
+    def __init__(self, db_path: Path, read_only: bool = True, ephemeral: bool = False):
+        """Initializes SQLiteManager with optional read-only or ephemeral mode."""
+        self.db_path = db_path
+        self.read_only = read_only
+        self.ephemeral = ephemeral
+        self._lock = threading.RLock()
+        self._conn: sqlite3.Connection | None = None
+
+    @contextlib.contextmanager
+    def connection(self):
+        with self._lock:
+            if self._conn is None:
+                uri = f"file:{self.db_path}?mode=ro" if self.read_only else str(self.db_path)
+                self._conn = sqlite3.connect(uri, uri=self.read_only, isolation_level="DEFERRED")
+                self._conn.execute("PRAGMA foreign_keys=ON;")
+                self._conn.execute("PRAGMA journal_mode=WAL;")
+            try:
+                yield self._conn
+                self._conn.commit()
+            except:
+                self._conn.rollback()
+                raise
+
+    def close(self):
+        """Closes the underlying connection for cleanup at environment teardown."""
+        with self._lock:
+            if self._conn:
+                self._conn.close()
+                self._conn = None
+
+    def reset(self, new_db_path: Path | None = None):
+        """Resets the connection, optionally switching to a new database path for a fresh session."""
+        with self._lock:
+            if self._conn:
+                self._conn.close()
+            if new_db_path:
+                self.db_path = new_db_path
+            self._conn = None

synth_ai/environments/environment/registry.py

@@ -0,0 +1,24 @@
+from typing import Type, Dict, List
+
+from synth_ai.environments.stateful.core import StatefulEnvironment
+
+# Global registry for environment types
+ENV_REGISTRY: Dict[str, Type[StatefulEnvironment]] = {}
+
+
+def register_environment(name: str, cls: Type[StatefulEnvironment]) -> None:
+    """Register an environment class under a unique name."""
+    ENV_REGISTRY[name] = cls
+
+
+def get_environment_cls(env_type: str) -> Type[StatefulEnvironment]:
+    """Retrieve a registered environment class or raise an error."""
+    try:
+        return ENV_REGISTRY[env_type]
+    except KeyError:
+        raise ValueError(f"Unsupported environment type: {env_type}")
+
+
+def list_supported_env_types() -> List[str]:
+    """List all registered environment type names."""
+    return list(ENV_REGISTRY.keys())

synth_ai/environments/environment/resources/sqlite.py

@@ -0,0 +1,46 @@
+import sqlite3
+import threading
+import contextlib
+from pathlib import Path
+from typing import Optional
+
+
+class SQLiteManager:
+    def __init__(self, db_path: Path, read_only: bool = True, ephemeral: bool = False):
+        """Initializes SQLiteManager with optional read-only or ephemeral mode."""
+        self.db_path = db_path
+        self.read_only = read_only
+        self.ephemeral = ephemeral
+        self._lock = threading.RLock()
+        self._conn: sqlite3.Connection | None = None
+
+    @contextlib.contextmanager
+    def connection(self):
+        with self._lock:
+            if self._conn is None:
+                uri = f"file:{self.db_path}?mode=ro" if self.read_only else str(self.db_path)
+                self._conn = sqlite3.connect(uri, uri=self.read_only, isolation_level="DEFERRED")
+                self._conn.execute("PRAGMA foreign_keys=ON;")
+                self._conn.execute("PRAGMA journal_mode=WAL;")
+            try:
+                yield self._conn
+                self._conn.commit()
+            except:
+                self._conn.rollback()
+                raise
+
+    def close(self):
+        """Closes the underlying connection for cleanup at environment teardown."""
+        with self._lock:
+            if self._conn:
+                self._conn.close()
+                self._conn = None
+
+    def reset(self, new_db_path: Optional[Path] = None):
+        """Resets the connection, optionally switching to a new database path for a fresh session."""
+        with self._lock:
+            if self._conn:
+                self._conn.close()
+            if new_db_path:
+                self.db_path = new_db_path
+            self._conn = None

synth_ai/environments/environment/results.py

@@ -0,0 +1 @@
+# EnvHistory, EnvRecord, EnvironmentCheckpointObservation (customer supplied, not for agent but only designer)

synth_ai/environments/environment/rewards/__init__.py

@@ -0,0 +1 @@
+# rewards package

synth_ai/environments/environment/rewards/core.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import List, Any
+
+
+class RewardComponent(ABC):
+    """Interface for a component contributing to stepwise reward."""
+
+    weight: float = 1.0
+
+    @abstractmethod
+    async def score(self, state: Any, action: Any) -> float:
+        """Compute the component's reward given current state and action."""
+        ...
+
+
+class RewardStack:
+    """Aggregates multiple RewardComponent instances to compute a total reward."""
+
+    def __init__(self, components: List[RewardComponent]):
+        self.components = components
+
+    async def step_reward(self, state: Any, action: Any) -> float:
+        """Compute the sum of weighted component rewards for a single step."""
+        total = 0.0
+        for comp in self.components:
+            total += comp.weight * await comp.score(state, action)
+        return total

synth_ai/environments/environment/shared_engine.py

@@ -0,0 +1,26 @@
+from abc import abstractmethod
+from typing import Any
+
+
+class InternalObservation:
+    public_observation: Any
+    private_observation: Any
+
+
+class GetObservationCallable:
+    @abstractmethod
+    async def get_observation(self) -> InternalObservation:
+        pass
+
+    pass
+
+
+class Engine:
+    async def initialize(self):
+        pass
+
+    async def terminate(self):
+        pass
+
+    async def _step_engine(self):
+        pass

synth_ai/environments/environment/tools/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from pydantic import BaseModel, Field
+from typing import Any, Dict, Type
+
+
+class EnvToolCall(BaseModel):
+    """Agent-requested call into an environment tool."""
+
+    tool: str
+    args: Dict[str, Any] = Field(default_factory=dict)
+
+
+class ToolResult(BaseModel):
+    ok: bool
+    payload: Any | None = None
+    error: str | None = None
+
+
+class AbstractTool(ABC):
+    name: str
+    call_schema: Type[BaseModel]
+    result_schema: Type[BaseModel] = ToolResult
+
+    @abstractmethod
+    async def __call__(self, call: EnvToolCall) -> ToolResult: ...
+
+
+TOOL_REGISTRY: dict[str, AbstractTool] = {}
+
+
+def register_tool(tool: AbstractTool) -> None:
+    """Register a tool instance under its `name` for dispatch."""
+    TOOL_REGISTRY[tool.name] = tool

synth_ai/environments/examples/__init__.py

@@ -0,0 +1 @@
+"""Environment examples and demos."""

synth_ai/environments/examples/crafter_classic/__init__.py

@@ -0,0 +1,8 @@
+from .config_logging import configure_logging
+from .environment import CrafterClassicEnvironment
+from .engine import CrafterEngine
+
+# Configure logging when crafter_classic module is imported
+configure_logging()
+
+__all__ = ["CrafterClassicEnvironment", "CrafterEngine"]

synth_ai/environments/examples/crafter_classic/agent_demos/crafter_comprehensive_evaluation.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+Run script for Full Enchilada Crafter Evaluation
+"""
+
+import asyncio
+import argparse
+from src.synth_env.examples.crafter_classic.agent_demos.full_enchilada import (
+    run_full_enchilada_eval,
+)
+
+
+async def main():
+    parser = argparse.ArgumentParser(description="Run Full Enchilada Crafter Evaluation")
+    parser.add_argument(
+        "--models", nargs="+", default=["gpt-4o-mini"], help="Model names to evaluate"
+    )
+    parser.add_argument(
+        "--difficulties",
+        nargs="+",
+        default=["easy", "hard"],
+        help="Difficulty levels to test",
+    )
+    parser.add_argument(
+        "--num-trajectories",
+        type=int,
+        default=3,
+        help="Number of trajectories per condition",
+    )
+    parser.add_argument("--max-turns", type=int, default=30, help="Maximum turns per trajectory")
+    parser.add_argument("--no-images", action="store_true", help="Disable image capture")
+    parser.add_argument(
+        "--no-viewer",
+        action="store_true",
+        help="Don't launch the viewer after evaluation",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=str,
+        default=None,
+        help="Output directory (default: src/evals/crafter/run_TIMESTAMP)",
+    )
+
+    args = parser.parse_args()
+
+    await run_full_enchilada_eval(
+        model_names=args.models,
+        difficulties=args.difficulties,
+        num_trajectories=args.num_trajectories,
+        max_turns=args.max_turns,
+        capture_images=not args.no_images,
+        launch_viewer=not args.no_viewer,
+        output_dir=args.output_dir,
+    )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

synth_ai/environments/examples/crafter_classic/agent_demos/crafter_evaluation_browser.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""
+Browse existing Crafter evaluations and launch viewer for a selected run.
+"""
+
+import argparse
+import json
+from pathlib import Path
+from datetime import datetime
+import asyncio
+from tabulate import tabulate
+
+from src.synth_env.examples.crafter_classic.agent_demos.full_enchilada import (
+    set_current_eval_dir,
+    app,
+)
+from fastapi.staticfiles import StaticFiles
+import uvicorn
+
+
+def list_evaluations(evals_dir: Path = Path("src/evals/crafter")):
+    """List all available evaluations with summary info."""
+    if not evals_dir.exists():
+        print(f"No evaluations found at {evals_dir}")
+        return []
+
+    evaluations = []
+    for run_dir in sorted(evals_dir.glob("run_*"), reverse=True):
+        if run_dir.is_dir():
+            summary_file = run_dir / "evaluation_summary.json"
+            if summary_file.exists():
+                with open(summary_file, "r") as f:
+                    summary = json.load(f)
+
+                eval_info = {
+                    "run_id": run_dir.name,
+                    "timestamp": summary["evaluation_metadata"]["timestamp"],
+                    "models": ", ".join(summary["models_evaluated"]),
+                    "difficulties": ", ".join(summary["difficulties_evaluated"]),
+                    "num_trajectories": summary["evaluation_metadata"]["num_trajectories"],
+                    "path": run_dir,
+                }
+                evaluations.append(eval_info)
+
+    return evaluations
+
+
+async def view_evaluation(eval_dir: Path):
+    """Launch viewer for a specific evaluation."""
+    if not eval_dir.exists():
+        print(f"Evaluation directory not found: {eval_dir}")
+        return
+
+    viewer_dir = eval_dir / "viewer"
+    if not viewer_dir.exists():
+        print(f"Viewer files not found in {eval_dir}")
+        return
+
+    print(f"\n📁 Viewing evaluation: {eval_dir}")
+    print("🌐 Launching viewer at http://localhost:8000")
+    print("   Press Ctrl+C to stop the viewer")
+
+    # Set the current eval directory for the viewer
+    set_current_eval_dir(eval_dir)
+
+    # Mount static files from the viewer directory
+    app.mount("/", StaticFiles(directory=str(viewer_dir), html=True), name="viewer")
+
+    # Run viewer
+    config = uvicorn.Config(app, host="0.0.0.0", port=8000, log_level="error")
+    server = uvicorn.Server(config)
+    await server.serve()
+
+
+async def main():
+    parser = argparse.ArgumentParser(description="Browse Crafter evaluations")
+    parser.add_argument(
+        "--eval-dir",
+        type=str,
+        default="src/evals/crafter",
+        help="Base directory for evaluations",
+    )
+    parser.add_argument(
+        "--run-id", type=str, help="Specific run ID to view (e.g., run_20240115_143022)"
+    )
+    parser.add_argument("--latest", action="store_true", help="View the latest evaluation")
+
+    args = parser.parse_args()
+    evals_dir = Path(args.eval_dir)
+
+    # List evaluations
+    evaluations = list_evaluations(evals_dir)
+
+    if not evaluations:
+        return
+
+    # Display table of evaluations
+    if not args.run_id and not args.latest:
+        print("\n📊 Available Crafter Evaluations:")
+        table_data = []
+        for i, eval_info in enumerate(evaluations):
+            # Parse timestamp for cleaner display
+            try:
+                ts = datetime.fromisoformat(eval_info["timestamp"])
+                ts_str = ts.strftime("%Y-%m-%d %H:%M:%S")
+            except:
+                ts_str = eval_info["timestamp"]
+
+            table_data.append(
+                [
+                    i + 1,
+                    eval_info["run_id"],
+                    ts_str,
+                    eval_info["models"],
+                    eval_info["difficulties"],
+                    eval_info["num_trajectories"],
+                ]
+            )
+
+        headers = ["#", "Run ID", "Timestamp", "Models", "Difficulties", "Trajectories"]
+        print(tabulate(table_data, headers=headers, tablefmt="grid"))
+
+        # Ask user to select
+        print("\nEnter the number of the evaluation to view (or 'q' to quit): ", end="")
+        choice = input().strip()
+
+        if choice.lower() == "q":
+            return
+
+        try:
+            idx = int(choice) - 1
+            if 0 <= idx < len(evaluations):
+                selected_eval = evaluations[idx]
+                await view_evaluation(selected_eval["path"])
+            else:
+                print("Invalid selection")
+        except ValueError:
+            print("Invalid input")
+
+    # View specific run
+    elif args.run_id:
+        eval_path = evals_dir / args.run_id
+        await view_evaluation(eval_path)
+
+    # View latest
+    elif args.latest and evaluations:
+        latest_eval = evaluations[0]
+        await view_evaluation(latest_eval["path"])
+
+
+if __name__ == "__main__":
+    asyncio.run(main())