Add files using upload-large-folder tool

.gitattributes

@@ -4445,3 +4445,5 @@ tool_server/.venv/lib/python3.12/site-packages/ray/data/__pycache__/dataset.cpyt
 tool_server/.venv/lib/python3.12/site-packages/ray/data/__pycache__/read_api.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
 tool_server/.venv/lib/python3.12/site-packages/ray/rllib/algorithms/__pycache__/algorithm.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
 tool_server/.venv/lib/python3.12/site-packages/ray/rllib/algorithms/__pycache__/algorithm_config.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/ray/rllib/env/__pycache__/multi_agent_episode.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/ray/serve/_private/__pycache__/deployment_state.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text

tool_server/.venv/lib/python3.12/site-packages/ray/rllib/env/__pycache__/multi_agent_episode.cpython-312.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5fce1cd7e76ccc16f30a194e79b53a2670fd5eeffd12846f185ac2b5e302619
+size 105683

tool_server/.venv/lib/python3.12/site-packages/ray/rllib/env/external/__init__.py

@@ -0,0 +1,12 @@
+from ray.rllib.env.external.rllink import (
+    get_rllink_message,
+    send_rllink_message,
+    RLlink,
+)
+
+
+__all__ = [
+    "get_rllink_message",
+    "send_rllink_message",
+    "RLlink",
+]

tool_server/.venv/lib/python3.12/site-packages/ray/rllib/env/external/env_runner_server_for_external_inference.py

@@ -0,0 +1,368 @@
+from collections import defaultdict
+import pickle
+import socket
+import threading
+import time
+from typing import Collection, DefaultDict, List, Optional, Union
+
+from ray.rllib.core import (
+    COMPONENT_RL_MODULE,
+    DEFAULT_AGENT_ID,
+    DEFAULT_MODULE_ID,
+)
+from ray.rllib.env import INPUT_ENV_SPACES
+from ray.rllib.env.env_runner import EnvRunner
+from ray.rllib.env.single_agent_env_runner import SingleAgentEnvRunner
+from ray.rllib.env.single_agent_episode import SingleAgentEpisode
+from ray.rllib.env.external.rllink import (
+    get_rllink_message,
+    send_rllink_message,
+    RLlink,
+)
+from ray.rllib.utils.annotations import override
+from ray.rllib.utils.checkpoints import Checkpointable
+from ray.rllib.utils.framework import try_import_torch
+from ray.rllib.utils.metrics import (
+    EPISODE_DURATION_SEC_MEAN,
+    EPISODE_LEN_MAX,
+    EPISODE_LEN_MEAN,
+    EPISODE_LEN_MIN,
+    EPISODE_RETURN_MAX,
+    EPISODE_RETURN_MEAN,
+    EPISODE_RETURN_MIN,
+    WEIGHTS_SEQ_NO,
+)
+from ray.rllib.utils.metrics.metrics_logger import MetricsLogger
+from ray.rllib.utils.typing import EpisodeID, StateDict
+from ray.util.annotations import DeveloperAPI
+
+torch, _ = try_import_torch()
+
+
+@DeveloperAPI
+class EnvRunnerServerForExternalInference(EnvRunner, Checkpointable):
+    """An EnvRunner communicating with an external env through a TCP socket.
+
+    This implementation assumes:
+    - Only one external client ever connects to this env runner.
+    - The external client owns the connector pipelines (env-to-module and module-to-env)
+    as well as the RLModule and thus performs inference locally. Samples are sent in
+    bulk as lists of RLlib episodes once a certain number of timesteps has been executed
+    on the client's side.
+    - A copy of the RLModule is kept at all times on this EnvRunner, but is never used
+    for inference, only as a weights container.
+    TODO (sven): The above might be inefficient as we have to store basically two
+     models, one in this EnvRunner, one in the env (as ONNX).
+    - As a consequence, there are no environment and no connectors on this env runner.
+    The external env is responsible for generating all the data to create episodes.
+    """
+
+    @override(EnvRunner)
+    def __init__(self, *, config, **kwargs):
+        """
+        Initializes an EnvRunnerServerForExternalInference instance.
+
+        Args:
+            config: The AlgorithmConfig to use for setup.
+
+        Keyword Args:
+            port: The base port number. The server socket is then actually bound to
+                `port` + self.worker_index.
+        """
+        super().__init__(config=config, **kwargs)
+
+        self.worker_index: int = kwargs.get("worker_index", 0)
+
+        self._weights_seq_no = 0
+
+        # Build the module from its spec.
+        module_spec = self.config.get_rl_module_spec(
+            spaces=self.get_spaces(), inference_only=True
+        )
+        self.module = module_spec.build()
+
+        self.host = "localhost"
+        self.port = int(self.config.env_config.get("port", 5555)) + self.worker_index
+        self.server_socket = None
+        self.client_socket = None
+        self.address = None
+
+        self.metrics = MetricsLogger()
+
+        self._episode_chunks_to_return: Optional[List[SingleAgentEpisode]] = None
+        self._done_episodes_for_metrics: List[SingleAgentEpisode] = []
+        self._ongoing_episodes_for_metrics: DefaultDict[
+            EpisodeID, List[SingleAgentEpisode]
+        ] = defaultdict(list)
+
+        self._sample_lock = threading.Lock()
+        self._on_policy_lock = threading.Lock()
+        self._blocked_on_state = False
+
+        # Start a background thread for client communication.
+        self.thread = threading.Thread(
+            target=self._client_message_listener, daemon=True
+        )
+        self.thread.start()
+
+    @override(EnvRunner)
+    def assert_healthy(self):
+        """Checks that the server socket is open and listening."""
+        assert (
+            self.server_socket is not None
+        ), "Server socket is None (not connected, not listening)."
+
+    @override(EnvRunner)
+    def sample(self, **kwargs):
+        """Waits for the client to send episodes."""
+        while True:
+            with self._sample_lock:
+                if self._episode_chunks_to_return is not None:
+                    num_env_steps = 0
+                    num_episodes_completed = 0
+                    for eps in self._episode_chunks_to_return:
+                        if eps.is_done:
+                            self._done_episodes_for_metrics.append(eps)
+                            num_episodes_completed += 1
+                        else:
+                            self._ongoing_episodes_for_metrics[eps.id_].append(eps)
+                        num_env_steps += len(eps)
+
+                    ret = self._episode_chunks_to_return
+                    self._episode_chunks_to_return = None
+
+                    SingleAgentEnvRunner._increase_sampled_metrics(
+                        self, num_env_steps, num_episodes_completed
+                    )
+
+                    return ret
+            time.sleep(0.01)
+
+    @override(EnvRunner)
+    def get_metrics(self):
+        # TODO (sven): We should probably make this a utility function to be called
+        #  from within Single/MultiAgentEnvRunner and other EnvRunner subclasses, as
+        #  needed.
+        # Compute per-episode metrics (only on already completed episodes).
+        for eps in self._done_episodes_for_metrics:
+            assert eps.is_done
+            episode_length = len(eps)
+            episode_return = eps.get_return()
+            episode_duration_s = eps.get_duration_s()
+            # Don't forget about the already returned chunks of this episode.
+            if eps.id_ in self._ongoing_episodes_for_metrics:
+                for eps2 in self._ongoing_episodes_for_metrics[eps.id_]:
+                    episode_length += len(eps2)
+                    episode_return += eps2.get_return()
+                    episode_duration_s += eps2.get_duration_s()
+                del self._ongoing_episodes_for_metrics[eps.id_]
+
+            self._log_episode_metrics(
+                episode_length, episode_return, episode_duration_s
+            )
+
+        # Now that we have logged everything, clear cache of done episodes.
+        self._done_episodes_for_metrics.clear()
+
+        # Return reduced metrics.
+        return self.metrics.reduce()
+
+    def get_spaces(self):
+        return {
+            INPUT_ENV_SPACES: (self.config.observation_space, self.config.action_space),
+            DEFAULT_MODULE_ID: (
+                self.config.observation_space,
+                self.config.action_space,
+            ),
+        }
+
+    @override(EnvRunner)
+    def stop(self):
+        """Closes the client and server sockets."""
+        self._close_sockets_if_necessary()
+
+    @override(Checkpointable)
+    def get_ctor_args_and_kwargs(self):
+        return (
+            (),  # *args
+            {"config": self.config},  # **kwargs
+        )
+
+    @override(Checkpointable)
+    def get_checkpointable_components(self):
+        return [
+            (COMPONENT_RL_MODULE, self.module),
+        ]
+
+    @override(Checkpointable)
+    def get_state(
+        self,
+        components: Optional[Union[str, Collection[str]]] = None,
+        *,
+        not_components: Optional[Union[str, Collection[str]]] = None,
+        **kwargs,
+    ) -> StateDict:
+        return {
+            COMPONENT_RL_MODULE: self.module.get_state(),
+            WEIGHTS_SEQ_NO: self._weights_seq_no,
+        }
+
+    @override(Checkpointable)
+    def set_state(self, state: StateDict) -> None:
+        # Update the RLModule state.
+        if COMPONENT_RL_MODULE in state:
+            # A missing value for WEIGHTS_SEQ_NO or a value of 0 means: Force the
+            # update.
+            weights_seq_no = state.get(WEIGHTS_SEQ_NO, 0)
+
+            # Only update the weigths, if this is the first synchronization or
+            # if the weights of this `EnvRunner` lacks behind the actual ones.
+            if weights_seq_no == 0 or self._weights_seq_no < weights_seq_no:
+                rl_module_state = state[COMPONENT_RL_MODULE]
+                if (
+                    isinstance(rl_module_state, dict)
+                    and DEFAULT_MODULE_ID in rl_module_state
+                ):
+                    rl_module_state = rl_module_state[DEFAULT_MODULE_ID]
+                self.module.set_state(rl_module_state)
+
+            # Update our weights_seq_no, if the new one is > 0.
+            if weights_seq_no > 0:
+                self._weights_seq_no = weights_seq_no
+
+        if self._blocked_on_state is True:
+            self._send_set_state_message()
+            self._blocked_on_state = False
+
+    def _client_message_listener(self):
+        """Entry point for the listener thread."""
+
+        # Set up the server socket and bind to the specified host and port.
+        self._recycle_sockets()
+
+        # Enter an endless message receival- and processing loop.
+        while True:
+            # As long as we are blocked on a new state, sleep a bit and continue.
+            # Do NOT process any incoming messages (until we send out the new state
+            # back to the client).
+            if self._blocked_on_state is True:
+                time.sleep(0.01)
+                continue
+
+            try:
+                # Blocking call to get next message.
+                msg_type, msg_body = get_rllink_message(self.client_socket)
+
+                # Process the message received based on its type.
+                # Initial handshake.
+                if msg_type == RLlink.PING:
+                    self._send_pong_message()
+
+                # Episode data from the client.
+                elif msg_type in [
+                    RLlink.EPISODES,
+                    RLlink.EPISODES_AND_GET_STATE,
+                ]:
+                    self._process_episodes_message(msg_type, msg_body)
+
+                # Client requests the state (model weights).
+                elif msg_type == RLlink.GET_STATE:
+                    self._send_set_state_message()
+
+                # Clients requests config information.
+                elif msg_type == RLlink.GET_CONFIG:
+                    self._send_set_config_message()
+
+            except ConnectionError as e:
+                print(f"Messaging/connection error {e}! Recycling sockets ...")
+                self._recycle_sockets(5.0)
+                continue
+
+    def _recycle_sockets(self, sleep: float = 0.0):
+        # Close all old sockets, if they exist.
+        self._close_sockets_if_necessary()
+
+        time.sleep(sleep)
+
+        # Start listening on the configured port.
+        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        # Allow reuse of the address.
+        self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self.server_socket.bind((self.host, self.port))
+        # Listen for a single connection.
+        self.server_socket.listen(1)
+        print(f"Waiting for client to connect to port {self.port}...")
+
+        self.client_socket, self.address = self.server_socket.accept()
+        print(f"Connected to client at {self.address}")
+
+    def _close_sockets_if_necessary(self):
+        if self.client_socket:
+            self.client_socket.close()
+        if self.server_socket:
+            self.server_socket.close()
+
+    def _send_pong_message(self):
+        send_rllink_message(self.client_socket, {"type": RLlink.PONG.name})
+
+    def _process_episodes_message(self, msg_type, msg_body):
+        # On-policy training -> we have to block until we get a new `set_state` call
+        # (b/c the learning step is done and we can send new weights back to all
+        # clients).
+        if msg_type == RLlink.EPISODES_AND_GET_STATE:
+            self._blocked_on_state = True
+
+        episodes = []
+        for episode_state in msg_body["episodes"]:
+            episode = SingleAgentEpisode.from_state(episode_state)
+            episodes.append(episode.to_numpy())
+
+        # Push episodes into the to-be-returned list (for `sample()` requests).
+        with self._sample_lock:
+            if isinstance(self._episode_chunks_to_return, list):
+                self._episode_chunks_to_return.extend(episodes)
+            else:
+                self._episode_chunks_to_return = episodes
+
+    def _send_set_state_message(self):
+        send_rllink_message(
+            self.client_socket,
+            {
+                "type": RLlink.SET_STATE.name,
+                "state": self.get_state(inference_only=True),
+            },
+        )
+
+    def _send_set_config_message(self):
+        send_rllink_message(
+            self.client_socket,
+            {
+                "type": RLlink.SET_CONFIG.name,
+                # TODO (sven): We need AlgorithmConfig to be a `Checkpointable` with a
+                #  msgpack'able state.
+                "config": pickle.dumps(self.config),
+            },
+        )
+
+    def _log_episode_metrics(self, length, ret, sec):
+        # Log general episode metrics.
+        # To mimic the old API stack behavior, we'll use `window` here for
+        # these particular stats (instead of the default EMA).
+        win = self.config.metrics_num_episodes_for_smoothing
+        self.metrics.log_value(EPISODE_LEN_MEAN, length, window=win)
+        self.metrics.log_value(EPISODE_RETURN_MEAN, ret, window=win)
+        self.metrics.log_value(EPISODE_DURATION_SEC_MEAN, sec, window=win)
+        # Per-agent returns.
+        self.metrics.log_value(
+            ("agent_episode_returns_mean", DEFAULT_AGENT_ID), ret, window=win
+        )
+        # Per-RLModule returns.
+        self.metrics.log_value(
+            ("module_episode_returns_mean", DEFAULT_MODULE_ID), ret, window=win
+        )
+
+        # For some metrics, log min/max as well.
+        self.metrics.log_value(EPISODE_LEN_MIN, length, reduce="min", window=win)
+        self.metrics.log_value(EPISODE_RETURN_MIN, ret, reduce="min", window=win)
+        self.metrics.log_value(EPISODE_LEN_MAX, length, reduce="max", window=win)
+        self.metrics.log_value(EPISODE_RETURN_MAX, ret, reduce="max", window=win)

tool_server/.venv/lib/python3.12/site-packages/ray/rllib/env/external/rllink.py

@@ -0,0 +1,109 @@
+from enum import Enum
+from packaging.version import Version
+
+from ray.rllib.utils.checkpoints import try_import_msgpack
+from ray.util.annotations import DeveloperAPI
+
+
+msgpack = None
+
+
+@DeveloperAPI
+class RLlink(Enum):
+    PROTOCOL_VERSION = Version("0.0.1")
+
+    # Requests: Client (external env) -> Server (RLlib).
+    # ----
+    # Ping command (initial handshake).
+    PING = "PING"
+    # List of episodes (similar to what an EnvRunner.sample() call would return).
+    EPISODES = "EPISODES"
+    # Request state (e.g. model weights).
+    GET_STATE = "GET_STATE"
+    # Request Algorithm config.
+    GET_CONFIG = "GET_CONFIG"
+    # Send episodes and request the next state update right after that.
+    # Clients sending this message should wait for a SET_STATE message as an immediate
+    # response. Useful for external samplers that must collect on-policy data.
+    EPISODES_AND_GET_STATE = "EPISODES_AND_GET_STATE"
+
+    # Responses: Server (RLlib) -> Client (external env).
+    # ----
+    # Pong response (initial handshake).
+    PONG = "PONG"
+    # Set state (e.g. model weights).
+    SET_STATE = "SET_STATE"
+    # Set Algorithm  config.
+    SET_CONFIG = "SET_CONFIG"
+
+    # @OldAPIStack (to be deprecated soon).
+    ACTION_SPACE = "ACTION_SPACE"
+    OBSERVATION_SPACE = "OBSERVATION_SPACE"
+    GET_WORKER_ARGS = "GET_WORKER_ARGS"
+    GET_WEIGHTS = "GET_WEIGHTS"
+    REPORT_SAMPLES = "REPORT_SAMPLES"
+    START_EPISODE = "START_EPISODE"
+    GET_ACTION = "GET_ACTION"
+    LOG_ACTION = "LOG_ACTION"
+    LOG_RETURNS = "LOG_RETURNS"
+    END_EPISODE = "END_EPISODE"
+
+    def __str__(self):
+        return self.name
+
+
+@DeveloperAPI
+def send_rllink_message(sock_, message: dict):
+    """Sends a message to the client with a length header."""
+    global msgpack
+    if msgpack is None:
+        msgpack = try_import_msgpack(error=True)
+
+    body = msgpack.packb(message, use_bin_type=True)  # .encode("utf-8")
+    header = str(len(body)).zfill(8).encode("utf-8")
+    try:
+        sock_.sendall(header + body)
+    except Exception as e:
+        raise ConnectionError(
+            f"Error sending message {message} to server on socket {sock_}! "
+            f"Original error was: {e}"
+        )
+
+
+@DeveloperAPI
+def get_rllink_message(sock_):
+    """Receives a message from the client following the length-header protocol."""
+    global msgpack
+    if msgpack is None:
+        msgpack = try_import_msgpack(error=True)
+
+    try:
+        # Read the length header (8 bytes)
+        header = _get_num_bytes(sock_, 8)
+        msg_length = int(header.decode("utf-8"))
+        # Read the message body
+        body = _get_num_bytes(sock_, msg_length)
+        # Decode JSON.
+        message = msgpack.unpackb(body, raw=False)  # .loads(body.decode("utf-8"))
+        # Check for proper protocol.
+        if "type" not in message:
+            raise ConnectionError(
+                "Protocol Error! Message from peer does not contain `type` field."
+            )
+        return RLlink(message.pop("type")), message
+    except Exception as e:
+        raise ConnectionError(
+            f"Error receiving message from peer on socket {sock_}! "
+            f"Original error was: {e}"
+        )
+
+
+def _get_num_bytes(sock_, num_bytes):
+    """Helper function to receive a specific number of bytes."""
+    data = b""
+    while len(data) < num_bytes:
+        packet = sock_.recv(num_bytes - len(data))
+        if not packet:
+            raise ConnectionError(f"No data received from socket {sock_}!")
+        data += packet
+    return data

tool_server/.venv/lib/python3.12/site-packages/ray/rllib/env/utils/__init__.py

@@ -0,0 +1,124 @@
+import logging
+from typing import Type, Union
+
+import gymnasium as gym
+
+from ray.rllib.env.env_context import EnvContext
+from ray.rllib.utils.error import (
+    ERR_MSG_INVALID_ENV_DESCRIPTOR,
+    EnvError,
+)
+from ray.util.annotations import PublicAPI
+
+
+logger = logging.getLogger(__name__)
+
+
+@PublicAPI
+def try_import_pyspiel(error: bool = False):
+    """Tries importing pyspiel and returns the module (or None).
+
+    Args:
+        error: Whether to raise an error if pyspiel cannot be imported.
+
+    Returns:
+        The pyspiel module.
+
+    Raises:
+        ImportError: If error=True and pyspiel is not installed.
+    """
+    try:
+        import pyspiel
+
+        return pyspiel
+    except ImportError:
+        if error:
+            raise ImportError(
+                "Could not import pyspiel! Pygame is not a dependency of RLlib "
+                "and RLlib requires you to install pygame separately: "
+                "`pip install pygame`."
+            )
+        return None
+
+
+@PublicAPI
+def try_import_open_spiel(error: bool = False):
+    """Tries importing open_spiel and returns the module (or None).
+
+    Args:
+        error: Whether to raise an error if open_spiel cannot be imported.
+
+    Returns:
+        The open_spiel module.
+
+    Raises:
+        ImportError: If error=True and open_spiel is not installed.
+    """
+    try:
+        import open_spiel
+
+        return open_spiel
+    except ImportError:
+        if error:
+            raise ImportError(
+                "Could not import open_spiel! open_spiel is not a dependency of RLlib "
+                "and RLlib requires you to install open_spiel separately: "
+                "`pip install open_spiel`."
+            )
+        return None
+
+
+def _gym_env_creator(
+    env_context: EnvContext,
+    env_descriptor: Union[str, Type[gym.Env]],
+) -> gym.Env:
+    """Tries to create a gym env given an EnvContext object and descriptor.
+
+    Note: This function tries to construct the env from a string descriptor
+    only using possibly installed RL env packages (such as gym, pybullet_envs,
+    etc). These packages are no installation requirements for RLlib. In case
+    you would like to support more such env packages, add the necessary imports
+    and construction logic below.
+
+    Args:
+        env_context: The env context object to configure the env.
+            Note that this is a config dict, plus the properties:
+            `worker_index`, `vector_index`, and `remote`.
+        env_descriptor: The env descriptor as a gym-registered string, e.g. CartPole-v1,
+            ALE/MsPacman-v5, or CartPoleContinuousBulletEnv-v0.
+            Alternatively, the gym.Env subclass to use.
+
+    Returns:
+        The actual gym environment object.
+
+    Raises:
+        gym.error.Error: If the env cannot be constructed.
+    """
+    # Allow for PyBullet or envs to be used as well (via string). This allows
+    # for doing things like `env=CartPoleContinuousBulletEnv-v0`.
+    try:
+        import pybullet_envs
+
+        pybullet_envs.getList()
+    except (AttributeError, ModuleNotFoundError, ImportError):
+        pass
+
+    # If env descriptor is a str, starting with "ale_py:ALE/", for now, register all ALE
+    # envs from ale_py.
+    if isinstance(env_descriptor, str) and env_descriptor.startswith("ale_py:ALE/"):
+        import ale_py
+
+        gym.register_envs(ale_py)
+
+    # Try creating a gym env. If this fails we can output a
+    # decent error message.
+    try:
+        # If class provided, call constructor directly.
+        if isinstance(env_descriptor, type):
+            env = env_descriptor(env_context)
+        else:
+            env = gym.make(env_descriptor, **env_context)
+    except gym.error.Error:
+        raise EnvError(ERR_MSG_INVALID_ENV_DESCRIPTOR.format(env_descriptor))
+
+    return env

tool_server/.venv/lib/python3.12/site-packages/ray/rllib/env/utils/external_env_protocol.py

@@ -0,0 +1,8 @@
+from ray.rllib.env.external.rllink import RLlink  # noqa
+from ray.rllib.utils.deprecation import deprecation_warning
+
+deprecation_warning(
+    old="ray.rllib.env.utils.external_env_protocol",
+    new="ray.rllib.env.external.rllink",
+    error=False,
+)

tool_server/.venv/lib/python3.12/site-packages/ray/rllib/env/utils/infinite_lookback_buffer.py

@@ -0,0 +1,721 @@
+from typing import Any, Dict, List, Optional, Union
+
+import gymnasium as gym
+import numpy as np
+import tree  # pip install dm_tree
+
+from ray.rllib.utils.numpy import LARGE_INTEGER, one_hot, one_hot_multidiscrete
+from ray.rllib.utils.serialization import gym_space_from_dict, gym_space_to_dict
+from ray.rllib.utils.spaces.space_utils import (
+    batch,
+    from_jsonable_if_needed,
+    get_dummy_batch_for_space,
+    get_base_struct_from_space,
+    to_jsonable_if_needed,
+)
+from ray.util.annotations import DeveloperAPI
+
+
+@DeveloperAPI
+class InfiniteLookbackBuffer:
+    @property
+    def space(self):
+        return self._space
+
+    @space.setter
+    def space(self, value):
+        self._space = value
+        self.space_struct = get_base_struct_from_space(value)
+
+    def __init__(
+        self,
+        data: Optional[Union[List, np.ndarray]] = None,
+        lookback: int = 0,
+        space: Optional[gym.Space] = None,
+    ):
+        self.data = data if data is not None else []
+        self.lookback = min(lookback, len(self.data))
+        self.finalized = not isinstance(self.data, list)
+        self.space_struct = None
+        self.space = space
+
+    def __eq__(
+        self,
+        other: "InfiniteLookbackBuffer",
+    ) -> bool:
+        """Compares two `InfiniteLookbackBuffers.
+
+        Args:
+            other: Another object. If another `LookbackBuffer` instance all
+                their attributes are compared.
+
+        Returns:
+            `True`, if `other` is an `InfiniteLookbackBuffer` instance and all
+            attributes are identical. Otherwise, returns `False`.
+        """
+        if isinstance(other, InfiniteLookbackBuffer):
+            if (
+                self.data == other.data
+                and self.lookback == other.lookback
+                and self.finalized == other.finalized
+                and self.space_struct == other.space_struct
+                and self.space == other.space
+            ):
+                return True
+        return False
+
+    def get_state(self) -> Dict[str, Any]:
+        """Returns the pickable state of a buffer.
+
+        The data in the buffer is stored into a dictionary. Note that
+        buffers can also be generated from pickable states (see
+        `InfiniteLookbackBuffer.from_state`)
+
+        Returns:
+            A dict containing all the data and metadata from the buffer.
+        """
+        return {
+            "data": to_jsonable_if_needed(self.data, self.space)
+            if self.space
+            else self.data,
+            "lookback": self.lookback,
+            "finalized": self.finalized,
+            "space": gym_space_to_dict(self.space) if self.space else self.space,
+        }
+
+    @staticmethod
+    def from_state(state: Dict[str, Any]) -> None:
+        """Creates a new `InfiniteLookbackBuffer` from a state dict.
+
+        Args:
+            state: The state dict, as returned by `self.get_state`.
+
+        Returns:
+            A new `InfiniteLookbackBuffer` instance with the data and metadata
+            from the state dict.
+        """
+        buffer = InfiniteLookbackBuffer()
+        buffer.lookback = state["lookback"]
+        buffer.finalized = state["finalized"]
+        buffer.space = gym_space_from_dict(state["space"]) if state["space"] else None
+        buffer.space_struct = (
+            get_base_struct_from_space(buffer.space) if buffer.space else None
+        )
+        buffer.data = (
+            from_jsonable_if_needed(state["data"], buffer.space)
+            if buffer.space
+            else state["data"]
+        )
+
+        return buffer
+
+    def append(self, item) -> None:
+        """Appends the given item to the end of this buffer."""
+        if self.finalized:
+            self.data = tree.map_structure(
+                lambda d, i: np.concatenate([d, [i]], axis=0), self.data, item
+            )
+        else:
+            self.data.append(item)
+
+    def extend(self, items) -> None:
+        """Appends all items in `items` to the end of this buffer."""
+        if self.finalized:
+            # TODO (sven): When extending with a list of structs, we should
+            #  probably rather do: `tree.map_structure(..., self.data,
+            #  tree.map_structure(lambda *s: np.array(*s), *items)`)??
+            self.data = tree.map_structure(
+                lambda d, i: np.concatenate([d, i], axis=0),
+                self.data,
+                # Note, we could have dictionaries here.
+                np.array(items) if isinstance(items, list) else items,
+            )
+        else:
+            for item in items:
+                self.append(item)
+
+    def concat(self, other: "InfiniteLookbackBuffer") -> None:
+        """Concatenates the data of `other` (w/o its lookback) to `self`.
+
+        Args:
+            other: The other InfiniteLookbackBuffer to be concatenated to self.
+        """
+        self.data.extend(other.get())
+
+    def pop(self, index: int = -1) -> None:
+        """Removes the item at `index` from this buffer, but does NOT return it.
+
+        Args:
+            index: The index to pop out of this buffer (w/o returning it from this
+                method).
+        """
+        if self.finalized:
+            self.data = tree.map_structure(
+                lambda s: np.delete(s, index, axis=0), self.data
+            )
+        else:
+            self.data.pop(index)
+
+    def finalize(self) -> None:
+        """Finalizes this buffer by converting internal data lists into numpy arrays.
+
+        Thereby, if the individual items in the list are nested structures, the
+        resulting buffer content will be a nested struct of np.ndarrays (leafs).
+        """
+        if not self.finalized:
+            self.data = batch(self.data)
+            self.finalized = True
+
+    def get(
+        self,
+        indices: Optional[Union[int, slice, List[int]]] = None,
+        *,
+        neg_index_as_lookback: bool = False,
+        fill: Optional[Any] = None,
+        one_hot_discrete: bool = False,
+        _ignore_last_ts: bool = False,
+        _add_last_ts_value: Optional[Any] = None,
+    ) -> Any:
+        """Returns data, based on the given args, from this buffer.
+
+        Args:
+            indices: A single int is interpreted as an index, from which to return the
+                individual data stored at this index.
+                A list of ints is interpreted as a list of indices from which to gather
+                individual data in a batch of size len(indices).
+                A slice object is interpreted as a range of data to be returned.
+                Thereby, negative indices by default are interpreted as "before the end"
+                unless the `neg_index_as_lookback=True` option is used, in which case
+                negative indices are interpreted as "before ts=0", meaning going back
+                into the lookback buffer.
+            neg_index_as_lookback: If True, negative values in `indices` are
+                interpreted as "before ts=0", meaning going back into the lookback
+                buffer. For example, a buffer with data [4, 5, 6,  7, 8, 9],
+                where [4, 5, 6] is the lookback buffer range (ts=0 item is 7), will
+                respond to `get(-1, neg_index_as_lookback=True)` with `6` and to
+                `get(slice(-2, 1), neg_index_as_lookback=True)` with `[5, 6,  7]`.
+            fill: An optional float value to use for filling up the returned results at
+                the boundaries. This filling only happens if the requested index range's
+                start/stop boundaries exceed the buffer's boundaries (including the
+                lookback buffer on the left side). This comes in very handy, if users
+                don't want to worry about reaching such boundaries and want to zero-pad.
+                For example, a buffer with data [10, 11,  12, 13, 14] and lookback
+                buffer size of 2 (meaning `10` and `11` are part of the lookback buffer)
+                will respond to `get(slice(-7, -2), fill=0.0)`
+                with `[0.0, 0.0, 10, 11, 12]`.
+            one_hot_discrete: If True, will return one-hot vectors (instead of
+                int-values) for those sub-components of a (possibly complex) space
+                that are Discrete or MultiDiscrete. Note that if `fill=0` and the
+                requested `indices` are out of the range of our data, the returned
+                one-hot vectors will actually be zero-hot (all slots zero).
+            _ignore_last_ts: Whether to ignore the last record in our internal
+                `self.data` when getting the provided indices.
+            _add_last_ts_value: Whether to add the value of this arg to the end of
+                the internal `self.data` buffer (just for the duration of this get
+                operation, not permanently).
+        """
+        if indices is None:
+            data = self._get_all_data(
+                one_hot_discrete=one_hot_discrete,
+                _ignore_last_ts=_ignore_last_ts,
+            )
+        elif isinstance(indices, slice):
+            data = self._get_slice(
+                indices,
+                fill=fill,
+                neg_index_as_lookback=neg_index_as_lookback,
+                one_hot_discrete=one_hot_discrete,
+                _ignore_last_ts=_ignore_last_ts,
+                _add_last_ts_value=_add_last_ts_value,
+            )
+        elif isinstance(indices, list):
+            data = [
+                self._get_int_index(
+                    idx,
+                    fill=fill,
+                    neg_index_as_lookback=neg_index_as_lookback,
+                    one_hot_discrete=one_hot_discrete,
+                    _ignore_last_ts=_ignore_last_ts,
+                    _add_last_ts_value=_add_last_ts_value,
+                )
+                for idx in indices
+            ]
+            if self.finalized:
+                data = batch(data)
+        else:
+            assert isinstance(indices, int)
+            data = self._get_int_index(
+                indices,
+                fill=fill,
+                neg_index_as_lookback=neg_index_as_lookback,
+                one_hot_discrete=one_hot_discrete,
+                _ignore_last_ts=_ignore_last_ts,
+                _add_last_ts_value=_add_last_ts_value,
+            )
+
+        return data
+
+    def __add__(
+        self, other: Union[List, "InfiniteLookbackBuffer", int, float, complex]
+    ) -> "InfiniteLookbackBuffer":
+        """Adds another InfiniteLookbackBuffer object or list to the end of this one.
+
+        Args:
+            other: Another `InfiniteLookbackBuffer` or a `list` or a number.
+                If a `InfiniteLookbackBuffer` its data (w/o its lookback buffer) gets
+                concatenated to self's data. If a `list`, we concat it to self's data.
+                If a number, we add this number to each element of self (if possible).
+
+        Returns:
+            A new `InfiniteLookbackBuffer` instance `self.data` containing
+            concatenated data from `self` and `other` (or adding `other` to each element
+            in self's data).
+        """
+
+        if self.finalized:
+            raise RuntimeError(f"Cannot `add` to a finalized {type(self).__name__}.")
+        else:
+            # If `other` is an int, simply add it to all our values (if possible) and
+            # use the result as the underlying data for the returned buffer.
+            if isinstance(other, (int, float, complex)):
+                data = [
+                    (d + other) if isinstance(d, (int, float, complex)) else d
+                    for d in self.data
+                ]
+            # If `other` is a InfiniteLookbackBuffer itself, do NOT include its
+            # lookback buffer anymore. We assume that `other`'s lookback buffer i
+            # already at the end of `self`.
+            elif isinstance(other, InfiniteLookbackBuffer):
+                data = self.data + other.data[other.lookback :]
+            # `other` is a list, simply concat the two lists and use the result as
+            # the underlying data for the returned buffer.
+            else:
+                data = self.data + other
+
+            return InfiniteLookbackBuffer(
+                data=data,
+                lookback=self.lookback,
+                space=self.space,
+            )
+
+    def __getitem__(self, item):
+        """Support squared bracket syntax, e.g. buffer[:5]."""
+        return self.get(item)
+
+    def __setitem__(self, key, value):
+        self.set(new_data=value, at_indices=key)
+
+    def set(
+        self,
+        new_data,
+        *,
+        at_indices: Optional[Union[int, slice, List[int]]] = None,
+        neg_index_as_lookback: bool = False,
+    ) -> None:
+        """Overwrites all or some of the data in this buffer with the provided data.
+
+        Args:
+            new_data: The new data to overwrite existing records with.
+            at_indices: A single int is interpreted as an index, at which to overwrite
+                the individual record stored at this index with `new_data`.
+                A list of ints is interpreted as a list of indices, which to overwrite
+                with `new_data`, which must be a batch of size `len(at_indices)`.
+                A slice object is interpreted as a range, which to overwrite with
+                `new_data`. Thereby, negative indices by default are interpreted as
+                "before the end" unless the `neg_index_as_lookback=True` option is
+                used, in which case negative indices are interpreted as
+                "before ts=0", meaning going back into the lookback buffer.
+            neg_index_as_lookback: If True, negative values in `at_indices` are
+                interpreted as "before ts=0", meaning going back into the lookback
+                buffer. For example, a buffer with data [4, 5, 6,  7, 8, 9],
+                where [4, 5, 6] is the lookback buffer range (ts=0 item is 7), will
+                handle a call `set(99, at_indices=-1, neg_index_as_lookback=True)`
+                with `6` being replaced by 99 and to `set([98, 99, 100],
+                at_indices=slice(-2, 1), neg_index_as_lookback=True)` with
+                `[5, 6,  7]` being replaced by `[98, 99,  100]`.
+        """
+        # `at_indices` is None -> Override all our data (excluding the lookback buffer).
+        if at_indices is None:
+            self._set_all_data(new_data)
+
+        elif isinstance(at_indices, slice):
+            self._set_slice(
+                new_data,
+                slice_=at_indices,
+                neg_index_as_lookback=neg_index_as_lookback,
+            )
+        elif isinstance(at_indices, list):
+            for i, idx in enumerate(at_indices):
+                self._set_int_index(
+                    new_data[i],
+                    idx=idx,
+                    neg_index_as_lookback=neg_index_as_lookback,
+                )
+        else:
+            assert isinstance(at_indices, int)
+            self._set_int_index(
+                new_data,
+                idx=at_indices,
+                neg_index_as_lookback=neg_index_as_lookback,
+            )
+
+    def __len__(self):
+        """Return the length of our data, excluding the lookback buffer."""
+        len_ = self.len_incl_lookback()
+        # Only count the data after the lookback.
+        return max(len_ - self.lookback, 0)
+
+    def len_incl_lookback(self):
+        if self.finalized:
+            return len(tree.flatten(self.data)[0])
+        else:
+            return len(self.data)
+
+    def __repr__(self):
+        return (
+            f"{type(self).__name__}({self.data[:self.lookback]} <- "
+            f"lookback({self.lookback}) | {self.data[self.lookback:]})"
+        )
+
+    def _get_all_data(self, one_hot_discrete=False, _ignore_last_ts=False):
+        data = self[: (None if not _ignore_last_ts else -1)]
+        if one_hot_discrete:
+            data = self._one_hot(data, space_struct=self.space_struct)
+        return data
+
+    def _set_all_data(self, new_data):
+        self._set_slice(new_data, slice(0, None))
+
+    def _get_slice(
+        self,
+        slice_,
+        fill=None,
+        neg_index_as_lookback=False,
+        one_hot_discrete=False,
+        _ignore_last_ts=False,
+        _add_last_ts_value=None,
+    ):
+        data_to_use = self.data
+        if _ignore_last_ts:
+            if self.finalized:
+                data_to_use = tree.map_structure(lambda s: s[:-1], self.data)
+            else:
+                data_to_use = self.data[:-1]
+        if _add_last_ts_value is not None:
+            if self.finalized:
+                data_to_use = tree.map_structure(
+                    lambda s, t: np.append(s, t),
+                    data_to_use.copy(),
+                    _add_last_ts_value,
+                )
+            else:
+                data_to_use = np.append(data_to_use.copy(), _add_last_ts_value)
+
+        slice_, slice_len, fill_left_count, fill_right_count = self._interpret_slice(
+            slice_,
+            neg_index_as_lookback,
+            len_self_plus_lookback=(
+                self.len_incl_lookback()
+                + int(_add_last_ts_value is not None)
+                - int(_ignore_last_ts)
+            ),
+        )
+
+        # Perform the actual slice.
+        data_slice = None
+        if slice_len > 0:
+            if self.finalized:
+                data_slice = tree.map_structure(lambda s: s[slice_], data_to_use)
+            else:
+                data_slice = data_to_use[slice_]
+
+            if one_hot_discrete:
+                data_slice = self._one_hot(data_slice, space_struct=self.space_struct)
+
+        # Data is shorter than the range requested -> Fill the rest with `fill` data.
+        if fill is not None and (fill_right_count > 0 or fill_left_count > 0):
+            if self.finalized:
+                if fill_left_count:
+                    if self.space is None:
+                        fill_batch = np.array([fill] * fill_left_count)
+                    else:
+                        fill_batch = get_dummy_batch_for_space(
+                            self.space,
+                            fill_value=fill,
+                            batch_size=fill_left_count,
+                            one_hot_discrete=one_hot_discrete,
+                        )
+                    if data_slice is not None:
+                        data_slice = tree.map_structure(
+                            lambda s0, s: np.concatenate([s0, s]),
+                            fill_batch,
+                            data_slice,
+                        )
+                    else:
+                        data_slice = fill_batch
+                if fill_right_count:
+                    if self.space is None:
+                        fill_batch = np.array([fill] * fill_right_count)
+                    else:
+                        fill_batch = get_dummy_batch_for_space(
+                            self.space,
+                            fill_value=fill,
+                            batch_size=fill_right_count,
+                            one_hot_discrete=one_hot_discrete,
+                        )
+                    if data_slice is not None:
+                        data_slice = tree.map_structure(
+                            lambda s0, s: np.concatenate([s, s0]),
+                            fill_batch,
+                            data_slice,
+                        )
+                    else:
+                        data_slice = fill_batch
+
+            else:
+                if self.space is None:
+                    fill_batch = [fill]
+                else:
+                    fill_batch = [
+                        get_dummy_batch_for_space(
+                            self.space,
+                            fill_value=fill,
+                            batch_size=0,
+                            one_hot_discrete=one_hot_discrete,
+                        )
+                    ]
+                data_slice = (
+                    fill_batch * fill_left_count
+                    + (data_slice if data_slice is not None else [])
+                    + fill_batch * fill_right_count
+                )
+
+        if data_slice is None:
+            if self.finalized:
+                return tree.map_structure(lambda s: s[slice_], data_to_use)
+            else:
+                return data_to_use[slice_]
+        return data_slice
+
+    def _set_slice(
+        self,
+        new_data,
+        slice_,
+        neg_index_as_lookback=False,
+    ):
+        slice_, _, _, _ = self._interpret_slice(slice_, neg_index_as_lookback)
+
+        # Check, whether the setting to new_data changes the length of self
+        # (it shouldn't). If it does, raise an error.
+        try:
+            if self.finalized:
+
+                def __set(s, n):
+                    if self.space:
+                        assert self.space.contains(n[0])
+                    assert len(s[slice_]) == len(n)
+                    s[slice_] = n
+
+                tree.map_structure(__set, self.data, new_data)
+            else:
+                assert len(self.data[slice_]) == len(new_data)
+                self.data[slice_] = new_data
+        except AssertionError:
+            raise IndexError(
+                f"Cannot `set()` value via at_indices={slice_} (option "
+                f"neg_index_as_lookback={neg_index_as_lookback})! Slice of data "
+                "does NOT have the same size as `new_data`."
+            )
+
+    def _get_int_index(
+        self,
+        idx: int,
+        fill=None,
+        neg_index_as_lookback=False,
+        one_hot_discrete=False,
+        _ignore_last_ts=False,
+        _add_last_ts_value=None,
+    ):
+        data_to_use = self.data
+        if _ignore_last_ts:
+            if self.finalized:
+                data_to_use = tree.map_structure(lambda s: s[:-1], self.data)
+            else:
+                data_to_use = self.data[:-1]
+        if _add_last_ts_value is not None:
+            if self.finalized:
+                data_to_use = tree.map_structure(
+                    lambda s, last: np.append(s, last), data_to_use, _add_last_ts_value
+                )
+            else:
+                data_to_use = data_to_use.copy()
+                data_to_use.append(_add_last_ts_value)
+
+        # If index >= 0 -> Ignore lookback buffer.
+        # Otherwise, include lookback buffer.
+        if idx >= 0 or neg_index_as_lookback:
+            idx = self.lookback + idx
+        # Negative indices mean: Go to left into lookback buffer starting from idx=0.
+        # But if we pass the lookback buffer, the index should be invalid and we will
+        # have to fill, if required. Invalidate the index by setting it to one larger
+        # than max.
+        if neg_index_as_lookback and idx < 0:
+            idx = len(self) + self.lookback - (_ignore_last_ts is True)
+
+        try:
+            if self.finalized:
+                data = tree.map_structure(lambda s: s[idx], data_to_use)
+            else:
+                data = data_to_use[idx]
+        # Out of range index -> If `fill`, use a fill dummy (B=0), if not, error out.
+        except IndexError as e:
+            if fill is not None:
+                if self.space is None:
+                    return fill
+                return get_dummy_batch_for_space(
+                    self.space,
+                    fill_value=fill,
+                    batch_size=0,
+                    one_hot_discrete=one_hot_discrete,
+                )
+            else:
+                raise e
+
+        # Convert discrete/multi-discrete components to one-hot vectors, if required.
+        if one_hot_discrete:
+            data = self._one_hot(data, self.space_struct)
+        return data
+
+    def _set_int_index(self, new_data, idx, neg_index_as_lookback):
+        actual_idx = idx
+        # If index >= 0 -> Ignore lookback buffer.
+        # Otherwise, include lookback buffer.
+        if actual_idx >= 0 or neg_index_as_lookback:
+            actual_idx = self.lookback + actual_idx
+        # Negative indices mean: Go to left into lookback buffer starting from idx=0.
+        # But if we pass the lookback buffer, the index should be invalid and we will
+        # have to fill, if required. Invalidate the index by setting it to one larger
+        # than max.
+        if neg_index_as_lookback and actual_idx < 0:
+            actual_idx = len(self) + self.lookback
+
+        try:
+            if self.finalized:
+
+                def __set(s, n):
+                    if self.space:
+                        assert self.space.contains(n), n
+                    s[actual_idx] = n
+
+                tree.map_structure(__set, self.data, new_data)
+            else:
+                self.data[actual_idx] = new_data
+        except IndexError:
+            raise IndexError(
+                f"Cannot `set()` value at index {idx} (option "
+                f"neg_index_as_lookback={neg_index_as_lookback})! Out of range "
+                f"of buffer data."
+            )
+
+    def _interpret_slice(
+        self,
+        slice_,
+        neg_index_as_lookback,
+        len_self_plus_lookback=None,
+    ):
+        if len_self_plus_lookback is None:
+            len_self_plus_lookback = len(self) + self.lookback
+
+        # Re-interpret slice bounds as absolute positions (>=0) within our
+        # internal data.
+        start = slice_.start
+        stop = slice_.stop
+
+        # Start is None -> Exclude lookback buffer.
+        if start is None:
+            start = self.lookback
+        # Start is negative.
+        elif start < 0:
+            # `neg_index_as_lookback=True` -> User wants to index into the lookback
+            # range.
+            if neg_index_as_lookback:
+                start = self.lookback + start
+            # Interpret index as counting "from end".
+            else:
+                start = len_self_plus_lookback + start
+        # Start is 0 or positive -> timestep right after lookback is interpreted as 0.
+        else:
+            start = self.lookback + start
+
+        # Stop is None -> Set stop to very last index + 1 of our internal data.
+        if stop is None:
+            stop = len_self_plus_lookback
+        # Stop is negative.
+        elif stop < 0:
+            # `neg_index_as_lookback=True` -> User wants to index into the lookback
+            # range. Set to 0 (beginning of lookback buffer) if result is a negative
+            # index.
+            if neg_index_as_lookback:
+                stop = self.lookback + stop
+            # Interpret index as counting "from end". Set to 0 (beginning of actual
+            # episode) if result is a negative index.
+            else:
+                stop = len_self_plus_lookback + stop
+        # Stop is positive -> Add lookback range to it.
+        else:
+            stop = self.lookback + stop
+
+        fill_left_count = fill_right_count = 0
+        # Both start and stop are on left side.
+        if start < 0 and stop < 0:
+            fill_left_count = abs(start - stop)
+            fill_right_count = 0
+            start = stop = 0
+        # Both start and stop are on right side.
+        elif start >= len_self_plus_lookback and stop >= len_self_plus_lookback:
+            fill_right_count = abs(start - stop)
+            fill_left_count = 0
+            start = stop = len_self_plus_lookback
+        # Set to 0 (beginning of actual episode) if result is a negative index.
+        elif start < 0:
+            fill_left_count = -start
+            start = 0
+        elif stop >= len_self_plus_lookback:
+            fill_right_count = stop - len_self_plus_lookback
+            stop = len_self_plus_lookback
+        # Only `stop` might be < 0, when slice has negative step and start is > 0.
+        elif stop < 0:
+            if start >= len_self_plus_lookback:
+                fill_left_count = start - len_self_plus_lookback + 1
+                start = len_self_plus_lookback - 1
+            fill_right_count = -stop - 1
+            stop = -LARGE_INTEGER
+
+        assert start >= 0 and (stop >= 0 or stop == -LARGE_INTEGER), (start, stop)
+
+        step = slice_.step if slice_.step is not None else 1
+        slice_ = slice(start, stop, step)
+        slice_len = max(0, (stop - start + (step - (1 if step > 0 else -1))) // step)
+        return slice_, slice_len, fill_left_count, fill_right_count
+
+    def _one_hot(self, data, space_struct):
+        if space_struct is None:
+            raise ValueError(
+                f"Cannot `one_hot` data in `{type(self).__name__}` if a "
+                "gym.Space was NOT provided during construction!"
+            )
+
+        def _convert(dat_, space):
+            if isinstance(space, gym.spaces.Discrete):
+                return one_hot(dat_, depth=space.n)
+            elif isinstance(space, gym.spaces.MultiDiscrete):
+                return one_hot_multidiscrete(dat_, depths=space.nvec)
+            return dat_
+
+        if isinstance(data, list):
+            data = [
+                tree.map_structure(_convert, dslice, space_struct) for dslice in data
+            ]
+        else:
+            data = tree.map_structure(_convert, data, space_struct)
+        return data

tool_server/.venv/lib/python3.12/site-packages/ray/rllib/env/vector/registration.py

@@ -0,0 +1,91 @@
+import copy
+import gymnasium as gym
+import logging
+
+from gymnasium.envs.registration import VectorizeMode
+from typing import Any, Dict, Optional
+
+from ray.rllib.env.multi_agent_env import MultiAgentEnv
+from ray.rllib.env.vector.sync_vector_multi_agent_env import SyncVectorMultiAgentEnv
+from ray.rllib.env.vector.vector_multi_agent_env import VectorMultiAgentEnv
+
+logger = logging.getLogger(__file__)
+
+
+def make_vec(
+    id: str,
+    num_envs: int = 1,
+    vectorization_mode: Optional[VectorizeMode] = None,
+    vector_kwargs: Optional[Dict[str, Any]] = None,
+    # TODO (simon): Add wrappers?
+    **kwargs,
+) -> VectorMultiAgentEnv:
+
+    if vector_kwargs is None:
+        vector_kwargs = {}
+
+    if vectorization_mode is None:
+        vectorization_mode = "sync"
+
+    # Create an `gymnasium.envs.registration.EnvSpec` to properly
+    # initialize the sub-environments.
+    if isinstance(id, gym.envs.registration.EnvSpec):
+        env_spec = id
+    elif isinstance(id, str):
+        env_spec = gym.envs.registration._find_spec(id)
+    else:
+        raise ValueError(f"Invalid id type: {type(id)}. Expected `str` or `EnvSpec`.")
+
+    env_spec = copy.deepcopy(env_spec)
+    env_spec_kwargs = env_spec.kwargs
+    env_spec.kwargs = dict()
+
+    num_envs = env_spec.kwargs.get("num_envs", num_envs)
+    vectorization_mode = env_spec_kwargs.pop("vectorization_mode", vectorization_mode)
+    vector_kwargs = env_spec_kwargs.pop("vector_kwargs", vector_kwargs)
+    env_spec_kwargs.update(kwargs)
+
+    # Specify the vectorization mode.
+    if vectorization_mode is None:
+        vectorization_mode = VectorizeMode.SYNC
+    else:
+        try:
+            vectorization_mode = VectorizeMode(vectorization_mode)
+        except ValueError:
+            raise ValueError(
+                f"Invalid vectorization mode: {vectorization_mode!r}, "
+                f"valid modes: {[mode.value for mode in VectorizeMode]}."
+            )
+    assert isinstance(vectorization_mode, VectorizeMode)
+
+    def create_single_env() -> MultiAgentEnv:
+        single_env = gym.make(env_spec, **env_spec_kwargs.copy())
+
+        return single_env
+
+    # Check, the vectorization mode.
+    if vectorization_mode == VectorizeMode.SYNC:
+        # Create the synchronized vector environemnt.
+        env = SyncVectorMultiAgentEnv(
+            env_fns=(create_single_env for _ in range(num_envs)),
+            **vector_kwargs,
+        )
+    # Other modes are not implemented, yet.
+    else:
+        raise ValueError(
+            "For `MultiAgentEnv` only synchronous environment vectorization "
+            "is implemented. Use `gym_env_vectorize_mode='sync'`."
+        )
+
+    # Add all creation specifications to the environment.
+    copied_id_spec = copy.deepcopy(env_spec)
+    copied_id_spec.kwargs = env_spec_kwargs.copy()
+    if num_envs != 1:
+        copied_id_spec.kwargs["num_envs"] = num_envs
+    copied_id_spec.kwargs["vectorization_mode"] = vectorization_mode.value
+    if len(vector_kwargs) > 0:
+        copied_id_spec.kwargs["vector_kwargs"] = vector_kwargs
+    env.unwrapped.spec = copied_id_spec
+
+    # Return the `VectorMultiAgentEnv`.
+    return env

tool_server/.venv/lib/python3.12/site-packages/ray/rllib/env/vector/sync_vector_multi_agent_env.py

@@ -0,0 +1,215 @@
+import gymnasium as gym
+import numpy as np
+
+from copy import deepcopy
+from gymnasium.core import ActType, RenderFrame
+from typing import Any, Callable, Dict, Iterator, List, Optional, Sequence, Tuple, Union
+
+from ray.rllib.env.multi_agent_env import MultiAgentEnv
+from ray.rllib.env.vector.vector_multi_agent_env import ArrayType, VectorMultiAgentEnv
+from ray.rllib.utils.typing import AgentID
+
+
+class SyncVectorMultiAgentEnv(VectorMultiAgentEnv):
+    def __init__(
+        self,
+        env_fns: Union[
+            Iterator[Callable[[], MultiAgentEnv]], Sequence[Callable[[], MultiAgentEnv]]
+        ],
+        copy: bool = True,
+        autoreset_mode: str = "next_step",
+    ):
+        super().__init__()
+
+        self.env_fns = env_fns
+        self.copy = copy
+        self.autoreset_mode = autoreset_mode
+
+        # Initialize all sub-environments.
+        self.envs = [env_fn() for env_fn in self.env_fns]
+
+        self.num_envs = len(self.envs)
+        self.metadata = self.envs[0].metadata
+        self.metadata["autoreset_mode"] = self.autoreset_mode
+        self.render_mode = self.envs[0].render_mode
+
+        if self.envs[0].unwrapped.observation_spaces is not None:
+            self.single_observation_spaces = self.envs[0].unwrapped.observation_spaces
+        elif self.envs[0].unwrapped.observation_space is not None:
+            self.single_observation_spaces = dict(
+                self.envs[0].unwrapped.observation_space
+            )
+        else:
+            self.single_observation_spaces = {
+                aid: self.envs[0].unwrapped.get_observation_space(aid)
+                for aid in self.envs[0].unwrapped.possible_agents
+            }
+        self.single_observation_space = gym.spaces.Dict(self.single_observation_spaces)
+
+        if self.envs[0].unwrapped.action_spaces is not None:
+            self.single_action_spaces = self.envs[0].unwrapped.action_spaces
+        elif self.envs[0].unwrapped.action_space is not None:
+            self.single_action_spaces = dict(self.envs[0].unwrapped.action_space)
+        else:
+            self.single_action_spaces = {
+                aid: self.envs[0].unwrapped.get_action_space(aid)
+                for aid in self.envs[0].unwrapped.possible_agents
+            }
+        self.single_action_space = gym.spaces.Dict(self.single_action_spaces)
+
+        # TODO (simon): Decide if we want to include a spaces check here.
+
+        # Note, if `single_observation_spaces` are not defined, this will
+        # raise an error.
+        self._observations = self.create_empty_array(
+            self.single_observation_spaces,
+            n=self.num_envs,
+        )
+        self._rewards = [{} for _ in range(self.num_envs)]
+        self._terminations = [{} for _ in range(self.num_envs)]
+        self._truncations = [{} for _ in range(self.num_envs)]
+        self._infos = [{} for _ in range(self.num_envs)]
+
+    def reset(
+        self, *, seed: Optional[int] = None, options: Optional[Dict[str, Any]] = None
+    ) -> Tuple[ArrayType, ArrayType]:
+
+        # Check the `seed`.
+        if seed is None:
+            seed = [None for _ in range(self.num_envs)]
+        elif isinstance(seed, int):
+            seed = [seed + i for i in range(self.num_envs)]
+        # If `seed` is a sequence, check if length is correct.
+        else:
+            assert len(seed) == self.num_envs, (
+                f"If seeds are passed as a list the length must match num_envs={self.num_envs} "
+                f"but got length={len(seed)}.",
+            )
+
+        # Set auto-reset to `False` for all sub-environments. This will be
+        # set to `True` during `VectorMultiAgentEnv.step`.
+        self._autoreset_envs = np.zeros((self.num_envs,), dtype=np.bool_)
+
+        # Force reset on all sub-environments.
+        for i, (env, single_seed) in enumerate(zip(self.envs, seed)):
+            self._observations[i], self._infos[i] = env.reset(
+                seed=single_seed, options=options
+            )
+
+        return (
+            deepcopy(self._observations) if self.copy else self._observations,
+            self._infos,
+        )
+
+    def step(
+        self, actions: List[Dict[AgentID, ActType]]
+    ) -> Tuple[ArrayType, ArrayType, ArrayType, ArrayType, ArrayType]:
+
+        for i, action in enumerate(actions):
+            # Note, this will be a feature coming in `gymnasium`s next release.
+            if self.autoreset_mode == "next_step":
+                # Auto-reset environments that terminated or truncated.
+                if self._autoreset_envs[i]:
+                    self._observations[i], self._infos[i] = self.envs[i].reset()
+
+                    self._rewards[i] = {
+                        aid: 0.0 for aid in self.envs[i].unwrapped.possible_agents
+                    }
+                    self._terminations[i] = {
+                        aid: False for aid in self.envs[i].unwrapped.possible_agents
+                    }
+                    self._truncations[i] = {
+                        aid: False for aid in self.envs[i].unwrapped.possible_agents
+                    }
+                    # Note, this needs to be added for `MultiAgentEpisode`s to work.
+                    self._terminations[i].update({"__all__": False})
+                    self._truncations[i].update({"__all__": False})
+                # Otherwise make a regular step.
+                else:
+                    (
+                        self._observations[i],
+                        self._rewards[i],
+                        self._terminations[i],
+                        self._truncations[i],
+                        self._infos[i],
+                    ) = self.envs[i].step(action)
+            # Other autoreset modes are not implemented, yet.
+            else:
+                raise ValueError(f"Unexpected autoreset mode: {self.autoreset_mode}")
+
+        # Is any sub-environment terminated or truncated?
+        self._autoreset_envs = np.logical_or(
+            np.array([t["__all__"] for t in self._terminations]),
+            # Note, some environments just return `terminated`.
+            np.array([t.get("__all__", False) for t in self._truncations]),
+        )
+
+        return (
+            deepcopy(self._observations) if self.copy else self._observations,
+            np.copy(self._rewards),
+            np.copy(self._terminations),
+            np.copy(self._truncations),
+            np.copy(self._infos),
+        )
+
+    def render(self) -> Optional[Tuple[RenderFrame, ...]]:
+        """Returns the rendered frames from all environments."""
+        return tuple(env.render() for env in self.envs)
+
+    def call(self, name: str, *args: Any, **kwargs: Any) -> tuple[Any, ...]:
+        """Calls a sub-environment method with name and applies args and kwargs.
+
+        Args:
+            name: The method name
+            *args: The method args
+            **kwargs: The method kwargs
+
+        Returns:
+            Tuple of results
+        """
+        results = []
+        for env in self.envs:
+            function = env.get_wrapper_attr(name)
+
+            if callable(function):
+                results.append(function(*args, **kwargs))
+            else:
+                results.append(function)
+
+        return tuple(results)
+
+    def get_attr(self, name: str) -> tuple[Any, ...]:
+        """Get a property from each parallel environment.
+
+        Args:
+            name: Name of the property to get from each individual environment.
+
+        Returns:
+            The property with name
+        """
+        return self.call(name)
+
+    def close_extras(self, **kwargs):
+        """Close all environments."""
+        if hasattr(self, "envs"):
+            [env.close() for env in self.envs]
+
+    @property
+    def np_random_seed(self) -> Tuple[int, ...]:
+        """Returns a tuple of random seeds for the wrapped envs."""
+        return self.get_attr("np_random_seed")
+
+    @property
+    def np_random(self) -> Tuple[np.random.Generator, ...]:
+        """Returns a tuple of numpy random generators for the wrapped envs."""
+        return self.get_attr("np_random")
+
+    # TODO (simon): Move to space_utils.
+    def create_empty_array(
+        self, space: Dict[str, gym.Space], n: int = 1
+    ) -> List[Dict[str, gym.Space]]:
+
+        return [
+            {aid: agent_space.sample() for aid, agent_space in space.items()}
+            for _ in range(n)
+        ]

tool_server/.venv/lib/python3.12/site-packages/ray/rllib/env/vector/vector_multi_agent_env.py

@@ -0,0 +1,88 @@
+from typing import Any, Dict, List, Optional, Tuple, TypeVar
+
+import gymnasium as gym
+from gymnasium.core import RenderFrame
+from gymnasium.envs.registration import EnvSpec
+from gymnasium.utils import seeding
+import numpy as np
+
+
+ArrayType = TypeVar("ArrayType")
+
+
+class VectorMultiAgentEnv:
+
+    metadata: Dict[str, Any] = {}
+    spec: Optional[EnvSpec] = None
+    render_mode: Optional[str] = None
+    closed: bool = False
+
+    envs: Optional[List] = None
+
+    # TODO (simon, sven): We could think about enabling here different
+    # spaces for different envs (e.g. different high/lows). In this
+    # case we would need here actually "batched" spaces and not a
+    # single on that holds for all sub-envs.
+    single_observation_spaces: Optional[Dict[str, gym.Space]] = None
+    single_action_spaces: Optional[Dict[str, gym.Space]] = None
+    # Note, the proper `gym` spaces are needed for the connector pipeline.
+    single_observation_space: Optional[gym.spaces.Dict] = None
+    single_action_space: Optional[gym.spaces.Dict] = None
+
+    num_envs: int
+
+    _np_random: Optional[np.random.Generator] = None
+    _np_random_seed: Optional[int] = None
+
+    # @OldAPIStack, use `observation_spaces` and `action_spaces`, instead.
+    observation_space: Optional[gym.Space] = None
+    action_space: Optional[gym.Space] = None
+
+    # TODO (simon): Add docstrings, when final design is clear.
+    def reset(
+        self, *, seed: Optional[int] = None, options: Optional[Dict[str, Any]] = None
+    ) -> Tuple[ArrayType, ArrayType]:
+        # Set random generators with the provided seeds.
+        if seed is not None:
+            self._np_random, self._np_random_seed = seeding.np_random(seed)
+
+    def step(
+        self, actions: ArrayType
+    ) -> Tuple[ArrayType, ArrayType, ArrayType, ArrayType, ArrayType]:
+        raise NotImplementedError(f"{self.__str__()} step function is not implemented.")
+
+    def render(self) -> Optional[Tuple[RenderFrame, ...]]:
+        raise NotImplementedError(
+            f"{self.__str__()} render function is not implemented."
+        )
+
+    def close(self, **kwargs: Any):
+
+        # If already closed, there is nothing more to do.
+        if self.closed:
+            return
+
+        # Otherwise close environments gracefully.
+        self.close_extras(**kwargs)
+        self.closed = True
+
+    def close_extras(self, **kwargs: Any):
+        # Users must not implement this.
+        pass
+
+    @property
+    def unwrapped(self):
+        return self
+
+    def __del__(self):
+        # Close environemnts, if necessary when deleting instances.
+        if not getattr(self, "closed", True):
+            self.close()
+
+    def __repr__(self):
+        if self.spec is None:
+            return f"{self.__class__.__name__}(num_envs={self.num_envs})"
+        else:
+            return (
+                f"{self.__class__.__name__}({self.spec.id}, num_envs={self.num_envs})"
+            )

tool_server/.venv/lib/python3.12/site-packages/ray/rllib/env/wrappers/atari_wrappers.py

@@ -0,0 +1,411 @@
+from collections import deque
+import gymnasium as gym
+from gymnasium import spaces
+import numpy as np
+from typing import Optional, Union
+
+from ray.rllib.utils.annotations import PublicAPI
+from ray.rllib.utils.images import rgb2gray, resize
+
+
+@PublicAPI
+def is_atari(env: Union[gym.Env, str]) -> bool:
+    """Returns, whether a given env object or env descriptor (str) is an Atari env.
+
+    Args:
+        env: The gym.Env object or a string descriptor of the env (for example,
+        "ale_py:ALE/Pong-v5").
+
+    Returns:
+        Whether `env` is an Atari environment.
+    """
+    # If a gym.Env, check proper spaces as well as occurrence of the "Atari<ALE" string
+    # in the class name.
+    if not isinstance(env, str):
+        if (
+            hasattr(env.observation_space, "shape")
+            and env.observation_space.shape is not None
+            and len(env.observation_space.shape) <= 2
+        ):
+            return False
+        return "AtariEnv<ALE" in str(env)
+    # If string, check for "ale_py:ALE/" prefix.
+    else:
+        return env.startswith("ALE/") or env.startswith("ale_py:")
+
+
+@PublicAPI
+def get_wrapper_by_cls(env, cls):
+    """Returns the gym env wrapper of the given class, or None."""
+    currentenv = env
+    while True:
+        if isinstance(currentenv, cls):
+            return currentenv
+        elif isinstance(currentenv, gym.Wrapper):
+            currentenv = currentenv.env
+        else:
+            return None
+
+
+@PublicAPI
+class ClipRewardEnv(gym.RewardWrapper):
+    def __init__(self, env):
+        gym.RewardWrapper.__init__(self, env)
+
+    def reward(self, reward):
+        """Bin reward to {+1, 0, -1} by its sign."""
+        return np.sign(reward)
+
+
+@PublicAPI
+class EpisodicLifeEnv(gym.Wrapper):
+    def __init__(self, env):
+        """Make end-of-life == end-of-episode, but only reset on true game over.
+        Done by DeepMind for the DQN and co. since it helps value estimation.
+        """
+        gym.Wrapper.__init__(self, env)
+        self.lives = 0
+        self.was_real_terminated = True
+
+    def step(self, action):
+        obs, reward, terminated, truncated, info = self.env.step(action)
+        self.was_real_terminated = terminated
+        # check current lives, make loss of life terminal,
+        # then update lives to handle bonus lives
+        lives = self.env.unwrapped.ale.lives()
+        if lives < self.lives and lives > 0:
+            # for Qbert sometimes we stay in lives == 0 condtion for a few fr
+            # so its important to keep lives > 0, so that we only reset once
+            # the environment advertises `terminated`.
+            terminated = True
+        self.lives = lives
+        return obs, reward, terminated, truncated, info
+
+    def reset(self, **kwargs):
+        """Reset only when lives are exhausted.
+        This way all states are still reachable even though lives are episodic,
+        and the learner need not know about any of this behind-the-scenes.
+        """
+        if self.was_real_terminated:
+            obs, info = self.env.reset(**kwargs)
+        else:
+            # no-op step to advance from terminal/lost life state
+            obs, _, _, _, info = self.env.step(0)
+        self.lives = self.env.unwrapped.ale.lives()
+        return obs, info
+
+
+@PublicAPI
+class FireResetEnv(gym.Wrapper):
+    def __init__(self, env):
+        """Take action on reset.
+
+        For environments that are fixed until firing."""
+        gym.Wrapper.__init__(self, env)
+        assert env.unwrapped.get_action_meanings()[1] == "FIRE"
+        assert len(env.unwrapped.get_action_meanings()) >= 3
+
+    def reset(self, **kwargs):
+        self.env.reset(**kwargs)
+        obs, _, terminated, truncated, _ = self.env.step(1)
+        if terminated or truncated:
+            self.env.reset(**kwargs)
+        obs, _, terminated, truncated, info = self.env.step(2)
+        if terminated or truncated:
+            self.env.reset(**kwargs)
+        return obs, info
+
+    def step(self, ac):
+        return self.env.step(ac)
+
+
+@PublicAPI
+class FrameStack(gym.Wrapper):
+    def __init__(self, env, k):
+        """Stack k last frames."""
+        gym.Wrapper.__init__(self, env)
+        self.k = k
+        self.frames = deque([], maxlen=k)
+        shp = env.observation_space.shape
+        self.observation_space = spaces.Box(
+            low=np.repeat(env.observation_space.low, repeats=k, axis=-1),
+            high=np.repeat(env.observation_space.high, repeats=k, axis=-1),
+            shape=(shp[0], shp[1], shp[2] * k),
+            dtype=env.observation_space.dtype,
+        )
+
+    def reset(self, *, seed=None, options=None):
+        ob, infos = self.env.reset(seed=seed, options=options)
+        for _ in range(self.k):
+            self.frames.append(ob)
+        return self._get_ob(), infos
+
+    def step(self, action):
+        ob, reward, terminated, truncated, info = self.env.step(action)
+        self.frames.append(ob)
+        return self._get_ob(), reward, terminated, truncated, info
+
+    def _get_ob(self):
+        assert len(self.frames) == self.k
+        return np.concatenate(self.frames, axis=2)
+
+
+@PublicAPI
+class FrameStackTrajectoryView(gym.ObservationWrapper):
+    def __init__(self, env):
+        """No stacking. Trajectory View API takes care of this."""
+        gym.Wrapper.__init__(self, env)
+        shp = env.observation_space.shape
+        assert shp[2] == 1
+        self.observation_space = spaces.Box(
+            low=0, high=255, shape=(shp[0], shp[1]), dtype=env.observation_space.dtype
+        )
+
+    def observation(self, observation):
+        return np.squeeze(observation, axis=-1)
+
+
+@PublicAPI
+class MaxAndSkipEnv(gym.Wrapper):
+    def __init__(self, env, skip=4):
+        """Return only every `skip`-th frame"""
+        gym.Wrapper.__init__(self, env)
+        # most recent raw observations (for max pooling across time steps)
+        self._obs_buffer = np.zeros(
+            (2,) + env.observation_space.shape, dtype=env.observation_space.dtype
+        )
+        self._skip = skip
+
+    def step(self, action):
+        """Repeat action, sum reward, and max over last observations."""
+        total_reward = 0.0
+        terminated = truncated = info = None
+        for i in range(self._skip):
+            obs, reward, terminated, truncated, info = self.env.step(action)
+            if i == self._skip - 2:
+                self._obs_buffer[0] = obs
+            if i == self._skip - 1:
+                self._obs_buffer[1] = obs
+            total_reward += reward
+            if terminated or truncated:
+                break
+        # Note that the observation on the terminated|truncated=True frame
+        # doesn't matter
+        max_frame = self._obs_buffer.max(axis=0)
+
+        return max_frame, total_reward, terminated, truncated, info
+
+    def reset(self, **kwargs):
+        return self.env.reset(**kwargs)
+
+
+@PublicAPI
+class MonitorEnv(gym.Wrapper):
+    def __init__(self, env=None):
+        """Record episodes stats prior to EpisodicLifeEnv, etc."""
+        gym.Wrapper.__init__(self, env)
+        self._current_reward = None
+        self._num_steps = None
+        self._total_steps = None
+        self._episode_rewards = []
+        self._episode_lengths = []
+        self._num_episodes = 0
+        self._num_returned = 0
+
+    def reset(self, **kwargs):
+        obs, info = self.env.reset(**kwargs)
+
+        if self._total_steps is None:
+            self._total_steps = sum(self._episode_lengths)
+
+        if self._current_reward is not None:
+            self._episode_rewards.append(self._current_reward)
+            self._episode_lengths.append(self._num_steps)
+            self._num_episodes += 1
+
+        self._current_reward = 0
+        self._num_steps = 0
+
+        return obs, info
+
+    def step(self, action):
+        obs, rew, terminated, truncated, info = self.env.step(action)
+        self._current_reward += rew
+        self._num_steps += 1
+        self._total_steps += 1
+        return obs, rew, terminated, truncated, info
+
+    def get_episode_rewards(self):
+        return self._episode_rewards
+
+    def get_episode_lengths(self):
+        return self._episode_lengths
+
+    def get_total_steps(self):
+        return self._total_steps
+
+    def next_episode_results(self):
+        for i in range(self._num_returned, len(self._episode_rewards)):
+            yield (self._episode_rewards[i], self._episode_lengths[i])
+        self._num_returned = len(self._episode_rewards)
+
+
+@PublicAPI
+class NoopResetEnv(gym.Wrapper):
+    def __init__(self, env, noop_max=30):
+        """Sample initial states by taking random number of no-ops on reset.
+        No-op is assumed to be action 0.
+        """
+        gym.Wrapper.__init__(self, env)
+        self.noop_max = noop_max
+        self.override_num_noops = None
+        self.noop_action = 0
+        assert env.unwrapped.get_action_meanings()[0] == "NOOP"
+
+    def reset(self, **kwargs):
+        """Do no-op action for a number of steps in [1, noop_max]."""
+        self.env.reset(**kwargs)
+        if self.override_num_noops is not None:
+            noops = self.override_num_noops
+        else:
+            # This environment now uses the pcg64 random number generator which
+            # does not have `randint` as an attribute only has `integers`.
+            try:
+                noops = self.unwrapped.np_random.integers(1, self.noop_max + 1)
+            # Also still support older versions.
+            except AttributeError:
+                noops = self.unwrapped.np_random.randint(1, self.noop_max + 1)
+        assert noops > 0
+        obs = None
+        for _ in range(noops):
+            obs, _, terminated, truncated, info = self.env.step(self.noop_action)
+            if terminated or truncated:
+                obs, info = self.env.reset(**kwargs)
+        return obs, info
+
+    def step(self, ac):
+        return self.env.step(ac)
+
+
+@PublicAPI
+class NormalizedImageEnv(gym.ObservationWrapper):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.observation_space = gym.spaces.Box(
+            -1.0,
+            1.0,
+            shape=self.observation_space.shape,
+            dtype=np.float32,
+        )
+
+    # Divide by scale and center around 0.0, such that observations are in the range
+    # of -1.0 and 1.0.
+    def observation(self, observation):
+        return (observation.astype(np.float32) / 128.0) - 1.0
+
+
+@PublicAPI
+class GrayScaleAndResize(gym.ObservationWrapper):
+    def __init__(self, env, dim, grayscale: bool = True):
+        """Warp frames to the specified size (dim x dim)."""
+        gym.ObservationWrapper.__init__(self, env)
+        self.width = dim
+        self.height = dim
+        self.grayscale = grayscale
+        self.observation_space = spaces.Box(
+            low=0,
+            high=255,
+            shape=(self.height, self.width, 1 if grayscale else 3),
+            dtype=np.uint8,
+        )
+
+    def observation(self, frame):
+        if self.grayscale:
+            frame = rgb2gray(frame)
+            frame = resize(frame, height=self.height, width=self.width)
+            return frame[:, :, None]
+        else:
+            return resize(frame, height=self.height, width=self.width)
+
+
+WarpFrame = GrayScaleAndResize
+
+
+@PublicAPI
+def wrap_atari_for_new_api_stack(
+    env: gym.Env,
+    dim: int = 64,
+    frameskip: int = 4,
+    framestack: Optional[int] = None,
+    grayscale: bool = True,
+    # TODO (sven): Add option to NOT grayscale, in which case framestack must be None
+    #  (b/c we are using the 3 color channels already as stacking frames).
+) -> gym.Env:
+    """Wraps `env` for new-API-stack-friendly RLlib Atari experiments.
+
+    Note that we assume reward clipping is done outside the wrapper.
+
+    Args:
+        env: The env object to wrap.
+        dim: Dimension to resize observations to (dim x dim).
+        frameskip: Whether to skip n frames and max over them (keep brightest pixels).
+        framestack: Whether to stack the last n (grayscaled) frames. Note that this
+            step happens after(!) a possible frameskip step, meaning that if
+            frameskip=4 and framestack=2, we would perform the following over this
+            trajectory:
+            actual env timesteps: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 -> ...
+            frameskip:            ( max ) ( max ) ( max   ) ( max     )
+            framestack:           ( stack       ) (stack              )
+
+    Returns:
+        The wrapped gym.Env.
+    """
+    # Time limit.
+    env = gym.wrappers.TimeLimit(env, max_episode_steps=108000)
+    # Grayscale + resize.
+    env = WarpFrame(env, dim=dim, grayscale=grayscale)
+    # Normalize the image.
+    env = NormalizedImageEnv(env)
+    # Frameskip: Take max over these n frames.
+    if frameskip > 1:
+        assert env.spec is not None
+        env = MaxAndSkipEnv(env, skip=frameskip)
+    # Send n noop actions into env after reset to increase variance in the
+    # "start states" of the trajectories. These dummy steps are NOT included in the
+    # sampled data used for learning.
+    env = NoopResetEnv(env, noop_max=30)
+    # Each life is one episode.
+    env = EpisodicLifeEnv(env)
+    # Some envs only start playing after pressing fire. Unblock those.
+    if "FIRE" in env.unwrapped.get_action_meanings():
+        env = FireResetEnv(env)
+    # Framestack.
+    if framestack:
+        env = FrameStack(env, k=framestack)
+    return env
+
+
+@PublicAPI
+def wrap_deepmind(env, dim=84, framestack=True, noframeskip=False):
+    """Configure environment for DeepMind-style Atari.
+
+    Note that we assume reward clipping is done outside the wrapper.
+
+    Args:
+        env: The env object to wrap.
+        dim: Dimension to resize observations to (dim x dim).
+        framestack: Whether to framestack observations.
+    """
+    env = MonitorEnv(env)
+    env = NoopResetEnv(env, noop_max=30)
+    if env.spec is not None and noframeskip is True:
+        env = MaxAndSkipEnv(env, skip=4)
+    env = EpisodicLifeEnv(env)
+    if "FIRE" in env.unwrapped.get_action_meanings():
+        env = FireResetEnv(env)
+    env = WarpFrame(env, dim)
+    # env = ClipRewardEnv(env)  # reward clipping is handled by policy eval
+    # 4x image framestacking.
+    if framestack is True:
+        env = FrameStack(env, 4)
+    return env