synth-ai 0.2.8.dev2__py3-none-any.whl → 0.4.3__py3-none-any.whl

synth_ai/environments/examples/bandit/engine.py

@@ -1,294 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any
-
-import numpy as np
-
-from synth_ai.environments.environment.shared_engine import (
-    GetObservationCallable,
-    InternalObservation,
-)
-from synth_ai.environments.reproducibility.core import IReproducibleEngine
-from synth_ai.environments.stateful.engine import StatefulEngine, StatefulEngineSnapshot
-from synth_ai.environments.tasks.core import TaskInstance
-
-
-@dataclass
-class BanditPublicState:
-    arm_count: int
-    step_count: int
-    max_steps: int
-    last_arm: int | None
-    last_reward: float | None
-    cumulative_reward: float
-    reward_history: list[float]
-    arm_pull_counts: list[int]
-    terminated: bool
-    status: str
-
-    @property
-    def steps_remaining(self) -> int:
-        return max(0, self.max_steps - self.step_count)
-
-    @property
-    def average_reward(self) -> float:
-        return self.cumulative_reward / self.step_count if self.step_count else 0.0
-
-
-@dataclass
-class BanditPrivateState:
-    reward_last: float
-    total_reward: float
-    terminated: bool
-    truncated: bool
-    true_expected_rewards: list[float]
-    step_count: int
-
-
-@dataclass
-class BanditEngineSnapshot(StatefulEngineSnapshot):
-    task_instance_dict: dict[str, Any]
-    engine_snapshot: dict[str, Any]
-
-
-class BanditEngine(StatefulEngine, IReproducibleEngine):
-    def __init__(self, task_instance: TaskInstance):
-        self.task_instance = task_instance
-
-        metadata = getattr(task_instance, "metadata", None)
-        self.bandit_type: str = getattr(metadata, "bandit_type", "bernoulli")
-        self.max_steps: int = int(getattr(metadata, "max_steps", 100))
-        self.seed: int | None = getattr(metadata, "seed", None)
-
-        self.arm_probabilities: list[float] | None = None
-        self.arm_means: list[float] | None = None
-        self.arm_stds: list[float] | None = None
-
-        if self.bandit_type.lower() == "bernoulli":
-            probs = list(getattr(metadata, "arm_probabilities", []) or [])
-            if not probs:
-                probs = [0.1, 0.5, 0.9]
-            self.arm_probabilities = [float(p) for p in probs]
-            self.true_expected_rewards = self.arm_probabilities.copy()
-        elif self.bandit_type.lower() == "gaussian":
-            means = list(getattr(metadata, "arm_means", []) or [])
-            if not means:
-                means = [0.0, 0.5, 1.0]
-            stds = getattr(metadata, "arm_stds", None)
-            if stds is None:
-                stds_list = [0.1] * len(means)
-            elif isinstance(stds, int | float):
-                stds_list = [float(stds)] * len(means)
-            else:
-                stds_list = [float(s) for s in stds]
-            if len(stds_list) != len(means):
-                raise ValueError("arm_stds must match arm_means length")
-            self.arm_means = [float(m) for m in means]
-            self.arm_stds = stds_list
-            self.true_expected_rewards = self.arm_means.copy()
-        else:
-            raise ValueError(f"Unsupported bandit_type: {self.bandit_type}")
-
-        self.arm_count = len(self.true_expected_rewards)
-        if self.arm_count == 0:
-            raise ValueError("Bandit must have at least one arm")
-
-        self._rng = np.random.default_rng(self.seed)
-
-        # Runtime state
-        self.step_count: int = 0
-        self.total_reward: float = 0.0
-        self.last_reward: float = 0.0
-        self.last_arm: int | None = None
-        self.reward_history: list[float] = []
-        self.arm_history: list[int] = []
-        self.arm_pull_counts: list[int] = [0 for _ in range(self.arm_count)]
-        self.terminated: bool = False
-        self.status: str = "in_progress"
-
-    async def _reset_engine(self) -> tuple[BanditPrivateState, BanditPublicState]:
-        if self.seed is not None:
-            self._rng = np.random.default_rng(self.seed)
-        else:
-            self._rng = np.random.default_rng()
-
-        self.step_count = 0
-        self.total_reward = 0.0
-        self.last_reward = 0.0
-        self.last_arm = None
-        self.reward_history = []
-        self.arm_history = []
-        self.arm_pull_counts = [0 for _ in range(self.arm_count)]
-        self.terminated = False
-        self.status = "in_progress"
-
-        private_state = self._build_private_state(reward=0.0)
-        public_state = self._build_public_state(reward=None)
-        return private_state, public_state
-
-    async def _step_engine(self, arm_index: int) -> tuple[BanditPrivateState, BanditPublicState]:
-        if self.terminated:
-            raise RuntimeError("Bandit episode already terminated")
-
-        if not isinstance(arm_index, int):
-            raise TypeError("arm_index must be an integer")
-        if arm_index < 0 or arm_index >= self.arm_count:
-            raise ValueError(f"arm_index {arm_index} out of range 0..{self.arm_count - 1}")
-
-        reward = float(self._sample_reward(arm_index))
-
-        self.step_count += 1
-        self.total_reward += reward
-        self.last_reward = reward
-        self.last_arm = arm_index
-        self.reward_history.append(reward)
-        self.arm_history.append(arm_index)
-        self.arm_pull_counts[arm_index] += 1
-
-        if self.step_count >= self.max_steps:
-            self.terminated = True
-            self.status = "completed"
-
-        private_state = self._build_private_state(reward=reward)
-        public_state = self._build_public_state(reward=reward)
-        return private_state, public_state
-
-    def _sample_reward(self, arm_index: int) -> float:
-        if self.bandit_type.lower() == "bernoulli":
-            assert self.arm_probabilities is not None
-            success_prob = self.arm_probabilities[arm_index]
-            return 1.0 if self._rng.random() < success_prob else 0.0
-
-        if self.bandit_type.lower() == "gaussian":
-            assert self.arm_means is not None and self.arm_stds is not None
-            mean = self.arm_means[arm_index]
-            std = self.arm_stds[arm_index]
-            return float(self._rng.normal(loc=mean, scale=std))
-
-        raise RuntimeError(f"Unknown bandit_type during sampling: {self.bandit_type}")
-
-    def get_current_states_for_observation(
-        self,
-    ) -> tuple[BanditPrivateState, BanditPublicState]:
-        private_state = self._build_private_state(reward=self.last_reward)
-        public_state = self._build_public_state(reward=self.last_reward)
-        return private_state, public_state
-
-    def _build_private_state(self, reward: float) -> BanditPrivateState:
-        return BanditPrivateState(
-            reward_last=float(reward),
-            total_reward=float(self.total_reward),
-            terminated=self.terminated,
-            truncated=False,
-            true_expected_rewards=self.true_expected_rewards.copy(),
-            step_count=self.step_count,
-        )
-
-    def _build_public_state(self, reward: float | None) -> BanditPublicState:
-        return BanditPublicState(
-            arm_count=self.arm_count,
-            step_count=self.step_count,
-            max_steps=self.max_steps,
-            last_arm=self.last_arm,
-            last_reward=float(reward) if reward is not None else (self.last_reward if self.step_count else None),
-            cumulative_reward=float(self.total_reward),
-            reward_history=self.reward_history.copy(),
-            arm_pull_counts=self.arm_pull_counts.copy(),
-            terminated=self.terminated,
-            status=self.status,
-        )
-
-    async def _serialize_engine(self) -> BanditEngineSnapshot:
-        snapshot = {
-            "bandit_type": self.bandit_type,
-            "arm_probabilities": self.arm_probabilities,
-            "arm_means": self.arm_means,
-            "arm_stds": self.arm_stds,
-            "max_steps": self.max_steps,
-            "seed": self.seed,
-            "step_count": self.step_count,
-            "total_reward": self.total_reward,
-            "last_reward": self.last_reward,
-            "last_arm": self.last_arm,
-            "reward_history": self.reward_history,
-            "arm_history": self.arm_history,
-            "arm_pull_counts": self.arm_pull_counts,
-            "terminated": self.terminated,
-            "status": self.status,
-            "true_expected_rewards": self.true_expected_rewards,
-            "rng_state": self._rng.bit_generator.state,
-        }
-        return BanditEngineSnapshot(
-            task_instance_dict=await self.task_instance.serialize(),
-            engine_snapshot=snapshot,
-        )
-
-    @classmethod
-    async def _deserialize_engine(cls, snapshot: BanditEngineSnapshot) -> BanditEngine:
-        from .taskset import BanditTaskInstance
-
-        task_instance = await BanditTaskInstance.deserialize(snapshot.task_instance_dict)
-        engine = cls(task_instance)
-
-        data = snapshot.engine_snapshot
-        engine.bandit_type = data.get("bandit_type", engine.bandit_type)
-        engine.max_steps = int(data.get("max_steps", engine.max_steps))
-        engine.seed = data.get("seed", engine.seed)
-        engine.arm_probabilities = data.get("arm_probabilities", engine.arm_probabilities)
-        engine.arm_means = data.get("arm_means", engine.arm_means)
-        engine.arm_stds = data.get("arm_stds", engine.arm_stds)
-        engine.true_expected_rewards = list(data.get("true_expected_rewards", engine.true_expected_rewards))
-        engine.arm_count = len(engine.true_expected_rewards)
-
-        engine.step_count = int(data.get("step_count", 0))
-        engine.total_reward = float(data.get("total_reward", 0.0))
-        engine.last_reward = float(data.get("last_reward", 0.0))
-        engine.last_arm = data.get("last_arm")
-        engine.reward_history = list(data.get("reward_history", []))
-        engine.arm_history = list(data.get("arm_history", []))
-        engine.arm_pull_counts = list(data.get("arm_pull_counts", [0 for _ in range(engine.arm_count)]))
-        engine.terminated = bool(data.get("terminated", False))
-        engine.status = data.get("status", "in_progress")
-
-        engine._rng = np.random.default_rng()
-        rng_state = data.get("rng_state")
-        if rng_state is not None:
-            engine._rng.bit_generator.state = rng_state
-
-        return engine
-
-
-class SynthBanditObservationCallable(GetObservationCallable):
-    async def get_observation(
-        self, pub: BanditPublicState, priv: BanditPrivateState
-    ) -> InternalObservation:
-        observation: InternalObservation = {
-            "arm_count": pub.arm_count,
-            "steps_taken": pub.step_count,
-            "steps_remaining": pub.steps_remaining,
-            "last_arm": pub.last_arm,
-            "last_reward": pub.last_reward,
-            "cumulative_reward": priv.total_reward,
-            "average_reward": pub.average_reward,
-            "arm_pull_counts": pub.arm_pull_counts,
-            "reward_history": pub.reward_history,
-            "terminated": pub.terminated,
-            "status": pub.status,
-        }
-        return observation
-
-
-class SynthBanditCheckpointObservationCallable(GetObservationCallable):
-    async def get_observation(
-        self, pub: BanditPublicState, priv: BanditPrivateState
-    ) -> InternalObservation:
-        observation: InternalObservation = {
-            "arm_count": pub.arm_count,
-            "total_reward": priv.total_reward,
-            "steps_taken": pub.step_count,
-            "best_expected_reward": max(priv.true_expected_rewards) if priv.true_expected_rewards else None,
-            "terminated": pub.terminated,
-            "status": pub.status,
-        }
-        return observation

synth_ai/environments/examples/bandit/environment.py

@@ -1,194 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from pydantic import BaseModel, Field, ValidationError
-
-from synth_ai.environments.environment.shared_engine import (
-    GetObservationCallable,
-    InternalObservation,
-)
-from synth_ai.environments.environment.tools import (
-    AbstractTool,
-    EnvToolCall,
-    ToolResult,
-)
-from synth_ai.environments.reproducibility.core import ReproducibleEnvironment
-from synth_ai.environments.stateful.core import StatefulEnvironment
-from synth_ai.environments.tasks.core import TaskInstance
-
-from .engine import (
-    BanditEngine,
-    BanditEngineSnapshot,
-    SynthBanditCheckpointObservationCallable,
-    SynthBanditObservationCallable,
-)
-
-
-class BanditActionInput(BaseModel):
-    arm: int = Field(..., ge=0, description="Index of the arm to pull (0-based)")
-
-
-class BanditInteractTool(AbstractTool):
-    name = "pull_arm"
-    description = "Pull a specific bandit arm to receive a stochastic reward."
-    call_schema = BanditActionInput
-    result_schema = ToolResult
-
-    def __init__(self, engine: BanditEngine):
-        self.engine = engine
-
-    async def __call__(self, call: EnvToolCall) -> ToolResult:
-        try:
-            parsed = self.call_schema(**call.args)
-        except ValidationError as exc:
-            return ToolResult(ok=False, error=str(exc))
-
-        try:
-            private_state, public_state = await self.engine._step_engine(parsed.arm)
-        except Exception as exc:  # noqa: BLE001 - propagate as tool error
-            priv, pub = self.engine.get_current_states_for_observation()
-            return ToolResult(
-                ok=False,
-                error=str(exc),
-                payload={"private_state": priv, "public_state": pub},
-            )
-
-        return ToolResult(
-            ok=True,
-            payload={"private_state": private_state, "public_state": public_state},
-        )
-
-
-class BanditEnvironment(StatefulEnvironment, ReproducibleEnvironment[BanditEngine]):
-    def __init__(
-        self,
-        task_instance: TaskInstance,
-        custom_step_obs: GetObservationCallable | None = None,
-        custom_ckpt_obs: GetObservationCallable | None = None,
-    ) -> None:
-        self.name = "Bandit"
-        self.task_instance = task_instance
-        self.custom_step_observation_callable = custom_step_obs or SynthBanditObservationCallable()
-        self.custom_checkpoint_observation_callable = (
-            custom_ckpt_obs or SynthBanditCheckpointObservationCallable()
-        )
-        self.engine = BanditEngine(task_instance)
-        self._interact_tool = BanditInteractTool(self.engine)
-
-    async def initialize(self) -> InternalObservation:
-        priv, pub = await self.engine._reset_engine()
-        return await self._to_observation(priv, pub, self.custom_step_observation_callable)
-
-    async def step(self, tool_calls: list[EnvToolCall] | EnvToolCall | Any) -> InternalObservation:
-        validated_call = self.validate_tool_calls(tool_calls)
-        result = await self._interact_tool(validated_call)
-
-        if result.ok and result.payload:
-            priv = result.payload["private_state"]
-            pub = result.payload["public_state"]
-            return await self._to_observation(priv, pub, self.custom_step_observation_callable)
-
-        priv, pub = self.engine.get_current_states_for_observation()
-        return await self._to_observation(
-            priv,
-            pub,
-            self.custom_step_observation_callable,
-            extra_obs={"error": result.error} if result.error else None,
-        )
-
-    async def checkpoint(self) -> InternalObservation:
-        priv, pub = self.engine.get_current_states_for_observation()
-        return await self._to_observation(priv, pub, self.custom_checkpoint_observation_callable)
-
-    async def terminate(self) -> InternalObservation:
-        priv, pub = self.engine.get_current_states_for_observation()
-        self.engine.terminated = True
-        pub.terminated = True
-        priv.terminated = True
-        if pub.status != "completed":
-            pub.status = "terminated"
-        return await self._to_observation(priv, pub, self.custom_checkpoint_observation_callable)
-
-    def validate_tool_calls(self, tool_calls: Any) -> EnvToolCall:
-        if isinstance(tool_calls, EnvToolCall):
-            candidate = tool_calls
-        elif isinstance(tool_calls, dict):
-            if "tool" in tool_calls:
-                candidate = EnvToolCall(tool=tool_calls["tool"], args=tool_calls.get("args", {}))
-            elif "name" in tool_calls:
-                candidate = EnvToolCall(
-                    tool=tool_calls["name"], args=tool_calls.get("parameters", {})
-                )
-            elif "function" in tool_calls:
-                func_spec = tool_calls["function"]
-                candidate = EnvToolCall(
-                    tool=func_spec.get("name", "pull_arm"),
-                    args=func_spec.get("arguments", {}),
-                )
-            else:
-                candidate = EnvToolCall(tool="pull_arm", args=tool_calls)
-        elif isinstance(tool_calls, list):
-            if not tool_calls:
-                raise ValueError("Empty tool calls list")
-            return self.validate_tool_calls(tool_calls[0])
-        else:
-            if isinstance(tool_calls, int):
-                return EnvToolCall(tool="pull_arm", args={"arm": tool_calls})
-            try:
-                return EnvToolCall(tool="pull_arm", args={"arm": int(tool_calls)})
-            except (TypeError, ValueError) as exc:
-                raise TypeError("Unsupported tool_calls format for bandit environment") from exc
-
-        tool_name = candidate.tool
-        if tool_name not in {"pull_arm", "interact"}:
-            raise ValueError(f"Unknown tool: {tool_name}")
-
-        args = dict(candidate.args or {})
-        if "arm" not in args:
-            for alias in ("action", "index", "arm_index", "armId", "choice"):
-                if alias in args:
-                    args["arm"] = args[alias]
-                    break
-        if "arm" not in args:
-            raise ValueError("Missing required 'arm' argument")
-
-        try:
-            arm_idx = int(args["arm"])
-        except (TypeError, ValueError) as exc:
-            raise ValueError("'arm' argument must be an integer") from exc
-
-        if arm_idx < 0:
-            raise ValueError("'arm' argument must be non-negative")
-
-        return EnvToolCall(tool="pull_arm", args={"arm": arm_idx})
-
-    async def _to_observation(
-        self,
-        priv,
-        pub,
-        obs_cb: GetObservationCallable | None,
-        extra_obs: dict[str, Any] | None = None,
-    ) -> InternalObservation:
-        observation: InternalObservation
-        if obs_cb:
-            observation = await obs_cb.get_observation(pub, priv)
-        else:
-            observation = {}
-        if extra_obs and isinstance(observation, dict):
-            observation.update(extra_obs)
-        return observation
-
-    async def _serialize_engine(self) -> BanditEngineSnapshot:
-        return await self.engine._serialize_engine()
-
-    @classmethod
-    async def _deserialize_engine(
-        cls,
-        snapshot: BanditEngineSnapshot,
-        task_instance: TaskInstance,
-    ) -> BanditEnvironment:
-        env = cls(task_instance)
-        env.engine = await BanditEngine._deserialize_engine(snapshot)
-        env._interact_tool = BanditInteractTool(env.engine)
-        return env

synth_ai/environments/examples/bandit/taskset.py

@@ -1,200 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Iterable
-from dataclasses import dataclass
-from typing import Any
-from uuid import UUID, uuid4
-
-from synth_ai.environments.tasks.core import (
-    Impetus,
-    Intent,
-    SplitInfo,
-    TaskInstance,
-    TaskInstanceMetadata,
-    TaskInstanceSet,
-)
-
-
-@dataclass
-class BanditTaskInstanceMetadata(TaskInstanceMetadata):
-    name: str
-    bandit_type: str
-    arm_probabilities: list[float] | None
-    arm_means: list[float] | None
-    arm_stds: list[float] | None
-    max_steps: int
-    seed: int | None = None
-
-
-@dataclass
-class BanditTaskInstance(TaskInstance):
-    async def serialize(self) -> dict[str, Any]:
-        return {
-            "id": str(self.id),
-            "impetus": {"instructions": self.impetus.instructions},
-            "intent": {
-                "rubric": self.intent.rubric,
-                "gold_trajectories": self.intent.gold_trajectories,
-                "gold_state_diff": self.intent.gold_state_diff,
-            },
-            "metadata": {
-                "name": self.metadata.name,
-                "bandit_type": self.metadata.bandit_type,
-                "arm_probabilities": self.metadata.arm_probabilities,
-                "arm_means": self.metadata.arm_means,
-                "arm_stds": self.metadata.arm_stds,
-                "max_steps": self.metadata.max_steps,
-                "seed": self.metadata.seed,
-            },
-            "is_reproducible": self.is_reproducible,
-            "initial_engine_snapshot": self.initial_engine_snapshot,
-        }
-
-    @classmethod
-    async def deserialize(cls, data: dict[str, Any]) -> BanditTaskInstance:
-        metadata = BanditTaskInstanceMetadata(
-            name=data["metadata"].get("name", "bandit"),
-            bandit_type=data["metadata"].get("bandit_type", "bernoulli"),
-            arm_probabilities=data["metadata"].get("arm_probabilities"),
-            arm_means=data["metadata"].get("arm_means"),
-            arm_stds=data["metadata"].get("arm_stds"),
-            max_steps=int(data["metadata"].get("max_steps", 100)),
-            seed=data["metadata"].get("seed"),
-        )
-        return cls(
-            id=UUID(data["id"]),
-            impetus=Impetus(instructions=data["impetus"]["instructions"]),
-            intent=Intent(
-                rubric=data["intent"].get("rubric", {}),
-                gold_trajectories=data["intent"].get("gold_trajectories"),
-                gold_state_diff=data["intent"].get("gold_state_diff", {}),
-            ),
-            metadata=metadata,
-            is_reproducible=bool(data.get("is_reproducible", True)),
-            initial_engine_snapshot=data.get("initial_engine_snapshot"),
-        )
-
-
-def _expected_rewards(metadata: BanditTaskInstanceMetadata) -> list[float]:
-    if metadata.bandit_type.lower() == "bernoulli" and metadata.arm_probabilities:
-        return [float(p) for p in metadata.arm_probabilities]
-    if metadata.bandit_type.lower() == "gaussian" and metadata.arm_means:
-        return [float(m) for m in metadata.arm_means]
-    return []
-
-
-def _default_bandit_configs() -> list[dict[str, Any]]:
-    return [
-        {
-            "name": "bernoulli-easy",
-            "bandit_type": "bernoulli",
-            "arm_probabilities": [0.1, 0.4, 0.8],
-            "max_steps": 50,
-            "seed": 7,
-        },
-        {
-            "name": "bernoulli-close",
-            "bandit_type": "bernoulli",
-            "arm_probabilities": [0.45, 0.5, 0.55],
-            "max_steps": 75,
-            "seed": 21,
-        },
-        {
-            "name": "gaussian-wide",
-            "bandit_type": "gaussian",
-            "arm_means": [0.0, 0.3, 1.0],
-            "arm_stds": [0.2, 0.2, 0.4],
-            "max_steps": 60,
-            "seed": 14,
-        },
-    ]
-
-
-def _build_impetus(metadata: BanditTaskInstanceMetadata, arm_count: int) -> Impetus:
-    bandit_desc = metadata.bandit_type.capitalize()
-    return Impetus(
-        instructions=(
-            f"You are interacting with a {bandit_desc} multi-armed bandit task. "
-            f"There are {arm_count} arms, indexed from 0 to {arm_count - 1}. "
-            f"You may pull up to {metadata.max_steps} arms. "
-            "Your objective is to maximize the cumulative reward by learning which arm has the highest expected payoff."
-        )
-    )
-
-
-def _build_intent(expected_rewards: Iterable[float]) -> Intent:
-    rewards = list(expected_rewards)
-    best_arm = max(range(len(rewards)), key=rewards.__getitem__) if rewards else 0
-    return Intent(
-        rubric={
-            "goal": "Maximize cumulative reward over the episode",
-            "measurement": "Higher total reward indicates better performance",
-        },
-        gold_trajectories=None,
-        gold_state_diff={
-            "best_arm_index": best_arm,
-            "expected_rewards": rewards,
-        },
-    )
-
-
-async def create_bandit_taskset(
-    configs: list[dict[str, Any]] | None = None,
-) -> TaskInstanceSet:
-    configs = configs or _default_bandit_configs()
-
-    instances: list[BanditTaskInstance] = []
-    for config in configs:
-        metadata = BanditTaskInstanceMetadata(
-            name=config.get("name", "bandit"),
-            bandit_type=config.get("bandit_type", "bernoulli"),
-            arm_probabilities=config.get("arm_probabilities"),
-            arm_means=config.get("arm_means"),
-            arm_stds=config.get("arm_stds"),
-            max_steps=int(config.get("max_steps", 100)),
-            seed=config.get("seed"),
-        )
-
-        expected = _expected_rewards(metadata)
-        arm_count = len(expected) if expected else (
-            len(metadata.arm_probabilities or [])
-            or len(metadata.arm_means or [])
-            or 0
-        )
-        if arm_count == 0:
-            arm_count = 1
-
-        impetus = _build_impetus(metadata, arm_count)
-        intent = _build_intent(expected)
-
-        instance = BanditTaskInstance(
-            id=uuid4(),
-            impetus=impetus,
-            intent=intent,
-            metadata=metadata,
-            is_reproducible=True,
-            initial_engine_snapshot=None,
-        )
-        instances.append(instance)
-
-    # Simple deterministic splits by index
-    val_ids = {instances[i].id for i in range(0, len(instances), 3)}
-    test_ids = {instances[i].id for i in range(1, len(instances), 3)}
-
-    split_info = SplitInfo(
-        val_instance_ids=val_ids,
-        test_instance_ids=test_ids,
-        _is_split_defined=bool(instances),
-    )
-
-    return TaskInstanceSet(
-        name="Bandit Example TaskSet",
-        description="Lightweight Bernoulli and Gaussian bandit tasks inspired by OpenAI Gym bandits.",
-        instances=instances,
-        split_info=split_info,
-    )
-
-
-# Alias for convenience
-
-taskset = create_bandit_taskset

synth_ai/environments/examples/crafter_classic/__init__.py

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