synth-ai 0.2.6.dev1__py3-none-any.whl → 0.4.3__py3-none-any.whl

synth_ai/demos/demo_task_apps/math/config.toml

@@ -1,44 +0,0 @@
-[model]
-name = "Qwen/Qwen3-0.6B"
-dtype = "bfloat16"
-seed = 42
-
-[reference]
-placement = "dedicated"
-port = 8002
-
-[topology]
-type = "single_node_split"
-gpus_for_vllm = 1
-gpus_for_training = 1
-gpus_for_ref = 1
-
-[training]
-num_epochs = 5
-iterations_per_epoch = 1
-batch_size = 4
-group_size = 16
-learning_rate = 5e-6
-max_grad_norm = 0.5
-log_interval = 1
-update_reference_interval = 0
-weight_sync_interval = 1
-
-[evaluation]
-seeds = [0, 1, 2, 3]
-rollouts_per_seed = 1
-instances = 1
-max_concurrent_rollouts = 4
-thinking_mode = "none"
-every_n_iters = 2
-
-[rollout]
-env_name = "math"
-policy_name = "math-react"
-max_steps_per_episode = 1
-sampling_temperature = 0.3
-sampling_top_p = 0.95
-max_tokens = 256
-max_concurrent_rollouts = 8
-ops_per_rollout = 2
-on_done = "reset"

synth_ai/demos/demo_task_apps/math/deploy_task_app.sh

@@ -1,22 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-log_file="${script_dir}/.last_deploy.log"
-rm -f "$log_file"
-
-: "${ENVIRONMENT_API_KEY:=}"
-
-repo_root="$(cd "${script_dir}/../../../.." && pwd)"
-fallback_script="${repo_root}/examples/rl/deploy_task_app.sh"
-
-if [[ -f "${fallback_script}" ]]; then
-  echo "Using ${fallback_script} via 'uv run'" | tee -a "$log_file"
-  (cd "${repo_root}/examples/rl" && ENVIRONMENT_API_KEY="${ENVIRONMENT_API_KEY}" uv run bash "${fallback_script}" | tee -a "$log_file")
-else
-  echo "ERROR: Deploy script not found at ${fallback_script}. Pass --script /path/to/deploy_task_app.sh" | tee -a "$log_file"
-  exit 1
-fi
-
-echo "Deploy finished. Inspect $log_file for the public URL (…modal.run)." | tee -a "$log_file"
-

synth_ai/environments/__init__.py

@@ -1,31 +0,0 @@
-"""Synth Environment Package - A framework for reinforcement learning environments."""
-
-__version__ = "0.1.5"
-
-# Import key modules for easier access
-from . import environment, examples, service, stateful, tasks
-
-__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__]
-sys.modules["src"].synth_env = sys.modules[__name__]

synth_ai/environments/environment/__init__.py

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

synth_ai/environments/environment/artifacts/__init__.py

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

synth_ai/environments/environment/artifacts/base.py

@@ -1,52 +0,0 @@
-from __future__ import annotations
-
-import shutil
-from abc import ABC, abstractmethod
-from pathlib import Path
-
-from pydantic import BaseModel
-
-
-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

@@ -1,67 +0,0 @@
-from synth_ai.core.system import System
-
-
-class Environment(System):
-    """
-    Base class for all environments in the Synth AI framework.
-
-    This class provides the fundamental structure for all environment types,
-    including a name attribute system that supports both automatic naming
-    based on the class name and manual name assignment.
-
-    The Environment class serves as the foundation for more specialized
-    environment types like StatefulEnvironment, providing common functionality
-    and ensuring consistent interfaces across all environment implementations.
-
-    Attributes:
-        _default_name: Class-level default name derived from the class name
-        _name: Instance-level name override (optional)
-
-    Example:
-        >>> class MyCustomEnv(Environment):
-        ...     pass
-        >>> env = MyCustomEnv()
-        >>> print(env.name)  # "MyCustomEnv"
-        >>> env.name = "custom_environment"
-        >>> print(env.name)  # "custom_environment"
-    """
-
-    _default_name: str
-
-    def __init_subclass__(cls, **kwargs):
-        """
-        Initialize subclass with automatic name assignment.
-
-        This method is called when a new subclass of Environment is created.
-        It automatically sets the _default_name attribute to the class name,
-        providing a fallback name for environment instances.
-
-        Args:
-            **kwargs: Additional keyword arguments passed to parent classes
-        """
-        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:
-        """
-        Get the environment name.
-
-        Returns the instance-specific name if set via the setter,
-        otherwise returns the class-level default name.
-
-        Returns:
-            str: The environment name, either custom or default
-        """
-        return getattr(self, "_name", self._default_name)
-
-    @name.setter
-    def name(self, value: str):
-        """
-        Set a custom name for this environment instance.
-
-        Args:
-            value: The custom name to assign to this environment
-        """
-        self._name = value

synth_ai/environments/environment/db/__init__.py

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

synth_ai/environments/environment/db/sqlite.py

@@ -1,45 +0,0 @@
-import contextlib
-import sqlite3
-import threading
-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

@@ -1,233 +0,0 @@
-"""
-Environment Registry Module
-
-This module provides a global registry system for environment types in the Synth AI framework.
-The registry allows environments to be registered by name and retrieved dynamically,
-enabling flexible environment management and discovery.
-
-The registry supports:
-- Dynamic environment registration at runtime
-- Type-safe environment retrieval
-- Environment discovery and listing
-- Centralized environment management
-
-Example:
-    >>> from synth_ai.environments.environment.registry import register_environment
-    >>> from myproject.environments import MyCustomEnvironment
-
-    >>> # Register a custom environment
-    >>> register_environment("my_env", MyCustomEnvironment)
-
-    >>> # List available environments
-    >>> available_envs = list_supported_env_types()
-    >>> print("Available environments:", available_envs)
-
-    >>> # Get environment class for instantiation
-    >>> env_cls = get_environment_cls("my_env")
-    >>> env_instance = env_cls(task_config)
-"""
-
-import importlib.metadata
-import logging
-
-from synth_ai.environments.stateful.core import StatefulEnvironment
-
-logger = logging.getLogger(__name__)
-
-# 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.
-
-    This function adds an environment class to the global registry, making it
-    available for dynamic instantiation by name. This is particularly useful
-    for building flexible systems where environment types are determined at
-    runtime or configured through external settings.
-
-    Args:
-        name: Unique identifier for the environment. This name will be used
-            to retrieve the environment class later. Names should be descriptive
-            and follow a consistent naming convention (e.g., "CartPole", "Sokoban").
-        cls: The environment class to register. Must be a subclass of
-            StatefulEnvironment and implement all required abstract methods.
-
-    Raises:
-        TypeError: If cls is not a subclass of StatefulEnvironment
-        ValueError: If name is empty or None
-
-    Example:
-        >>> class MyGameEnvironment(StatefulEnvironment):
-        ...     # Implementation of abstract methods
-        ...     pass
-
-        >>> register_environment("my_game", MyGameEnvironment)
-        >>>
-        >>> # Now the environment can be retrieved by name
-        >>> env_cls = get_environment_cls("my_game")
-        >>> env = env_cls(task_config)
-
-    Note:
-        Environment names are case-sensitive. It's recommended to use
-        consistent naming conventions (e.g., lowercase with underscores
-        or CamelCase) across your application.
-    """
-    ENV_REGISTRY[name] = cls
-
-
-def get_environment_cls(env_type: str) -> type[StatefulEnvironment]:
-    """
-    Retrieve a registered environment class by name.
-
-    This function looks up an environment class in the global registry
-    and returns it for instantiation. This enables dynamic environment
-    creation based on string identifiers, which is useful for:
-    - Configuration-driven environment selection
-    - API endpoints that accept environment type parameters
-    - Plugin systems and modular architectures
-    - Testing frameworks that need to test multiple environment types
-
-    Args:
-        env_type: The name of the environment type to retrieve. Must match
-            a name that was previously registered using register_environment().
-
-    Returns:
-        Type[StatefulEnvironment]: The environment class that can be instantiated
-            with appropriate task parameters.
-
-    Raises:
-        ValueError: If env_type is not found in the registry. The error message
-            will include the invalid type name and suggest checking available types.
-
-    Example:
-        >>> # Retrieve and instantiate an environment
-        >>> env_cls = get_environment_cls("CartPole")
-        >>> environment = env_cls(task_instance)
-        >>>
-        >>> # Use in configuration-driven scenarios
-        >>> config = {"environment_type": "Sokoban", "difficulty": "easy"}
-        >>> env_cls = get_environment_cls(config["environment_type"])
-        >>> env = env_cls(create_task(config))
-
-    See Also:
-        list_supported_env_types(): Get all available environment type names
-        register_environment(): Register new environment types
-    """
-    try:
-        return ENV_REGISTRY[env_type]
-    except KeyError:
-        available_types = list(ENV_REGISTRY.keys())
-        raise ValueError(
-            f"Unsupported environment type: '{env_type}'. Available types: {available_types}"
-        ) from None
-
-
-def list_supported_env_types() -> list[str]:
-    """
-    List all registered environment type names.
-
-    This function returns a list of all environment names that have been
-    registered in the global registry. It's useful for:
-    - Displaying available options to users
-    - Validating environment type parameters
-    - Building dynamic UIs or configuration tools
-    - Debugging and development
-
-    Returns:
-        List[str]: Sorted list of all registered environment type names.
-            Returns an empty list if no environments have been registered.
-
-    Example:
-        >>> # Check what environments are available
-        >>> available_envs = list_supported_env_types()
-        >>> print("Supported environments:")
-        >>> for env_type in available_envs:
-        ...     print(f"  - {env_type}")
-
-        >>> # Validate user input
-        >>> user_choice = input("Choose environment: ")
-        >>> if user_choice not in list_supported_env_types():
-        ...     print(f"Error: {user_choice} not available")
-
-        >>> # Build configuration options
-        >>> config_schema = {
-        ...     "environment_type": {
-        ...         "enum": list_supported_env_types(),
-        ...         "description": "Type of environment to use"
-        ...     }
-        ... }
-
-    Note:
-        The returned list is sorted alphabetically for consistent ordering.
-        This function returns a copy of the environment names, so modifying
-        the returned list will not affect the registry.
-    """
-    return sorted(ENV_REGISTRY.keys())
-
-
-def discover_entry_point_environments() -> None:
-    """
-    Discover and register environments from entry points.
-
-    This function scans for environments registered via setuptools entry points
-    under the group 'synth_ai.environments'. This allows third-party packages
-    to register environments by declaring them in their pyproject.toml:
-
-    [project.entry-points."synth_ai.environments"]
-    my_env = "my_package.my_env:MyEnvironment"
-    another_env = "my_package.other:AnotherEnv"
-
-    The function will automatically import and register all discovered environments.
-    """
-    try:
-        entry_points = importlib.metadata.entry_points()
-        if hasattr(entry_points, "select"):
-            # Python 3.10+
-            env_entry_points = entry_points.select(group="synth_ai.environments")
-        else:
-            # Python 3.9 and below
-            env_entry_points = entry_points.get("synth_ai.environments", [])
-
-        for entry_point in env_entry_points:
-            try:
-                env_cls = entry_point.load()
-
-                # Validate that it's a StatefulEnvironment subclass
-                if not issubclass(env_cls, StatefulEnvironment):
-                    logger.warning(
-                        f"Entry point '{entry_point.name}' from '{entry_point.value}' "
-                        f"is not a StatefulEnvironment subclass. Skipping."
-                    )
-                    continue
-
-                register_environment(entry_point.name, env_cls)
-                logger.info(f"Registered environment '{entry_point.name}' from entry point")
-
-            except Exception as e:
-                logger.error(
-                    f"Failed to load environment entry point '{entry_point.name}' "
-                    f"from '{entry_point.value}': {e}"
-                )
-    except Exception as e:
-        logger.debug(f"Entry point discovery failed (this is normal if no entry points exist): {e}")
-
-
-def auto_discover_environments() -> None:
-    """
-    Automatically discover and register environments from multiple sources.
-
-    This function combines multiple discovery mechanisms:
-    1. Entry points (setuptools plugins)
-    2. Could be extended with more discovery methods in the future
-
-    This should be called once at application startup to populate the registry
-    with all available environments.
-    """
-    discover_entry_point_environments()
-
-
-# Auto-discover environments when the registry module is imported
-# This ensures third-party environments are available as soon as the registry is used
-auto_discover_environments()

synth_ai/environments/environment/resources/sqlite.py

@@ -1,45 +0,0 @@
-import contextlib
-import sqlite3
-import threading
-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/results.py

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

synth_ai/environments/environment/rewards/__init__.py

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

synth_ai/environments/environment/rewards/core.py

@@ -1,29 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from typing import 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

@@ -1,26 +0,0 @@
-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