Add files using upload-large-folder tool

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/connectors/action/clip.py

@@ -0,0 +1,41 @@
+from typing import Any
+
+from ray.rllib.connectors.connector import (
+    ActionConnector,
+    ConnectorContext,
+)
+from ray.rllib.connectors.registry import register_connector
+from ray.rllib.utils.spaces.space_utils import clip_action, get_base_struct_from_space
+from ray.rllib.utils.typing import ActionConnectorDataType
+from ray.rllib.utils.annotations import OldAPIStack
+
+
+@OldAPIStack
+class ClipActionsConnector(ActionConnector):
+    def __init__(self, ctx: ConnectorContext):
+        super().__init__(ctx)
+
+        self._action_space_struct = get_base_struct_from_space(ctx.action_space)
+
+    def transform(self, ac_data: ActionConnectorDataType) -> ActionConnectorDataType:
+        assert isinstance(
+            ac_data.output, tuple
+        ), "Action connector requires PolicyOutputType data."
+
+        actions, states, fetches = ac_data.output
+        return ActionConnectorDataType(
+            ac_data.env_id,
+            ac_data.agent_id,
+            ac_data.input_dict,
+            (clip_action(actions, self._action_space_struct), states, fetches),
+        )
+
+    def to_state(self):
+        return ClipActionsConnector.__name__, None
+
+    @staticmethod
+    def from_state(ctx: ConnectorContext, params: Any):
+        return ClipActionsConnector(ctx)
+
+
+register_connector(ClipActionsConnector.__name__, ClipActionsConnector)

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/connectors/action/lambdas.py

@@ -0,0 +1,76 @@
+from typing import Any, Callable, Dict, Type
+
+from ray.rllib.connectors.connector import (
+    ActionConnector,
+    ConnectorContext,
+)
+from ray.rllib.connectors.registry import register_connector
+from ray.rllib.utils.numpy import convert_to_numpy
+from ray.rllib.utils.typing import (
+    ActionConnectorDataType,
+    PolicyOutputType,
+    StateBatches,
+    TensorStructType,
+)
+from ray.rllib.utils.annotations import OldAPIStack
+
+
+@OldAPIStack
+def register_lambda_action_connector(
+    name: str, fn: Callable[[TensorStructType, StateBatches, Dict], PolicyOutputType]
+) -> Type[ActionConnector]:
+    """A util to register any function transforming PolicyOutputType as an ActionConnector.
+
+    The only requirement is that fn should take actions, states, and fetches as input,
+    and return transformed actions, states, and fetches.
+
+    Args:
+        name: Name of the resulting actor connector.
+        fn: The function that transforms PolicyOutputType.
+
+    Returns:
+        A new ActionConnector class that transforms PolicyOutputType using fn.
+    """
+
+    class LambdaActionConnector(ActionConnector):
+        def transform(
+            self, ac_data: ActionConnectorDataType
+        ) -> ActionConnectorDataType:
+            assert isinstance(
+                ac_data.output, tuple
+            ), "Action connector requires PolicyOutputType data."
+
+            actions, states, fetches = ac_data.output
+            return ActionConnectorDataType(
+                ac_data.env_id,
+                ac_data.agent_id,
+                ac_data.input_dict,
+                fn(actions, states, fetches),
+            )
+
+        def to_state(self):
+            return name, None
+
+        @staticmethod
+        def from_state(ctx: ConnectorContext, params: Any):
+            return LambdaActionConnector(ctx)
+
+    LambdaActionConnector.__name__ = name
+    LambdaActionConnector.__qualname__ = name
+
+    register_connector(name, LambdaActionConnector)
+
+    return LambdaActionConnector
+
+
+# Convert actions and states into numpy arrays if necessary.
+ConvertToNumpyConnector = OldAPIStack(
+    register_lambda_action_connector(
+        "ConvertToNumpyConnector",
+        lambda actions, states, fetches: (
+            convert_to_numpy(actions),
+            convert_to_numpy(states),
+            fetches,
+        ),
+    ),
+)

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/connectors/action/pipeline.py

@@ -0,0 +1,61 @@
+import logging
+from typing import Any, List
+from collections import defaultdict
+
+from ray.rllib.connectors.connector import (
+    ActionConnector,
+    Connector,
+    ConnectorContext,
+    ConnectorPipeline,
+)
+from ray.rllib.connectors.registry import get_connector, register_connector
+from ray.rllib.utils.annotations import OldAPIStack
+from ray.rllib.utils.typing import ActionConnectorDataType
+from ray.util.timer import _Timer
+
+
+logger = logging.getLogger(__name__)
+
+
+@OldAPIStack
+class ActionConnectorPipeline(ConnectorPipeline, ActionConnector):
+    def __init__(self, ctx: ConnectorContext, connectors: List[Connector]):
+        super().__init__(ctx, connectors)
+        self.timers = defaultdict(_Timer)
+
+    def __call__(self, ac_data: ActionConnectorDataType) -> ActionConnectorDataType:
+        for c in self.connectors:
+            timer = self.timers[str(c)]
+            with timer:
+                ac_data = c(ac_data)
+        return ac_data
+
+    def to_state(self):
+        children = []
+        for c in self.connectors:
+            state = c.to_state()
+            assert isinstance(state, tuple) and len(state) == 2, (
+                "Serialized connector state must be in the format of "
+                f"Tuple[name: str, params: Any]. Instead we got {state}"
+                f"for connector {c.__name__}."
+            )
+            children.append(state)
+        return ActionConnectorPipeline.__name__, children
+
+    @staticmethod
+    def from_state(ctx: ConnectorContext, params: Any):
+        assert (
+            type(params) == list
+        ), "ActionConnectorPipeline takes a list of connector params."
+        connectors = []
+        for state in params:
+            try:
+                name, subparams = state
+                connectors.append(get_connector(name, ctx, subparams))
+            except Exception as e:
+                logger.error(f"Failed to de-serialize connector state: {state}")
+                raise e
+        return ActionConnectorPipeline(ctx, connectors)
+
+
+register_connector(ActionConnectorPipeline.__name__, ActionConnectorPipeline)

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/connectors/agent/clip_reward.py

@@ -0,0 +1,56 @@
+from typing import Any
+
+import numpy as np
+
+from ray.rllib.connectors.connector import (
+    AgentConnector,
+    ConnectorContext,
+)
+from ray.rllib.connectors.registry import register_connector
+from ray.rllib.policy.sample_batch import SampleBatch
+from ray.rllib.utils.typing import AgentConnectorDataType
+from ray.rllib.utils.annotations import OldAPIStack
+
+
+@OldAPIStack
+class ClipRewardAgentConnector(AgentConnector):
+    def __init__(self, ctx: ConnectorContext, sign=False, limit=None):
+        super().__init__(ctx)
+        assert (
+            not sign or not limit
+        ), "should not enable both sign and limit reward clipping."
+        self.sign = sign
+        self.limit = limit
+
+    def transform(self, ac_data: AgentConnectorDataType) -> AgentConnectorDataType:
+        d = ac_data.data
+        assert (
+            type(d) == dict
+        ), "Single agent data must be of type Dict[str, TensorStructType]"
+
+        if SampleBatch.REWARDS not in d:
+            # Nothing to clip. May happen for initial obs.
+            return ac_data
+
+        if self.sign:
+            d[SampleBatch.REWARDS] = np.sign(d[SampleBatch.REWARDS])
+        elif self.limit:
+            d[SampleBatch.REWARDS] = np.clip(
+                d[SampleBatch.REWARDS],
+                a_min=-self.limit,
+                a_max=self.limit,
+            )
+        return ac_data
+
+    def to_state(self):
+        return ClipRewardAgentConnector.__name__, {
+            "sign": self.sign,
+            "limit": self.limit,
+        }
+
+    @staticmethod
+    def from_state(ctx: ConnectorContext, params: Any):
+        return ClipRewardAgentConnector(ctx, **params)
+
+
+register_connector(ClipRewardAgentConnector.__name__, ClipRewardAgentConnector)

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/connectors/agent/lambdas.py

@@ -0,0 +1,86 @@
+from typing import Any, Callable, Type
+
+import numpy as np
+import tree  # dm_tree
+
+from ray.rllib.connectors.connector import (
+    AgentConnector,
+    ConnectorContext,
+)
+from ray.rllib.connectors.registry import register_connector
+from ray.rllib.policy.sample_batch import SampleBatch
+from ray.rllib.utils.typing import (
+    AgentConnectorDataType,
+    AgentConnectorsOutput,
+)
+from ray.rllib.utils.annotations import OldAPIStack
+
+
+@OldAPIStack
+def register_lambda_agent_connector(
+    name: str, fn: Callable[[Any], Any]
+) -> Type[AgentConnector]:
+    """A util to register any simple transforming function as an AgentConnector
+
+    The only requirement is that fn should take a single data object and return
+    a single data object.
+
+    Args:
+        name: Name of the resulting actor connector.
+        fn: The function that transforms env / agent data.
+
+    Returns:
+        A new AgentConnector class that transforms data using fn.
+    """
+
+    class LambdaAgentConnector(AgentConnector):
+        def transform(self, ac_data: AgentConnectorDataType) -> AgentConnectorDataType:
+            return AgentConnectorDataType(
+                ac_data.env_id, ac_data.agent_id, fn(ac_data.data)
+            )
+
+        def to_state(self):
+            return name, None
+
+        @staticmethod
+        def from_state(ctx: ConnectorContext, params: Any):
+            return LambdaAgentConnector(ctx)
+
+    LambdaAgentConnector.__name__ = name
+    LambdaAgentConnector.__qualname__ = name
+
+    register_connector(name, LambdaAgentConnector)
+
+    return LambdaAgentConnector
+
+
+@OldAPIStack
+def flatten_data(data: AgentConnectorsOutput):
+    assert isinstance(
+        data, AgentConnectorsOutput
+    ), "Single agent data must be of type AgentConnectorsOutput"
+
+    raw_dict = data.raw_dict
+    sample_batch = data.sample_batch
+
+    flattened = {}
+    for k, v in sample_batch.items():
+        if k in [SampleBatch.INFOS, SampleBatch.ACTIONS] or k.startswith("state_out_"):
+            # Do not flatten infos, actions, and state_out_ columns.
+            flattened[k] = v
+            continue
+        if v is None:
+            # Keep the same column shape.
+            flattened[k] = None
+            continue
+        flattened[k] = np.array(tree.flatten(v))
+    flattened = SampleBatch(flattened, is_training=False)
+
+    return AgentConnectorsOutput(raw_dict, flattened)
+
+
+# Agent connector to build and return a flattened observation SampleBatch
+# in addition to the original input dict.
+FlattenDataAgentConnector = OldAPIStack(
+    register_lambda_agent_connector("FlattenDataAgentConnector", flatten_data)
+)

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/connectors/agent/pipeline.py

@@ -0,0 +1,72 @@
+import logging
+from typing import Any, List
+from collections import defaultdict
+
+from ray.rllib.connectors.connector import (
+    AgentConnector,
+    Connector,
+    ConnectorContext,
+    ConnectorPipeline,
+)
+from ray.rllib.connectors.registry import get_connector, register_connector
+from ray.rllib.utils.typing import ActionConnectorDataType, AgentConnectorDataType
+from ray.rllib.utils.annotations import OldAPIStack
+from ray.util.timer import _Timer
+
+
+logger = logging.getLogger(__name__)
+
+
+@OldAPIStack
+class AgentConnectorPipeline(ConnectorPipeline, AgentConnector):
+    def __init__(self, ctx: ConnectorContext, connectors: List[Connector]):
+        super().__init__(ctx, connectors)
+        self.timers = defaultdict(_Timer)
+
+    def reset(self, env_id: str):
+        for c in self.connectors:
+            c.reset(env_id)
+
+    def on_policy_output(self, output: ActionConnectorDataType):
+        for c in self.connectors:
+            c.on_policy_output(output)
+
+    def __call__(
+        self, acd_list: List[AgentConnectorDataType]
+    ) -> List[AgentConnectorDataType]:
+        ret = acd_list
+        for c in self.connectors:
+            timer = self.timers[str(c)]
+            with timer:
+                ret = c(ret)
+        return ret
+
+    def to_state(self):
+        children = []
+        for c in self.connectors:
+            state = c.to_state()
+            assert isinstance(state, tuple) and len(state) == 2, (
+                "Serialized connector state must be in the format of "
+                f"Tuple[name: str, params: Any]. Instead we got {state}"
+                f"for connector {c.__name__}."
+            )
+            children.append(state)
+        return AgentConnectorPipeline.__name__, children
+
+    @staticmethod
+    def from_state(ctx: ConnectorContext, params: List[Any]):
+        assert (
+            type(params) == list
+        ), "AgentConnectorPipeline takes a list of connector params."
+        connectors = []
+        for state in params:
+            try:
+                name, subparams = state
+                connectors.append(get_connector(name, ctx, subparams))
+            except Exception as e:
+                logger.error(f"Failed to de-serialize connector state: {state}")
+                raise e
+        return AgentConnectorPipeline(ctx, connectors)
+
+
+register_connector(AgentConnectorPipeline.__name__, AgentConnectorPipeline)

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/connectors/agent/state_buffer.py

@@ -0,0 +1,120 @@
+from collections import defaultdict
+import logging
+import pickle
+from typing import Any
+
+import numpy as np
+from ray.rllib.utils.annotations import override
+import tree  # dm_tree
+
+from ray.rllib.connectors.connector import (
+    AgentConnector,
+    Connector,
+    ConnectorContext,
+)
+from ray import cloudpickle
+from ray.rllib.connectors.registry import register_connector
+from ray.rllib.core.columns import Columns
+from ray.rllib.policy.sample_batch import SampleBatch
+from ray.rllib.utils.spaces.space_utils import get_base_struct_from_space
+from ray.rllib.utils.typing import ActionConnectorDataType, AgentConnectorDataType
+from ray.rllib.utils.annotations import OldAPIStack
+
+
+logger = logging.getLogger(__name__)
+
+
+@OldAPIStack
+class StateBufferConnector(AgentConnector):
+    def __init__(self, ctx: ConnectorContext, states: Any = None):
+        super().__init__(ctx)
+
+        self._initial_states = ctx.initial_states
+        self._action_space_struct = get_base_struct_from_space(ctx.action_space)
+
+        self._states = defaultdict(lambda: defaultdict(lambda: (None, None, None)))
+        self._enable_new_api_stack = False
+        # TODO(jungong) : we would not need this if policies are never stashed
+        # during the rollout of a single episode.
+        if states:
+            try:
+                self._states = cloudpickle.loads(states)
+            except pickle.UnpicklingError:
+                # StateBufferConnector states are only needed for rare cases
+                # like stashing then restoring a policy during the rollout of
+                # a single episode.
+                # It is ok to ignore the error for most of the cases here.
+                logger.info(
+                    "Can not restore StateBufferConnector states. This warning can "
+                    "usually be ignore, unless it is from restoring a stashed policy."
+                )
+
+    @override(Connector)
+    def in_eval(self):
+        super().in_eval()
+
+    def reset(self, env_id: str):
+        # States should not be carried over between episodes.
+        if env_id in self._states:
+            del self._states[env_id]
+
+    def on_policy_output(self, ac_data: ActionConnectorDataType):
+        # Buffer latest output states for next input __call__.
+        self._states[ac_data.env_id][ac_data.agent_id] = ac_data.output
+
+    def transform(self, ac_data: AgentConnectorDataType) -> AgentConnectorDataType:
+        d = ac_data.data
+        assert (
+            type(d) is dict
+        ), "Single agent data must be of type Dict[str, TensorStructType]"
+
+        env_id = ac_data.env_id
+        agent_id = ac_data.agent_id
+        assert (
+            env_id is not None and agent_id is not None
+        ), f"StateBufferConnector requires env_id(f{env_id}) and agent_id(f{agent_id})"
+
+        action, states, fetches = self._states[env_id][agent_id]
+
+        if action is not None:
+            d[SampleBatch.ACTIONS] = action  # Last action
+        else:
+            # Default zero action.
+            d[SampleBatch.ACTIONS] = tree.map_structure(
+                lambda s: np.zeros_like(s.sample(), s.dtype)
+                if hasattr(s, "dtype")
+                else np.zeros_like(s.sample()),
+                self._action_space_struct,
+            )
+
+        if states is None:
+            states = self._initial_states
+        if self._enable_new_api_stack:
+            if states:
+                d[Columns.STATE_OUT] = states
+        else:
+            for i, v in enumerate(states):
+                d["state_out_{}".format(i)] = v
+
+        # Also add extra fetches if available.
+        if fetches:
+            d.update(fetches)
+
+        return ac_data
+
+    def to_state(self):
+        # Note(jungong) : it is ok to use cloudpickle here for stats because:
+        # 1. self._states may contain arbitary data objects, and will be hard
+        #     to serialize otherwise.
+        # 2. seriazlized states are only useful if a policy is stashed and
+        #     restored during the rollout of a single episode. So it is ok to
+        #     use cloudpickle for such non-persistent data bits.
+        states = cloudpickle.dumps(self._states)
+        return StateBufferConnector.__name__, states
+
+    @staticmethod
+    def from_state(ctx: ConnectorContext, params: Any):
+        return StateBufferConnector(ctx, params)
+
+
+register_connector(StateBufferConnector.__name__, StateBufferConnector)

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/connectors/connector_pipeline_v2.py

@@ -0,0 +1,381 @@
+from collections import defaultdict
+import logging
+from typing import Any, Collection, Dict, List, Optional, Tuple, Type, Union
+
+import gymnasium as gym
+
+from ray.rllib.connectors.connector_v2 import ConnectorV2
+from ray.rllib.core.rl_module.rl_module import RLModule
+from ray.rllib.utils.annotations import override
+from ray.rllib.utils.checkpoints import Checkpointable
+from ray.rllib.utils.typing import EpisodeType, StateDict
+from ray.util.annotations import PublicAPI
+from ray.util.timer import _Timer
+
+logger = logging.getLogger(__name__)
+
+
+@PublicAPI(stability="alpha")
+class ConnectorPipelineV2(ConnectorV2):
+    """Utility class for quick manipulation of a connector pipeline."""
+
+    @override(ConnectorV2)
+    def recompute_output_observation_space(
+        self,
+        input_observation_space: gym.Space,
+        input_action_space: gym.Space,
+    ) -> gym.Space:
+        self._fix_spaces(input_observation_space, input_action_space)
+        return self.observation_space
+
+    @override(ConnectorV2)
+    def recompute_output_action_space(
+        self,
+        input_observation_space: gym.Space,
+        input_action_space: gym.Space,
+    ) -> gym.Space:
+        self._fix_spaces(input_observation_space, input_action_space)
+        return self.action_space
+
+    def __init__(
+        self,
+        input_observation_space: Optional[gym.Space] = None,
+        input_action_space: Optional[gym.Space] = None,
+        *,
+        connectors: Optional[List[ConnectorV2]] = None,
+        **kwargs,
+    ):
+        """Initializes a ConnectorPipelineV2 instance.
+
+        Args:
+            input_observation_space: The (optional) input observation space for this
+                connector piece. This is the space coming from a previous connector
+                piece in the (env-to-module or learner) pipeline or is directly
+                defined within the gym.Env.
+            input_action_space: The (optional) input action space for this connector
+                piece. This is the space coming from a previous connector piece in the
+                (module-to-env) pipeline or is directly defined within the gym.Env.
+            connectors: A list of individual ConnectorV2 pieces to be added to this
+                pipeline during construction. Note that you can always add (or remove)
+                more ConnectorV2 pieces later on the fly.
+        """
+        self.connectors = []
+
+        for conn in connectors:
+            # If we have a `ConnectorV2` instance just append.
+            if isinstance(conn, ConnectorV2):
+                self.connectors.append(conn)
+            # If, we have a class with `args` and `kwargs`, build the instance.
+            # Note that this way of constructing a pipeline should only be
+            # used internally when restoring the pipeline state from a
+            # checkpoint.
+            elif isinstance(conn, tuple) and len(conn) == 3:
+                self.connectors.append(conn[0](*conn[1], **conn[2]))
+
+        super().__init__(input_observation_space, input_action_space, **kwargs)
+
+        self.timers = defaultdict(_Timer)
+
+    def __len__(self):
+        return len(self.connectors)
+
+    @override(ConnectorV2)
+    def __call__(
+        self,
+        *,
+        rl_module: RLModule,
+        batch: Dict[str, Any],
+        episodes: List[EpisodeType],
+        explore: Optional[bool] = None,
+        shared_data: Optional[dict] = None,
+        **kwargs,
+    ) -> Any:
+        """In a pipeline, we simply call each of our connector pieces after each other.
+
+        Each connector piece receives as input the output of the previous connector
+        piece in the pipeline.
+        """
+        shared_data = shared_data if shared_data is not None else {}
+        # Loop through connector pieces and call each one with the output of the
+        # previous one. Thereby, time each connector piece's call.
+        for connector in self.connectors:
+            timer = self.timers[str(connector)]
+            with timer:
+                batch = connector(
+                    rl_module=rl_module,
+                    batch=batch,
+                    episodes=episodes,
+                    explore=explore,
+                    shared_data=shared_data,
+                    # Deprecated arg.
+                    data=batch,
+                    **kwargs,
+                )
+                if not isinstance(batch, dict):
+                    raise ValueError(
+                        f"`data` returned by ConnectorV2 {connector} must be a dict! "
+                        f"You returned {batch}. Check your (custom) connectors' "
+                        f"`__call__()` method's return value and make sure you return "
+                        f"the `data` arg passed in (either altered or unchanged)."
+                    )
+        return batch
+
+    def remove(self, name_or_class: Union[str, Type]):
+        """Remove a single connector piece in this pipeline by its name or class.
+
+        Args:
+            name: The name of the connector piece to be removed from the pipeline.
+        """
+        idx = -1
+        for i, c in enumerate(self.connectors):
+            if c.__class__.__name__ == name_or_class:
+                idx = i
+                break
+        if idx >= 0:
+            del self.connectors[idx]
+            self._fix_spaces(self.input_observation_space, self.input_action_space)
+            logger.info(
+                f"Removed connector {name_or_class} from {self.__class__.__name__}."
+            )
+        else:
+            logger.warning(
+                f"Trying to remove a non-existent connector {name_or_class}."
+            )
+
+    def insert_before(
+        self,
+        name_or_class: Union[str, type],
+        connector: ConnectorV2,
+    ) -> ConnectorV2:
+        """Insert a new connector piece before an existing piece (by name or class).
+
+        Args:
+            name_or_class: Name or class of the connector piece before which `connector`
+                will get inserted.
+            connector: The new connector piece to be inserted.
+
+        Returns:
+            The ConnectorV2 before which `connector` has been inserted.
+        """
+        idx = -1
+        for idx, c in enumerate(self.connectors):
+            if (
+                isinstance(name_or_class, str) and c.__class__.__name__ == name_or_class
+            ) or (isinstance(name_or_class, type) and c.__class__ is name_or_class):
+                break
+        if idx < 0:
+            raise ValueError(
+                f"Can not find connector with name or type '{name_or_class}'!"
+            )
+        next_connector = self.connectors[idx]
+
+        self.connectors.insert(idx, connector)
+        self._fix_spaces(self.input_observation_space, self.input_action_space)
+
+        logger.info(
+            f"Inserted {connector.__class__.__name__} before {name_or_class} "
+            f"to {self.__class__.__name__}."
+        )
+        return next_connector
+
+    def insert_after(
+        self,
+        name_or_class: Union[str, Type],
+        connector: ConnectorV2,
+    ) -> ConnectorV2:
+        """Insert a new connector piece after an existing piece (by name or class).
+
+        Args:
+            name_or_class: Name or class of the connector piece after which `connector`
+                will get inserted.
+            connector: The new connector piece to be inserted.
+
+        Returns:
+            The ConnectorV2 after which `connector` has been inserted.
+        """
+        idx = -1
+        for idx, c in enumerate(self.connectors):
+            if (
+                isinstance(name_or_class, str) and c.__class__.__name__ == name_or_class
+            ) or (isinstance(name_or_class, type) and c.__class__ is name_or_class):
+                break
+        if idx < 0:
+            raise ValueError(
+                f"Can not find connector with name or type '{name_or_class}'!"
+            )
+        prev_connector = self.connectors[idx]
+
+        self.connectors.insert(idx + 1, connector)
+        self._fix_spaces(self.input_observation_space, self.input_action_space)
+
+        logger.info(
+            f"Inserted {connector.__class__.__name__} after {name_or_class} "
+            f"to {self.__class__.__name__}."
+        )
+
+        return prev_connector
+
+    def prepend(self, connector: ConnectorV2) -> None:
+        """Prepend a new connector at the beginning of a connector pipeline.
+
+        Args:
+            connector: The new connector piece to be prepended to this pipeline.
+        """
+        self.connectors.insert(0, connector)
+        self._fix_spaces(self.input_observation_space, self.input_action_space)
+
+        logger.info(
+            f"Added {connector.__class__.__name__} to the beginning of "
+            f"{self.__class__.__name__}."
+        )
+
+    def append(self, connector: ConnectorV2) -> None:
+        """Append a new connector at the end of a connector pipeline.
+
+        Args:
+            connector: The new connector piece to be appended to this pipeline.
+        """
+        self.connectors.append(connector)
+        self._fix_spaces(self.input_observation_space, self.input_action_space)
+
+        logger.info(
+            f"Added {connector.__class__.__name__} to the end of "
+            f"{self.__class__.__name__}."
+        )
+
+    @override(ConnectorV2)
+    def get_state(
+        self,
+        components: Optional[Union[str, Collection[str]]] = None,
+        *,
+        not_components: Optional[Union[str, Collection[str]]] = None,
+        **kwargs,
+    ) -> StateDict:
+        state = {}
+        for conn in self.connectors:
+            conn_name = type(conn).__name__
+            if self._check_component(conn_name, components, not_components):
+                state[conn_name] = conn.get_state(
+                    components=self._get_subcomponents(conn_name, components),
+                    not_components=self._get_subcomponents(conn_name, not_components),
+                    **kwargs,
+                )
+        return state
+
+    @override(ConnectorV2)
+    def set_state(self, state: Dict[str, Any]) -> None:
+        for conn in self.connectors:
+            conn_name = type(conn).__name__
+            if conn_name in state:
+                conn.set_state(state[conn_name])
+
+    @override(Checkpointable)
+    def get_checkpointable_components(self) -> List[Tuple[str, "Checkpointable"]]:
+        return [(type(conn).__name__, conn) for conn in self.connectors]
+
+    # Note that we don't have to override Checkpointable.get_ctor_args_and_kwargs and
+    # don't have to return the `connectors` c'tor kwarg from there. This is b/c all
+    # connector pieces in this pipeline are themselves Checkpointable components,
+    # so they will be properly written into this pipeline's checkpoint.
+    @override(Checkpointable)
+    def get_ctor_args_and_kwargs(self) -> Tuple[Tuple, Dict[str, Any]]:
+        return (
+            (self.input_observation_space, self.input_action_space),  # *args
+            {
+                "connectors": [
+                    (type(conn), *conn.get_ctor_args_and_kwargs())
+                    for conn in self.connectors
+                ]
+            },
+        )
+
+    @override(ConnectorV2)
+    def reset_state(self) -> None:
+        for conn in self.connectors:
+            conn.reset_state()
+
+    @override(ConnectorV2)
+    def merge_states(self, states: List[Dict[str, Any]]) -> Dict[str, Any]:
+        merged_states = {}
+        if not states:
+            return merged_states
+        for i, (key, item) in enumerate(states[0].items()):
+            state_list = [state[key] for state in states]
+            conn = self.connectors[i]
+            merged_states[key] = conn.merge_states(state_list)
+        return merged_states
+
+    def __repr__(self, indentation: int = 0):
+        return "\n".join(
+            [" " * indentation + self.__class__.__name__]
+            + [c.__str__(indentation + 4) for c in self.connectors]
+        )
+
+    def __getitem__(
+        self,
+        key: Union[str, int, Type],
+    ) -> Union[ConnectorV2, List[ConnectorV2]]:
+        """Returns a single ConnectorV2 or list of ConnectorV2s that fit `key`.
+
+        If key is an int, we return a single ConnectorV2 at that index in this pipeline.
+        If key is a ConnectorV2 type or a string matching the class name of a
+        ConnectorV2 in this pipeline, we return a list of all ConnectorV2s in this
+        pipeline matching the specified class.
+
+        Args:
+            key: The key to find or to index by.
+
+        Returns:
+            A single ConnectorV2 or a list of ConnectorV2s matching `key`.
+        """
+        # Key is an int -> Index into pipeline and return.
+        if isinstance(key, int):
+            return self.connectors[key]
+        # Key is a class.
+        elif isinstance(key, type):
+            results = []
+            for c in self.connectors:
+                if issubclass(c.__class__, key):
+                    results.append(c)
+            return results
+        # Key is a string -> Find connector(s) by name.
+        elif isinstance(key, str):
+            results = []
+            for c in self.connectors:
+                if c.name == key:
+                    results.append(c)
+            return results
+        # Slicing not supported (yet).
+        elif isinstance(key, slice):
+            raise NotImplementedError(
+                "Slicing of ConnectorPipelineV2 is currently not supported!"
+            )
+        else:
+            raise NotImplementedError(
+                f"Indexing ConnectorPipelineV2 by {type(key)} is currently not "
+                f"supported!"
+            )
+
+    @property
+    def observation_space(self):
+        if len(self) > 0:
+            return self.connectors[-1].observation_space
+        return self._observation_space
+
+    @property
+    def action_space(self):
+        if len(self) > 0:
+            return self.connectors[-1].action_space
+        return self._action_space
+
+    def _fix_spaces(self, input_observation_space, input_action_space):
+        if len(self) > 0:
+            # Fix each connector's input_observation- and input_action space in
+            # the pipeline.
+            obs_space = input_observation_space
+            act_space = input_action_space
+            for con in self.connectors:
+                con.input_action_space = act_space
+                con.input_observation_space = obs_space
+                obs_space = con.observation_space
+                act_space = con.action_space

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/connectors/env_to_module/__init__.py

@@ -0,0 +1,36 @@
+from ray.rllib.connectors.common.add_observations_from_episodes_to_batch import (
+    AddObservationsFromEpisodesToBatch,
+)
+from ray.rllib.connectors.common.add_states_from_episodes_to_batch import (
+    AddStatesFromEpisodesToBatch,
+)
+from ray.rllib.connectors.common.agent_to_module_mapping import AgentToModuleMapping
+from ray.rllib.connectors.common.batch_individual_items import BatchIndividualItems
+from ray.rllib.connectors.common.numpy_to_tensor import NumpyToTensor
+from ray.rllib.connectors.env_to_module.env_to_module_pipeline import (
+    EnvToModulePipeline,
+)
+from ray.rllib.connectors.env_to_module.flatten_observations import (
+    FlattenObservations,
+)
+from ray.rllib.connectors.env_to_module.mean_std_filter import MeanStdFilter
+from ray.rllib.connectors.env_to_module.prev_actions_prev_rewards import (
+    PrevActionsPrevRewards,
+)
+from ray.rllib.connectors.env_to_module.write_observations_to_episodes import (
+    WriteObservationsToEpisodes,
+)
+
+
+__all__ = [
+    "AddObservationsFromEpisodesToBatch",
+    "AddStatesFromEpisodesToBatch",
+    "AgentToModuleMapping",
+    "BatchIndividualItems",
+    "EnvToModulePipeline",
+    "FlattenObservations",
+    "MeanStdFilter",
+    "NumpyToTensor",
+    "PrevActionsPrevRewards",
+    "WriteObservationsToEpisodes",
+]

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/connectors/env_to_module/flatten_observations.py

@@ -0,0 +1,211 @@
+from typing import Any, Collection, Dict, List, Optional
+
+import gymnasium as gym
+from gymnasium.spaces import Box
+import numpy as np
+import tree  # pip install dm_tree
+
+from ray.rllib.connectors.connector_v2 import ConnectorV2
+from ray.rllib.core.rl_module.rl_module import RLModule
+from ray.rllib.utils.annotations import override
+from ray.rllib.utils.numpy import flatten_inputs_to_1d_tensor
+from ray.rllib.utils.spaces.space_utils import get_base_struct_from_space
+from ray.rllib.utils.typing import AgentID, EpisodeType
+from ray.util.annotations import PublicAPI
+
+
+@PublicAPI(stability="alpha")
+class FlattenObservations(ConnectorV2):
+    """A connector piece that flattens all observation components into a 1D array.
+
+    - Should be used only in env-to-module pipelines.
+    - Works directly on the incoming episodes list and changes the last observation
+    in-place (write the flattened observation back into the episode).
+    - This connector does NOT alter the incoming batch (`data`) when called.
+    - This connector does NOT work in a `LearnerConnectorPipeline` because it requires
+    the incoming episodes to still be ongoing (in progress) as it only alters the
+    latest observation, not all observations in an episode.
+
+    .. testcode::
+
+        import gymnasium as gym
+        import numpy as np
+
+        from ray.rllib.connectors.env_to_module import FlattenObservations
+        from ray.rllib.env.single_agent_episode import SingleAgentEpisode
+        from ray.rllib.utils.test_utils import check
+
+        # Some arbitrarily nested, complex observation space.
+        obs_space = gym.spaces.Dict({
+            "a": gym.spaces.Box(-10.0, 10.0, (), np.float32),
+            "b": gym.spaces.Tuple([
+                gym.spaces.Discrete(2),
+                gym.spaces.Box(-1.0, 1.0, (2, 1), np.float32),
+            ]),
+            "c": gym.spaces.MultiDiscrete([2, 3]),
+        })
+        act_space = gym.spaces.Discrete(2)
+
+        # Two example episodes, both with initial (reset) observations coming from the
+        # above defined observation space.
+        episode_1 = SingleAgentEpisode(
+            observations=[
+                {
+                    "a": np.array(-10.0, np.float32),
+                    "b": (1, np.array([[-1.0], [-1.0]], np.float32)),
+                    "c": np.array([0, 2]),
+                },
+            ],
+        )
+        episode_2 = SingleAgentEpisode(
+            observations=[
+                {
+                    "a": np.array(10.0, np.float32),
+                    "b": (0, np.array([[1.0], [1.0]], np.float32)),
+                    "c": np.array([1, 1]),
+                },
+            ],
+        )
+
+        # Construct our connector piece.
+        connector = FlattenObservations(obs_space, act_space)
+
+        # Call our connector piece with the example data.
+        output_batch = connector(
+            rl_module=None,  # This connector works without an RLModule.
+            batch={},  # This connector does not alter the input batch.
+            episodes=[episode_1, episode_2],
+            explore=True,
+            shared_data={},
+        )
+
+        # The connector does not alter the data and acts as pure pass-through.
+        check(output_batch, {})
+
+        # The connector has flattened each item in the episodes to a 1D tensor.
+        check(
+            episode_1.get_observations(0),
+            #         box()  disc(2).  box(2, 1).  multidisc(2, 3)........
+            np.array([-10.0, 0.0, 1.0, -1.0, -1.0, 1.0, 0.0, 0.0, 0.0, 1.0]),
+        )
+        check(
+            episode_2.get_observations(0),
+            #         box()  disc(2).  box(2, 1).  multidisc(2, 3)........
+            np.array([10.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0]),
+        )
+    """
+
+    @override(ConnectorV2)
+    def recompute_output_observation_space(
+        self,
+        input_observation_space,
+        input_action_space,
+    ) -> gym.Space:
+        self._input_obs_base_struct = get_base_struct_from_space(
+            self.input_observation_space
+        )
+        if self._multi_agent:
+            spaces = {}
+            for agent_id, space in self._input_obs_base_struct.items():
+                if self._agent_ids and agent_id not in self._agent_ids:
+                    spaces[agent_id] = self._input_obs_base_struct[agent_id]
+                else:
+                    sample = flatten_inputs_to_1d_tensor(
+                        tree.map_structure(
+                            lambda s: s.sample(),
+                            self._input_obs_base_struct[agent_id],
+                        ),
+                        self._input_obs_base_struct[agent_id],
+                        batch_axis=False,
+                    )
+                    spaces[agent_id] = Box(
+                        float("-inf"), float("inf"), (len(sample),), np.float32
+                    )
+            return gym.spaces.Dict(spaces)
+        else:
+            sample = flatten_inputs_to_1d_tensor(
+                tree.map_structure(
+                    lambda s: s.sample(),
+                    self._input_obs_base_struct,
+                ),
+                self._input_obs_base_struct,
+                batch_axis=False,
+            )
+            return Box(float("-inf"), float("inf"), (len(sample),), np.float32)
+
+    def __init__(
+        self,
+        input_observation_space: Optional[gym.Space] = None,
+        input_action_space: Optional[gym.Space] = None,
+        *,
+        multi_agent: bool = False,
+        agent_ids: Optional[Collection[AgentID]] = None,
+        **kwargs,
+    ):
+        """Initializes a FlattenObservations instance.
+
+        Args:
+            multi_agent: Whether this connector operates on multi-agent observations,
+                in which case, the top-level of the Dict space (where agent IDs are
+                mapped to individual agents' observation spaces) is left as-is.
+            agent_ids: If multi_agent is True, this argument defines a collection of
+                AgentIDs for which to flatten. AgentIDs not in this collection are
+                ignored.
+                If None, flatten observations for all AgentIDs. None is the default.
+        """
+        self._input_obs_base_struct = None
+        self._multi_agent = multi_agent
+        self._agent_ids = agent_ids
+
+        super().__init__(input_observation_space, input_action_space, **kwargs)
+
+    @override(ConnectorV2)
+    def __call__(
+        self,
+        *,
+        rl_module: RLModule,
+        batch: Dict[str, Any],
+        episodes: List[EpisodeType],
+        explore: Optional[bool] = None,
+        shared_data: Optional[dict] = None,
+        **kwargs,
+    ) -> Any:
+        for sa_episode in self.single_agent_episode_iterator(
+            episodes, agents_that_stepped_only=True
+        ):
+            # Episode is not finalized yet and thus still operates on lists of items.
+            assert not sa_episode.is_finalized
+
+            last_obs = sa_episode.get_observations(-1)
+
+            if self._multi_agent:
+                if (
+                    self._agent_ids is not None
+                    and sa_episode.agent_id not in self._agent_ids
+                ):
+                    flattened_obs = last_obs
+                else:
+                    flattened_obs = flatten_inputs_to_1d_tensor(
+                        inputs=last_obs,
+                        # In the multi-agent case, we need to use the specific agent's
+                        # space struct, not the multi-agent observation space dict.
+                        spaces_struct=self._input_obs_base_struct[sa_episode.agent_id],
+                        # Our items are individual observations (no batch axis present).
+                        batch_axis=False,
+                    )
+            else:
+                flattened_obs = flatten_inputs_to_1d_tensor(
+                    inputs=last_obs,
+                    spaces_struct=self._input_obs_base_struct,
+                    # Our items are individual observations (no batch axis present).
+                    batch_axis=False,
+                )
+
+            # Write new observation directly back into the episode.
+            sa_episode.set_observations(at_indices=-1, new_data=flattened_obs)
+            #  We set the Episode's observation space to ours so that we can safely
+            #  set the last obs to the new value (without causing a space mismatch
+            #  error).
+            sa_episode.observation_space = self.observation_space
+
+        return batch

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/connectors/env_to_module/frame_stacking.py

@@ -0,0 +1,6 @@
+from functools import partial
+
+from ray.rllib.connectors.common.frame_stacking import _FrameStacking
+
+
+FrameStackingEnvToModule = partial(_FrameStacking, as_learner_connector=False)

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/connectors/env_to_module/observation_preprocessor.py

@@ -0,0 +1,80 @@
+import abc
+from typing import Any, Dict, List, Optional
+
+import gymnasium as gym
+
+from ray.rllib.connectors.connector_v2 import ConnectorV2
+from ray.rllib.core.rl_module.rl_module import RLModule
+from ray.rllib.utils.annotations import override
+from ray.rllib.utils.typing import EpisodeType
+from ray.util.annotations import PublicAPI
+
+
+@PublicAPI(stability="alpha")
+class ObservationPreprocessor(ConnectorV2, abc.ABC):
+    """Env-to-module connector performing one preprocessor step on the last observation.
+
+    This is a convenience class that simplifies the writing of few-step preprocessor
+    connectors.
+
+    Users must implement the `preprocess()` method, which simplifies the usual procedure
+    of extracting some data from a list of episodes and adding it to the batch to a mere
+    "old-observation --transform--> return new-observation" step.
+    """
+
+    @override(ConnectorV2)
+    def recompute_output_observation_space(
+        self,
+        input_observation_space: gym.Space,
+        input_action_space: gym.Space,
+    ) -> gym.Space:
+        # Users should override this method only in case the `ObservationPreprocessor`
+        # changes the observation space of the pipeline. In this case, return the new
+        # observation space based on the incoming one (`input_observation_space`).
+        return super().recompute_output_observation_space(
+            input_observation_space, input_action_space
+        )
+
+    @abc.abstractmethod
+    def preprocess(self, observation):
+        """Override to implement the preprocessing logic.
+
+        Args:
+            observation: A single (non-batched) observation item for a single agent to
+                be processed by this connector.
+
+        Returns:
+            The new observation after `observation` has been preprocessed.
+        """
+
+    @override(ConnectorV2)
+    def __call__(
+        self,
+        *,
+        rl_module: RLModule,
+        batch: Dict[str, Any],
+        episodes: List[EpisodeType],
+        explore: Optional[bool] = None,
+        persistent_data: Optional[dict] = None,
+        **kwargs,
+    ) -> Any:
+        # We process and then replace observations inside the episodes directly.
+        # Thus, all following connectors will only see and operate on the already
+        # processed observation (w/o having access anymore to the original
+        # observations).
+        for sa_episode in self.single_agent_episode_iterator(episodes):
+            observation = sa_episode.get_observations(-1)
+
+            # Process the observation and write the new observation back into the
+            # episode.
+            new_observation = self.preprocess(observation=observation)
+            sa_episode.set_observations(at_indices=-1, new_data=new_observation)
+            #  We set the Episode's observation space to ours so that we can safely
+            #  set the last obs to the new value (without causing a space mismatch
+            #  error).
+            sa_episode.observation_space = self.observation_space
+
+        # Leave `batch` as is. RLlib's default connector will automatically
+        # populate the OBS column therein from the episodes' now transformed
+        # observations.
+        return batch

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/connectors/env_to_module/prev_actions_prev_rewards.py

@@ -0,0 +1,168 @@
+from typing import Any, Dict, List, Optional
+
+import gymnasium as gym
+from gymnasium.spaces import Box
+import numpy as np
+
+from ray.rllib.connectors.connector_v2 import ConnectorV2
+from ray.rllib.core.rl_module.rl_module import RLModule
+from ray.rllib.utils.annotations import override
+from ray.rllib.utils.spaces.space_utils import (
+    batch as batch_fn,
+    flatten_to_single_ndarray,
+)
+from ray.rllib.utils.typing import EpisodeType
+from ray.util.annotations import PublicAPI
+
+
+@PublicAPI(stability="alpha")
+class PrevActionsPrevRewards(ConnectorV2):
+    """A connector piece that adds previous rewards and actions to the input obs.
+
+    - Requires Columns.OBS to be already a part of the batch.
+    - This connector makes the assumption that under the Columns.OBS key in batch,
+    there is either a list of individual env observations to be flattened (single-agent
+    case) or a dict mapping (AgentID, ModuleID)-tuples to lists of data items to be
+    flattened (multi-agent case).
+    - Converts Columns.OBS data into a dict (or creates a sub-dict if obs are
+    already a dict), and adds "prev_rewards" and "prev_actions"
+    to this dict. The original observations are stored under the self.ORIG_OBS_KEY in
+    that dict.
+    - If your RLModule does not handle dict inputs, you will have to plug in an
+    `FlattenObservations` connector piece after this one.
+    - Does NOT work in a Learner pipeline as it operates on individual observation
+    items (as opposed to batched/time-ranked data).
+    - Therefore, assumes that the altered (flattened) observations will be written
+    back into the episode by a later connector piece in the env-to-module pipeline
+    (which this piece is part of as well).
+    - Only reads reward- and action information from the given list of Episode objects.
+    - Does NOT write any observations (or other data) to the given Episode objects.
+    """
+
+    ORIG_OBS_KEY = "_orig_obs"
+    PREV_ACTIONS_KEY = "prev_n_actions"
+    PREV_REWARDS_KEY = "prev_n_rewards"
+
+    @override(ConnectorV2)
+    def recompute_output_observation_space(
+        self,
+        input_observation_space: gym.Space,
+        input_action_space: gym.Space,
+    ) -> gym.Space:
+        if self._multi_agent:
+            ret = {}
+            for agent_id, obs_space in input_observation_space.spaces.items():
+                act_space = input_action_space[agent_id]
+                ret[agent_id] = self._convert_individual_space(obs_space, act_space)
+            return gym.spaces.Dict(ret)
+        else:
+            return self._convert_individual_space(
+                input_observation_space, input_action_space
+            )
+
+    def __init__(
+        self,
+        input_observation_space: Optional[gym.Space] = None,
+        input_action_space: Optional[gym.Space] = None,
+        *,
+        multi_agent: bool = False,
+        n_prev_actions: int = 1,
+        n_prev_rewards: int = 1,
+        **kwargs,
+    ):
+        """Initializes a PrevActionsPrevRewards instance.
+
+        Args:
+            multi_agent: Whether this is a connector operating on a multi-agent
+                observation space mapping AgentIDs to individual agents' observations.
+            n_prev_actions: The number of previous actions to include in the output
+                data. Discrete actions are ont-hot'd. If > 1, will concatenate the
+                individual action tensors.
+            n_prev_rewards: The number of previous rewards to include in the output
+                data.
+        """
+        super().__init__(
+            input_observation_space=input_observation_space,
+            input_action_space=input_action_space,
+            **kwargs,
+        )
+
+        self._multi_agent = multi_agent
+        self.n_prev_actions = n_prev_actions
+        self.n_prev_rewards = n_prev_rewards
+
+        # TODO: Move into input_observation_space setter
+        # Thus far, this connector piece only operates on discrete action spaces.
+        # act_spaces = [self.input_action_space]
+        # if self._multi_agent:
+        #    act_spaces = self.input_action_space.spaces.values()
+        # if not all(isinstance(s, gym.spaces.Discrete) for s in act_spaces):
+        #    raise ValueError(
+        #        f"{type(self).__name__} only works on Discrete action spaces "
+        #        f"thus far (or, for multi-agent, on Dict spaces mapping AgentIDs to "
+        #        f"the individual agents' Discrete action spaces)!"
+        #    )
+
+    @override(ConnectorV2)
+    def __call__(
+        self,
+        *,
+        rl_module: RLModule,
+        batch: Optional[Dict[str, Any]],
+        episodes: List[EpisodeType],
+        explore: Optional[bool] = None,
+        shared_data: Optional[dict] = None,
+        **kwargs,
+    ) -> Any:
+        for sa_episode in self.single_agent_episode_iterator(
+            episodes, agents_that_stepped_only=True
+        ):
+            # Episode is not finalized yet and thus still operates on lists of items.
+            assert not sa_episode.is_finalized
+
+            augmented_obs = {self.ORIG_OBS_KEY: sa_episode.get_observations(-1)}
+
+            if self.n_prev_actions:
+                augmented_obs[self.PREV_ACTIONS_KEY] = flatten_to_single_ndarray(
+                    batch_fn(
+                        sa_episode.get_actions(
+                            indices=slice(-self.n_prev_actions, None),
+                            fill=0.0,
+                            one_hot_discrete=True,
+                        )
+                    )
+                )
+
+            if self.n_prev_rewards:
+                augmented_obs[self.PREV_REWARDS_KEY] = np.array(
+                    sa_episode.get_rewards(
+                        indices=slice(-self.n_prev_rewards, None),
+                        fill=0.0,
+                    )
+                )
+
+            # Write new observation directly back into the episode.
+            sa_episode.set_observations(at_indices=-1, new_data=augmented_obs)
+            #  We set the Episode's observation space to ours so that we can safely
+            #  set the last obs to the new value (without causing a space mismatch
+            #  error).
+            sa_episode.observation_space = self.observation_space
+
+        return batch
+
+    def _convert_individual_space(self, obs_space, act_space):
+        return gym.spaces.Dict(
+            {
+                self.ORIG_OBS_KEY: obs_space,
+                # Currently only works for Discrete action spaces.
+                self.PREV_ACTIONS_KEY: Box(
+                    0.0, 1.0, (act_space.n * self.n_prev_actions,), np.float32
+                ),
+                self.PREV_REWARDS_KEY: Box(
+                    float("-inf"),
+                    float("inf"),
+                    (self.n_prev_rewards,),
+                    np.float32,
+                ),
+            }
+        )

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/connectors/env_to_module/write_observations_to_episodes.py

@@ -0,0 +1,131 @@
+from typing import Any, Dict, List, Optional
+
+from ray.rllib.connectors.connector_v2 import ConnectorV2
+from ray.rllib.core.columns import Columns
+from ray.rllib.core.rl_module.rl_module import RLModule
+from ray.rllib.utils.annotations import override
+from ray.rllib.utils.typing import EpisodeType
+from ray.util.annotations import PublicAPI
+
+
+@PublicAPI(stability="alpha")
+class WriteObservationsToEpisodes(ConnectorV2):
+    """Writes the observations from the batch into the running episodes.
+
+    Note: This is one of the default env-to-module ConnectorV2 pieces that are added
+    automatically by RLlib into every env-to-module connector pipelines, unless
+    `config.add_default_connectors_to_env_to_module_pipeline` is set to False.
+
+    The default env-to-module connector pipeline is:
+    [
+        [0 or more user defined ConnectorV2 pieces],
+        AddObservationsFromEpisodesToBatch,
+        AddStatesFromEpisodesToBatch,
+        AgentToModuleMapping,  # only in multi-agent setups!
+        BatchIndividualItems,
+        NumpyToTensor,
+    ]
+
+    This ConnectorV2:
+    - Operates on a batch that already has observations in it and a list of Episode
+    objects.
+    - Writes the observation(s) from the batch to all the given episodes. Thereby
+    the number of observations in the batch must match the length of the list of
+    episodes given.
+    - Does NOT alter any observations (or other data) in the batch.
+    - Can only be used in an EnvToModule pipeline (writing into Episode objects in a
+    Learner pipeline does not make a lot of sense as - after the learner update - the
+    list of episodes is discarded).
+
+    .. testcode::
+
+        import gymnasium as gym
+        import numpy as np
+
+        from ray.rllib.connectors.env_to_module import WriteObservationsToEpisodes
+        from ray.rllib.env.single_agent_episode import SingleAgentEpisode
+        from ray.rllib.utils.test_utils import check
+
+        # Assume we have two episodes (vectorized), then our forward batch will carry
+        # two observation records (batch size = 2).
+        # The connector in this example will write these two (possibly transformed)
+        # observations back into the two respective SingleAgentEpisode objects.
+        batch = {
+            "obs": [np.array([0.0, 1.0], np.float32), np.array([2.0, 3.0], np.float32)],
+        }
+
+        # Our two episodes have one observation each (i.e. the reset one). This is the
+        # one that will be overwritten by the connector in this example.
+        obs_space = gym.spaces.Box(-10.0, 10.0, (2,), np.float32)
+        act_space = gym.spaces.Discrete(2)
+        episodes = [
+            SingleAgentEpisode(
+                observation_space=obs_space,
+                observations=[np.array([-10, -20], np.float32)],
+                len_lookback_buffer=0,
+            ) for _ in range(2)
+        ]
+        # Make sure everything is setup correctly.
+        check(episodes[0].get_observations(0), [-10.0, -20.0])
+        check(episodes[1].get_observations(-1), [-10.0, -20.0])
+
+        # Create our connector piece.
+        connector = WriteObservationsToEpisodes(obs_space, act_space)
+
+        # Call the connector (and thereby write the transformed observations back
+        # into the episodes).
+        output_batch = connector(
+            rl_module=None,  # This particular connector works without an RLModule.
+            batch=batch,
+            episodes=episodes,
+            explore=True,
+            shared_data={},
+        )
+
+        # The connector does NOT change the data batch being passed through.
+        check(output_batch, batch)
+
+        # However, the connector has overwritten the last observations in the episodes.
+        check(episodes[0].get_observations(-1), [0.0, 1.0])
+        check(episodes[1].get_observations(0), [2.0, 3.0])
+    """
+
+    @override(ConnectorV2)
+    def __call__(
+        self,
+        *,
+        rl_module: RLModule,
+        batch: Optional[Dict[str, Any]],
+        episodes: List[EpisodeType],
+        explore: Optional[bool] = None,
+        shared_data: Optional[dict] = None,
+        **kwargs,
+    ) -> Any:
+        observations = batch.get(Columns.OBS)
+
+        if observations is None:
+            raise ValueError(
+                f"`batch` must already have a column named {Columns.OBS} in it "
+                f"for this connector to work!"
+            )
+
+        # Note that the following loop works with multi-agent as well as with
+        # single-agent episode, as long as the following conditions are met (these
+        # will be validated by `self.single_agent_episode_iterator()`):
+        # - Per single agent episode, one observation item is expected to exist in
+        # `data`, either in a list directly under the "obs" key OR for multi-agent:
+        # in a list sitting under a key `(agent_id, module_id)` of a dict sitting
+        # under the "obs" key.
+        for sa_episode, obs in self.single_agent_episode_iterator(
+            episodes=episodes, zip_with_batch_column=observations
+        ):
+            # Make sure episodes are NOT finalized yet (we are expecting to run in an
+            # env-to-module pipeline).
+            assert not sa_episode.is_finalized
+            # Write new information into the episode.
+            sa_episode.set_observations(at_indices=-1, new_data=obs)
+            # Change the observation space of the sa_episode.
+            sa_episode.observation_space = self.observation_space
+
+        # Return the unchanged `batch`.
+        return batch

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/connectors/learner/add_columns_from_episodes_to_train_batch.py

@@ -0,0 +1,165 @@
+from typing import Any, Dict, List, Optional
+
+from ray.rllib.connectors.connector_v2 import ConnectorV2
+from ray.rllib.core.columns import Columns
+from ray.rllib.core.rl_module.rl_module import RLModule
+from ray.rllib.utils.annotations import override
+from ray.rllib.utils.typing import EpisodeType
+from ray.util.annotations import PublicAPI
+
+
+@PublicAPI(stability="alpha")
+class AddColumnsFromEpisodesToTrainBatch(ConnectorV2):
+    """Adds infos/actions/rewards/terminateds/... to train batch.
+
+    Note: This is one of the default Learner ConnectorV2 pieces that are added
+    automatically by RLlib into every Learner connector pipeline, unless
+    `config.add_default_connectors_to_learner_pipeline` is set to False.
+
+    The default Learner connector pipeline is:
+    [
+        [0 or more user defined ConnectorV2 pieces],
+        AddObservationsFromEpisodesToBatch,
+        AddColumnsFromEpisodesToTrainBatch,
+        AddStatesFromEpisodesToBatch,
+        AgentToModuleMapping,  # only in multi-agent setups!
+        BatchIndividualItems,
+        NumpyToTensor,
+    ]
+
+    Does NOT add observations to train batch (these should have already been added
+    by another ConnectorV2 piece: `AddObservationsToTrainBatch` in the same pipeline).
+
+    If provided with `episodes` data, this connector piece makes sure that the final
+    train batch going into the RLModule for updating (`forward_train()` call) contains
+    at the minimum:
+    - Observations: From all episodes under the Columns.OBS key.
+    - Actions, rewards, terminal/truncation flags: From all episodes under the
+    respective keys.
+    - All data inside the episodes' `extra_model_outs` property, e.g. action logp and
+    action probs under the respective keys.
+    - Internal states: These will NOT be added to the batch by this connector piece
+    as this functionality is handled by a different default connector piece:
+    `AddStatesFromEpisodesToBatch`.
+
+    If the user wants to customize their own data under the given keys (e.g. obs,
+    actions, ...), they can extract from the episodes or recompute from `data`
+    their own data and store it in `data` under those keys. In this case, the default
+    connector will not change the data under these keys and simply act as a
+    pass-through.
+    """
+
+    @override(ConnectorV2)
+    def __call__(
+        self,
+        *,
+        rl_module: RLModule,
+        batch: Optional[Dict[str, Any]],
+        episodes: List[EpisodeType],
+        explore: Optional[bool] = None,
+        shared_data: Optional[dict] = None,
+        **kwargs,
+    ) -> Any:
+        # Infos.
+        if Columns.INFOS not in batch:
+            for sa_episode in self.single_agent_episode_iterator(
+                episodes,
+                agents_that_stepped_only=False,
+            ):
+                self.add_n_batch_items(
+                    batch,
+                    Columns.INFOS,
+                    items_to_add=sa_episode.get_infos(slice(0, len(sa_episode))),
+                    num_items=len(sa_episode),
+                    single_agent_episode=sa_episode,
+                )
+
+        # Actions.
+        if Columns.ACTIONS not in batch:
+            for sa_episode in self.single_agent_episode_iterator(
+                episodes,
+                agents_that_stepped_only=False,
+            ):
+                self.add_n_batch_items(
+                    batch,
+                    Columns.ACTIONS,
+                    items_to_add=[
+                        sa_episode.get_actions(indices=ts)
+                        for ts in range(len(sa_episode))
+                    ],
+                    num_items=len(sa_episode),
+                    single_agent_episode=sa_episode,
+                )
+        # Rewards.
+        if Columns.REWARDS not in batch:
+            for sa_episode in self.single_agent_episode_iterator(
+                episodes,
+                agents_that_stepped_only=False,
+            ):
+                self.add_n_batch_items(
+                    batch,
+                    Columns.REWARDS,
+                    items_to_add=[
+                        sa_episode.get_rewards(indices=ts)
+                        for ts in range(len(sa_episode))
+                    ],
+                    num_items=len(sa_episode),
+                    single_agent_episode=sa_episode,
+                )
+        # Terminateds.
+        if Columns.TERMINATEDS not in batch:
+            for sa_episode in self.single_agent_episode_iterator(
+                episodes,
+                agents_that_stepped_only=False,
+            ):
+                self.add_n_batch_items(
+                    batch,
+                    Columns.TERMINATEDS,
+                    items_to_add=(
+                        [False] * (len(sa_episode) - 1) + [sa_episode.is_terminated]
+                        if len(sa_episode) > 0
+                        else []
+                    ),
+                    num_items=len(sa_episode),
+                    single_agent_episode=sa_episode,
+                )
+        # Truncateds.
+        if Columns.TRUNCATEDS not in batch:
+            for sa_episode in self.single_agent_episode_iterator(
+                episodes,
+                agents_that_stepped_only=False,
+            ):
+                self.add_n_batch_items(
+                    batch,
+                    Columns.TRUNCATEDS,
+                    items_to_add=(
+                        [False] * (len(sa_episode) - 1) + [sa_episode.is_truncated]
+                        if len(sa_episode) > 0
+                        else []
+                    ),
+                    num_items=len(sa_episode),
+                    single_agent_episode=sa_episode,
+                )
+        # Extra model outputs (except for STATE_OUT, which will be handled by another
+        # default connector piece). Also, like with all the fields above, skip
+        # those that the user already seemed to have populated via custom connector
+        # pieces.
+        skip_columns = set(batch.keys()) | {Columns.STATE_IN, Columns.STATE_OUT}
+        for sa_episode in self.single_agent_episode_iterator(
+            episodes,
+            agents_that_stepped_only=False,
+        ):
+            for column in sa_episode.extra_model_outputs.keys():
+                if column not in skip_columns:
+                    self.add_n_batch_items(
+                        batch,
+                        column,
+                        items_to_add=[
+                            sa_episode.get_extra_model_outputs(key=column, indices=ts)
+                            for ts in range(len(sa_episode))
+                        ],
+                        num_items=len(sa_episode),
+                        single_agent_episode=sa_episode,
+                    )
+
+        return batch

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/connectors/learner/add_next_observations_from_episodes_to_train_batch.py

@@ -0,0 +1,103 @@
+from typing import Any, Dict, List, Optional
+
+from ray.rllib.core.columns import Columns
+from ray.rllib.connectors.connector_v2 import ConnectorV2
+from ray.rllib.core.rl_module.rl_module import RLModule
+from ray.rllib.utils.annotations import override
+from ray.rllib.utils.typing import EpisodeType
+from ray.util.annotations import PublicAPI
+
+
+@PublicAPI(stability="alpha")
+class AddNextObservationsFromEpisodesToTrainBatch(ConnectorV2):
+    """Adds the NEXT_OBS column with the correct episode observations to train batch.
+
+    - Operates on a list of Episode objects.
+    - Gets all observation(s) from all the given episodes (except the very first ones)
+    and adds them to the batch under construction in the NEXT_OBS column (as a list of
+    individual observations).
+    - Does NOT alter any observations (or other data) in the given episodes.
+    - Can be used in Learner connector pipelines.
+
+    .. testcode::
+
+        import gymnasium as gym
+        import numpy as np
+
+        from ray.rllib.connectors.learner import (
+            AddNextObservationsFromEpisodesToTrainBatch
+        )
+        from ray.rllib.core.columns import Columns
+        from ray.rllib.env.single_agent_episode import SingleAgentEpisode
+        from ray.rllib.utils.test_utils import check
+
+        # Create two dummy SingleAgentEpisodes, each containing 3 observations,
+        # 2 actions and 2 rewards (both episodes are length=2).
+        obs_space = gym.spaces.Box(-1.0, 1.0, (2,), np.float32)
+        act_space = gym.spaces.Discrete(2)
+
+        episodes = [SingleAgentEpisode(
+            observations=[obs_space.sample(), obs_space.sample(), obs_space.sample()],
+            actions=[act_space.sample(), act_space.sample()],
+            rewards=[1.0, 2.0],
+            len_lookback_buffer=0,
+        ) for _ in range(2)]
+        eps_1_next_obses = episodes[0].get_observations([1, 2])
+        eps_2_next_obses = episodes[1].get_observations([1, 2])
+        print(f"1st Episode's next obses are {eps_1_next_obses}")
+        print(f"2nd Episode's next obses are {eps_2_next_obses}")
+
+        # Create an instance of this class.
+        connector = AddNextObservationsFromEpisodesToTrainBatch()
+
+        # Call the connector with the two created episodes.
+        # Note that this particular connector works without an RLModule, so we
+        # simplify here for the sake of this example.
+        output_data = connector(
+            rl_module=None,
+            batch={},
+            episodes=episodes,
+            explore=True,
+            shared_data={},
+        )
+        # The output data should now contain the last observations of both episodes,
+        # in a "per-episode organized" fashion.
+        check(
+            output_data,
+            {
+                Columns.NEXT_OBS: {
+                    (episodes[0].id_,): eps_1_next_obses,
+                    (episodes[1].id_,): eps_2_next_obses,
+                },
+            },
+        )
+    """
+
+    @override(ConnectorV2)
+    def __call__(
+        self,
+        *,
+        rl_module: RLModule,
+        batch: Dict[str, Any],
+        episodes: List[EpisodeType],
+        explore: Optional[bool] = None,
+        shared_data: Optional[dict] = None,
+        **kwargs,
+    ) -> Any:
+        # If "obs" already in `batch`, early out.
+        if Columns.NEXT_OBS in batch:
+            return batch
+
+        for sa_episode in self.single_agent_episode_iterator(
+            # This is a Learner-only connector -> Get all episodes (for train batch).
+            episodes,
+            agents_that_stepped_only=False,
+        ):
+            self.add_n_batch_items(
+                batch,
+                Columns.NEXT_OBS,
+                items_to_add=sa_episode.get_observations(slice(1, len(sa_episode) + 1)),
+                num_items=len(sa_episode),
+                single_agent_episode=sa_episode,
+            )
+        return batch

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/connectors/learner/add_one_ts_to_episodes_and_truncate.py

@@ -0,0 +1,168 @@
+from typing import Any, Dict, List, Optional
+
+from ray.rllib.connectors.connector_v2 import ConnectorV2
+from ray.rllib.core.columns import Columns
+from ray.rllib.core.rl_module.rl_module import RLModule
+from ray.rllib.env.multi_agent_episode import MultiAgentEpisode
+from ray.rllib.utils.annotations import override
+from ray.rllib.utils.postprocessing.episodes import add_one_ts_to_episodes_and_truncate
+from ray.rllib.utils.typing import EpisodeType
+from ray.util.annotations import PublicAPI
+
+
+@PublicAPI(stability="alpha")
+class AddOneTsToEpisodesAndTruncate(ConnectorV2):
+    """Adds an artificial timestep to all incoming episodes at the end.
+
+    In detail: The last observations, infos, actions, and all `extra_model_outputs`
+    will be duplicated and appended to each episode's data. An extra 0.0 reward
+    will be appended to the episode's rewards. The episode's timestep will be
+    increased by 1. Also, adds the truncated=True flag to each episode if the
+    episode is not already done (terminated or truncated).
+
+    Useful for value function bootstrapping, where it is required to compute a
+    forward pass for the very last timestep within the episode,
+    i.e. using the following input dict: {
+      obs=[final obs],
+      state=[final state output],
+      prev. reward=[final reward],
+      etc..
+    }
+
+    .. testcode::
+
+        from ray.rllib.connectors.learner import AddOneTsToEpisodesAndTruncate
+        from ray.rllib.env.single_agent_episode import SingleAgentEpisode
+        from ray.rllib.utils.test_utils import check
+
+        # Create 2 episodes (both to be extended by one timestep).
+        episode1 = SingleAgentEpisode(
+            observations=[0, 1, 2],
+            actions=[0, 1],
+            rewards=[0.0, 1.0],
+            terminated=False,
+            truncated=False,
+            len_lookback_buffer=0,
+        ).finalize()
+        check(len(episode1), 2)
+        check(episode1.is_truncated, False)
+
+        episode2 = SingleAgentEpisode(
+            observations=[0, 1, 2, 3, 4, 5],
+            actions=[0, 1, 2, 3, 4],
+            rewards=[0.0, 1.0, 2.0, 3.0, 4.0],
+            terminated=True,  # a terminated episode
+            truncated=False,
+            len_lookback_buffer=0,
+        ).finalize()
+        check(len(episode2), 5)
+        check(episode2.is_truncated, False)
+        check(episode2.is_terminated, True)
+
+        # Create an instance of this class.
+        connector = AddOneTsToEpisodesAndTruncate()
+
+        # Call the connector.
+        shared_data = {}
+        _ = connector(
+            rl_module=None,  # Connector used here does not require RLModule.
+            batch={},
+            episodes=[episode1, episode2],
+            shared_data=shared_data,
+        )
+        # Check on the episodes. Both of them should now be 1 timestep longer.
+        check(len(episode1), 3)
+        check(episode1.is_truncated, True)
+        check(len(episode2), 6)
+        check(episode2.is_truncated, False)
+        check(episode2.is_terminated, True)
+    """
+
+    @override(ConnectorV2)
+    def __call__(
+        self,
+        *,
+        rl_module: RLModule,
+        batch: Dict[str, Any],
+        episodes: List[EpisodeType],
+        explore: Optional[bool] = None,
+        shared_data: Optional[dict] = None,
+        **kwargs,
+    ) -> Any:
+        # Build the loss mask to make sure the extra added timesteps do not influence
+        # the final loss and fix the terminateds and truncateds in the batch.
+
+        # For proper v-trace execution, the rules must be as follows:
+        # Legend:
+        # T: terminal=True
+        # R: truncated=True
+        # B0: bootstrap with value 0 (also: terminal=True)
+        # Bx: bootstrap with some vf-computed value (also: terminal=True)
+
+        # batch: - - - - - - - T B0- - - - - R Bx- - - - R Bx
+        # mask : t t t t t t t t f t t t t t t f t t t t t f
+
+        # TODO (sven): Same situation as in TODO below, but for multi-agent episode.
+        #  Maybe add a dedicated connector piece for this task?
+        # We extend the MultiAgentEpisode's ID by a running number here to make sure
+        # we treat each MAEpisode chunk as separate (for potentially upcoming v-trace
+        # and LSTM zero-padding) and don't mix data from different chunks.
+        if isinstance(episodes[0], MultiAgentEpisode):
+            for i, ma_episode in enumerate(episodes):
+                ma_episode.id_ += "_" + str(i)
+                # Also change the underlying single-agent episode's
+                # `multi_agent_episode_id` properties.
+                for sa_episode in ma_episode.agent_episodes.values():
+                    sa_episode.multi_agent_episode_id = ma_episode.id_
+
+        for i, sa_episode in enumerate(
+            self.single_agent_episode_iterator(episodes, agents_that_stepped_only=False)
+        ):
+            # TODO (sven): This is a little bit of a hack: By extending the Episode's
+            #  ID, we make sure that each episode chunk in `episodes` is treated as a
+            #  separate episode in the `self.add_n_batch_items` below. Some algos (e.g.
+            #  APPO) may have >1 episode chunks from the same episode (same ID) in the
+            #  training data, thus leading to a malformatted batch in case of
+            #  RNN-triggered zero-padding of the train batch.
+            #  For example, if e1 (id=a len=4) and e2 (id=a len=5) are two chunks of the
+            #  same episode in `episodes`, the resulting batch would have an additional
+            #  timestep in the middle of the episode's "row":
+            #  {  "obs": {
+            #    ("a", <- eps ID): [0, 1, 2, 3 <- len=4, [additional 1 ts (bad)],
+            #                       0, 1, 2, 3, 4 <- len=5, [additional 1 ts]]
+            #  }}
+            sa_episode.id_ += "_" + str(i)
+
+            len_ = len(sa_episode)
+
+            # Extend all episodes by one ts.
+            add_one_ts_to_episodes_and_truncate([sa_episode])
+
+            loss_mask = [True for _ in range(len_)] + [False]
+            self.add_n_batch_items(
+                batch,
+                Columns.LOSS_MASK,
+                loss_mask,
+                len_ + 1,
+                sa_episode,
+            )
+
+            terminateds = (
+                [False for _ in range(len_ - 1)]
+                + [bool(sa_episode.is_terminated)]
+                + [True]  # extra timestep
+            )
+            self.add_n_batch_items(
+                batch,
+                Columns.TERMINATEDS,
+                terminateds,
+                len_ + 1,
+                sa_episode,
+            )
+
+        # Signal to following connector pieces that the loss-mask which masks out
+        # invalid episode ts (for the extra added ts at the end) has already been
+        # added to `data`.
+        shared_data["_added_loss_mask_for_valid_episode_ts"] = True
+
+        return batch

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/connectors/learner/frame_stacking.py

@@ -0,0 +1,6 @@
+from functools import partial
+
+from ray.rllib.connectors.common.frame_stacking import _FrameStacking
+
+
+FrameStackingLearner = partial(_FrameStacking, as_learner_connector=True)

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/connectors/learner/learner_connector_pipeline.py

@@ -0,0 +1,7 @@
+from ray.rllib.connectors.connector_pipeline_v2 import ConnectorPipelineV2
+from ray.util.annotations import PublicAPI
+
+
+@PublicAPI(stability="alpha")
+class LearnerConnectorPipeline(ConnectorPipelineV2):
+    pass

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/connectors/module_to_env/remove_single_ts_time_rank_from_batch.py

@@ -0,0 +1,70 @@
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+import tree  # pip install dm_tree
+
+from ray.rllib.connectors.connector_v2 import ConnectorV2
+from ray.rllib.core.columns import Columns
+from ray.rllib.core.rl_module.rl_module import RLModule
+from ray.rllib.utils.annotations import override
+from ray.rllib.utils.typing import EpisodeType
+from ray.util.annotations import PublicAPI
+
+
+@PublicAPI(stability="alpha")
+class RemoveSingleTsTimeRankFromBatch(ConnectorV2):
+    """
+    Note: This is one of the default module-to-env ConnectorV2 pieces that
+    are added automatically by RLlib into every module-to-env connector pipeline,
+    unless `config.add_default_connectors_to_module_to_env_pipeline` is set to
+    False.
+
+    The default module-to-env connector pipeline is:
+    [
+        GetActions,
+        TensorToNumpy,
+        UnBatchToIndividualItems,
+        ModuleToAgentUnmapping,  # only in multi-agent setups!
+        RemoveSingleTsTimeRankFromBatch,
+
+        [0 or more user defined ConnectorV2 pieces],
+
+        NormalizeAndClipActions,
+        ListifyDataForVectorEnv,
+    ]
+
+    """
+
+    @override(ConnectorV2)
+    def __call__(
+        self,
+        *,
+        rl_module: RLModule,
+        batch: Optional[Dict[str, Any]],
+        episodes: List[EpisodeType],
+        explore: Optional[bool] = None,
+        shared_data: Optional[dict] = None,
+        **kwargs,
+    ) -> Any:
+        # If single ts time-rank had not been added, early out.
+        if shared_data is None or not shared_data.get("_added_single_ts_time_rank"):
+            return batch
+
+        def _remove_single_ts(item, eps_id, aid, mid):
+            # Only remove time-rank for modules that are statefule (only for those has
+            # a timerank been added).
+            if mid is None or rl_module[mid].is_stateful():
+                return tree.map_structure(lambda s: np.squeeze(s, axis=0), item)
+            return item
+
+        for column, column_data in batch.copy().items():
+            # Skip state_out (doesn't have a time rank).
+            if column == Columns.STATE_OUT:
+                continue
+            self.foreach_batch_item_change_in_place(
+                batch,
+                column=column,
+                func=_remove_single_ts,
+            )
+
+        return batch

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/schedules/exponential_schedule.py

@@ -0,0 +1,50 @@
+from typing import Optional
+
+from ray.rllib.utils.annotations import OldAPIStack, override
+from ray.rllib.utils.framework import try_import_torch
+from ray.rllib.utils.schedules.schedule import Schedule
+from ray.rllib.utils.typing import TensorType
+
+torch, _ = try_import_torch()
+
+
+@OldAPIStack
+class ExponentialSchedule(Schedule):
+    """Exponential decay schedule from `initial_p` to `final_p`.
+
+    Reduces output over `schedule_timesteps`. After this many time steps
+    always returns `final_p`.
+    """
+
+    def __init__(
+        self,
+        schedule_timesteps: int,
+        framework: Optional[str] = None,
+        initial_p: float = 1.0,
+        decay_rate: float = 0.1,
+    ):
+        """Initializes a ExponentialSchedule instance.
+
+        Args:
+            schedule_timesteps: Number of time steps for which to
+                linearly anneal initial_p to final_p.
+            framework: The framework descriptor string, e.g. "tf",
+                "torch", or None.
+            initial_p: Initial output value.
+            decay_rate: The percentage of the original value after
+                100% of the time has been reached (see formula above).
+                >0.0: The smaller the decay-rate, the stronger the decay.
+                1.0: No decay at all.
+        """
+        super().__init__(framework=framework)
+        assert schedule_timesteps > 0
+        self.schedule_timesteps = schedule_timesteps
+        self.initial_p = initial_p
+        self.decay_rate = decay_rate
+
+    @override(Schedule)
+    def _value(self, t: TensorType) -> TensorType:
+        """Returns the result of: initial_p * decay_rate ** (`t`/t_max)."""
+        if self.framework == "torch" and torch and isinstance(t, torch.Tensor):
+            t = t.float()
+        return self.initial_p * self.decay_rate ** (t / self.schedule_timesteps)

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/schedules/polynomial_schedule.py

@@ -0,0 +1,67 @@
+from typing import Optional
+
+from ray.rllib.utils.annotations import OldAPIStack, override
+from ray.rllib.utils.framework import try_import_tf, try_import_torch
+from ray.rllib.utils.schedules.schedule import Schedule
+from ray.rllib.utils.typing import TensorType
+
+tf1, tf, tfv = try_import_tf()
+torch, _ = try_import_torch()
+
+
+@OldAPIStack
+class PolynomialSchedule(Schedule):
+    """Polynomial interpolation between `initial_p` and `final_p`.
+
+    Over `schedule_timesteps`. After this many time steps, always returns
+    `final_p`.
+    """
+
+    def __init__(
+        self,
+        schedule_timesteps: int,
+        final_p: float,
+        framework: Optional[str],
+        initial_p: float = 1.0,
+        power: float = 2.0,
+    ):
+        """Initializes a PolynomialSchedule instance.
+
+        Args:
+            schedule_timesteps: Number of time steps for which to
+                linearly anneal initial_p to final_p
+            final_p: Final output value.
+            framework: The framework descriptor string, e.g. "tf",
+                "torch", or None.
+            initial_p: Initial output value.
+            power: The exponent to use (default: quadratic).
+        """
+        super().__init__(framework=framework)
+        assert schedule_timesteps > 0
+        self.schedule_timesteps = schedule_timesteps
+        self.final_p = final_p
+        self.initial_p = initial_p
+        self.power = power
+
+    @override(Schedule)
+    def _value(self, t: TensorType) -> TensorType:
+        """Returns the result of:
+        final_p + (initial_p - final_p) * (1 - `t`/t_max) ** power
+        """
+        if self.framework == "torch" and torch and isinstance(t, torch.Tensor):
+            t = t.float()
+        t = min(t, self.schedule_timesteps)
+        return (
+            self.final_p
+            + (self.initial_p - self.final_p)
+            * (1.0 - (t / self.schedule_timesteps)) ** self.power
+        )
+
+    @override(Schedule)
+    def _tf_value_op(self, t: TensorType) -> TensorType:
+        t = tf.math.minimum(t, self.schedule_timesteps)
+        return (
+            self.final_p
+            + (self.initial_p - self.final_p)
+            * (1.0 - (t / self.schedule_timesteps)) ** self.power
+        )

infer_4_37_2/lib/python3.10/site-packages/ray/rllib/utils/schedules/scheduler.py

@@ -0,0 +1,167 @@
+from typing import Optional
+
+from ray.rllib.utils.framework import try_import_tf, try_import_torch
+from ray.rllib.utils.schedules.piecewise_schedule import PiecewiseSchedule
+from ray.rllib.utils.typing import LearningRateOrSchedule, TensorType
+from ray.util.annotations import DeveloperAPI
+
+
+_, tf, _ = try_import_tf()
+torch, _ = try_import_torch()
+
+
+@DeveloperAPI
+class Scheduler:
+    """Class to manage a scheduled (framework-dependent) tensor variable.
+
+    Uses the PiecewiseSchedule (for maximum configuration flexibility)
+    """
+
+    def __init__(
+        self,
+        *,
+        fixed_value_or_schedule: LearningRateOrSchedule,
+        framework: str = "torch",
+        device: Optional[str] = None,
+    ):
+        """Initializes a Scheduler instance.
+
+        Args:
+            fixed_value_or_schedule: A fixed, constant value (in case no schedule should
+                be used) or a schedule configuration in the format of
+                [[timestep, value], [timestep, value], ...]
+                Intermediary timesteps will be assigned to linerarly interpolated
+                values. A schedule config's first entry must
+                start with timestep 0, i.e.: [[0, initial_value], [...]].
+            framework: The framework string, for which to create the tensor variable
+                that hold the current value. This is the variable that can be used in
+                the graph, e.g. in a loss function.
+            device: Optional device (for torch) to place the tensor variable on.
+        """
+        self.framework = framework
+        self.device = device
+        self.use_schedule = isinstance(fixed_value_or_schedule, (list, tuple))
+
+        if self.use_schedule:
+            # Custom schedule, based on list of
+            # ([ts], [value to be reached by ts])-tuples.
+            self._schedule = PiecewiseSchedule(
+                fixed_value_or_schedule,
+                outside_value=fixed_value_or_schedule[-1][-1],
+                framework=None,
+            )
+            # As initial tensor valie, use the first timestep's (must be 0) value.
+            self._curr_value = self._create_tensor_variable(
+                initial_value=fixed_value_or_schedule[0][1]
+            )
+
+        # If no schedule, pin (fix) given value.
+        else:
+            self._curr_value = fixed_value_or_schedule
+
+    @staticmethod
+    def validate(
+        *,
+        fixed_value_or_schedule: LearningRateOrSchedule,
+        setting_name: str,
+        description: str,
+    ) -> None:
+        """Performs checking of a certain schedule configuration.
+
+        The first entry in `value_or_schedule` (if it's not a fixed value) must have a
+        timestep of 0.
+
+        Args:
+            fixed_value_or_schedule: A fixed, constant value (in case no schedule should
+                be used) or a schedule configuration in the format of
+                [[timestep, value], [timestep, value], ...]
+                Intermediary timesteps will be assigned to linerarly interpolated
+                values. A schedule config's first entry must
+                start with timestep 0, i.e.: [[0, initial_value], [...]].
+            setting_name: The property name of the schedule setting (within a config),
+                e.g. `lr` or `entropy_coeff`.
+            description: A full text description of the property that's being scheduled,
+                e.g. `learning rate`.
+
+        Raises:
+            ValueError: In case, errors are found in the schedule's format.
+        """
+        if (
+            isinstance(fixed_value_or_schedule, (int, float))
+            or fixed_value_or_schedule is None
+        ):
+            return
+
+        if not isinstance(fixed_value_or_schedule, (list, tuple)) or (
+            len(fixed_value_or_schedule) < 2
+        ):
+            raise ValueError(
+                f"Invalid `{setting_name}` ({fixed_value_or_schedule}) specified! "
+                f"Must be a list of at least 2 tuples, each of the form "
+                f"(`timestep`, `{description} to reach`), e.g. "
+                "`[(0, 0.001), (1e6, 0.0001), (2e6, 0.00005)]`."
+            )
+        elif fixed_value_or_schedule[0][0] != 0:
+            raise ValueError(
+                f"When providing a `{setting_name}`, the first timestep must be 0 "
+                f"and the corresponding lr value is the initial {description}! You "
+                f"provided ts={fixed_value_or_schedule[0][0]} {description}="
+                f"{fixed_value_or_schedule[0][1]}."
+            )
+
+    def get_current_value(self) -> TensorType:
+        """Returns the current value (as a tensor variable).
+
+        This method should be used in loss functions of other (in-graph) places
+        where the current value is needed.
+
+        Returns:
+            The tensor variable (holding the current value to be used).
+        """
+        return self._curr_value
+
+    def update(self, timestep: int) -> float:
+        """Updates the underlying (framework specific) tensor variable.
+
+        In case of a fixed value, this method does nothing and only returns the fixed
+        value as-is.
+
+        Args:
+            timestep: The current timestep that the update might depend on.
+
+        Returns:
+            The current value of the tensor variable as a python float.
+        """
+        if self.use_schedule:
+            python_value = self._schedule.value(t=timestep)
+            if self.framework == "torch":
+                self._curr_value.data = torch.tensor(python_value)
+            else:
+                self._curr_value.assign(python_value)
+        else:
+            python_value = self._curr_value
+
+        return python_value
+
+    def _create_tensor_variable(self, initial_value: float) -> TensorType:
+        """Creates a framework-specific tensor variable to be scheduled.
+
+        Args:
+            initial_value: The initial (float) value for the variable to hold.
+
+        Returns:
+            The created framework-specific tensor variable.
+        """
+        if self.framework == "torch":
+            return torch.tensor(
+                initial_value,
+                requires_grad=False,
+                dtype=torch.float32,
+                device=self.device,
+            )
+        else:
+            return tf.Variable(
+                initial_value,
+                trainable=False,
+                dtype=tf.float32,
+            )

janus/lib/python3.10/_compat_pickle.py

@@ -0,0 +1,251 @@
+# This module is used to map the old Python 2 names to the new names used in
+# Python 3 for the pickle module.  This needed to make pickle streams
+# generated with Python 2 loadable by Python 3.
+
+# This is a copy of lib2to3.fixes.fix_imports.MAPPING.  We cannot import
+# lib2to3 and use the mapping defined there, because lib2to3 uses pickle.
+# Thus, this could cause the module to be imported recursively.
+IMPORT_MAPPING = {
+    '__builtin__' : 'builtins',
+    'copy_reg': 'copyreg',
+    'Queue': 'queue',
+    'SocketServer': 'socketserver',
+    'ConfigParser': 'configparser',
+    'repr': 'reprlib',
+    'tkFileDialog': 'tkinter.filedialog',
+    'tkSimpleDialog': 'tkinter.simpledialog',
+    'tkColorChooser': 'tkinter.colorchooser',
+    'tkCommonDialog': 'tkinter.commondialog',
+    'Dialog': 'tkinter.dialog',
+    'Tkdnd': 'tkinter.dnd',
+    'tkFont': 'tkinter.font',
+    'tkMessageBox': 'tkinter.messagebox',
+    'ScrolledText': 'tkinter.scrolledtext',
+    'Tkconstants': 'tkinter.constants',
+    'Tix': 'tkinter.tix',
+    'ttk': 'tkinter.ttk',
+    'Tkinter': 'tkinter',
+    'markupbase': '_markupbase',
+    '_winreg': 'winreg',
+    'thread': '_thread',
+    'dummy_thread': '_dummy_thread',
+    'dbhash': 'dbm.bsd',
+    'dumbdbm': 'dbm.dumb',
+    'dbm': 'dbm.ndbm',
+    'gdbm': 'dbm.gnu',
+    'xmlrpclib': 'xmlrpc.client',
+    'SimpleXMLRPCServer': 'xmlrpc.server',
+    'httplib': 'http.client',
+    'htmlentitydefs' : 'html.entities',
+    'HTMLParser' : 'html.parser',
+    'Cookie': 'http.cookies',
+    'cookielib': 'http.cookiejar',
+    'BaseHTTPServer': 'http.server',
+    'test.test_support': 'test.support',
+    'commands': 'subprocess',
+    'urlparse' : 'urllib.parse',
+    'robotparser' : 'urllib.robotparser',
+    'urllib2': 'urllib.request',
+    'anydbm': 'dbm',
+    '_abcoll' : 'collections.abc',
+}
+
+
+# This contains rename rules that are easy to handle.  We ignore the more
+# complex stuff (e.g. mapping the names in the urllib and types modules).
+# These rules should be run before import names are fixed.
+NAME_MAPPING = {
+    ('__builtin__', 'xrange'):     ('builtins', 'range'),
+    ('__builtin__', 'reduce'):     ('functools', 'reduce'),
+    ('__builtin__', 'intern'):     ('sys', 'intern'),
+    ('__builtin__', 'unichr'):     ('builtins', 'chr'),
+    ('__builtin__', 'unicode'):    ('builtins', 'str'),
+    ('__builtin__', 'long'):       ('builtins', 'int'),
+    ('itertools', 'izip'):         ('builtins', 'zip'),
+    ('itertools', 'imap'):         ('builtins', 'map'),
+    ('itertools', 'ifilter'):      ('builtins', 'filter'),
+    ('itertools', 'ifilterfalse'): ('itertools', 'filterfalse'),
+    ('itertools', 'izip_longest'): ('itertools', 'zip_longest'),
+    ('UserDict', 'IterableUserDict'): ('collections', 'UserDict'),
+    ('UserList', 'UserList'): ('collections', 'UserList'),
+    ('UserString', 'UserString'): ('collections', 'UserString'),
+    ('whichdb', 'whichdb'): ('dbm', 'whichdb'),
+    ('_socket', 'fromfd'): ('socket', 'fromfd'),
+    ('_multiprocessing', 'Connection'): ('multiprocessing.connection', 'Connection'),
+    ('multiprocessing.process', 'Process'): ('multiprocessing.context', 'Process'),
+    ('multiprocessing.forking', 'Popen'): ('multiprocessing.popen_fork', 'Popen'),
+    ('urllib', 'ContentTooShortError'): ('urllib.error', 'ContentTooShortError'),
+    ('urllib', 'getproxies'): ('urllib.request', 'getproxies'),
+    ('urllib', 'pathname2url'): ('urllib.request', 'pathname2url'),
+    ('urllib', 'quote_plus'): ('urllib.parse', 'quote_plus'),
+    ('urllib', 'quote'): ('urllib.parse', 'quote'),
+    ('urllib', 'unquote_plus'): ('urllib.parse', 'unquote_plus'),
+    ('urllib', 'unquote'): ('urllib.parse', 'unquote'),
+    ('urllib', 'url2pathname'): ('urllib.request', 'url2pathname'),
+    ('urllib', 'urlcleanup'): ('urllib.request', 'urlcleanup'),
+    ('urllib', 'urlencode'): ('urllib.parse', 'urlencode'),
+    ('urllib', 'urlopen'): ('urllib.request', 'urlopen'),
+    ('urllib', 'urlretrieve'): ('urllib.request', 'urlretrieve'),
+    ('urllib2', 'HTTPError'): ('urllib.error', 'HTTPError'),
+    ('urllib2', 'URLError'): ('urllib.error', 'URLError'),
+}
+
+PYTHON2_EXCEPTIONS = (
+    "ArithmeticError",
+    "AssertionError",
+    "AttributeError",
+    "BaseException",
+    "BufferError",
+    "BytesWarning",
+    "DeprecationWarning",
+    "EOFError",
+    "EnvironmentError",
+    "Exception",
+    "FloatingPointError",
+    "FutureWarning",
+    "GeneratorExit",
+    "IOError",
+    "ImportError",
+    "ImportWarning",
+    "IndentationError",
+    "IndexError",
+    "KeyError",
+    "KeyboardInterrupt",
+    "LookupError",
+    "MemoryError",
+    "NameError",
+    "NotImplementedError",
+    "OSError",
+    "OverflowError",
+    "PendingDeprecationWarning",
+    "ReferenceError",
+    "RuntimeError",
+    "RuntimeWarning",
+    # StandardError is gone in Python 3, so we map it to Exception
+    "StopIteration",
+    "SyntaxError",
+    "SyntaxWarning",
+    "SystemError",
+    "SystemExit",
+    "TabError",
+    "TypeError",
+    "UnboundLocalError",
+    "UnicodeDecodeError",
+    "UnicodeEncodeError",
+    "UnicodeError",
+    "UnicodeTranslateError",
+    "UnicodeWarning",
+    "UserWarning",
+    "ValueError",
+    "Warning",
+    "ZeroDivisionError",
+)
+
+try:
+    WindowsError
+except NameError:
+    pass
+else:
+    PYTHON2_EXCEPTIONS += ("WindowsError",)
+
+for excname in PYTHON2_EXCEPTIONS:
+    NAME_MAPPING[("exceptions", excname)] = ("builtins", excname)
+
+MULTIPROCESSING_EXCEPTIONS = (
+    'AuthenticationError',
+    'BufferTooShort',
+    'ProcessError',
+    'TimeoutError',
+)
+
+for excname in MULTIPROCESSING_EXCEPTIONS:
+    NAME_MAPPING[("multiprocessing", excname)] = ("multiprocessing.context", excname)
+
+# Same, but for 3.x to 2.x
+REVERSE_IMPORT_MAPPING = dict((v, k) for (k, v) in IMPORT_MAPPING.items())
+assert len(REVERSE_IMPORT_MAPPING) == len(IMPORT_MAPPING)
+REVERSE_NAME_MAPPING = dict((v, k) for (k, v) in NAME_MAPPING.items())
+assert len(REVERSE_NAME_MAPPING) == len(NAME_MAPPING)
+
+# Non-mutual mappings.
+
+IMPORT_MAPPING.update({
+    'cPickle': 'pickle',
+    '_elementtree': 'xml.etree.ElementTree',
+    'FileDialog': 'tkinter.filedialog',
+    'SimpleDialog': 'tkinter.simpledialog',
+    'DocXMLRPCServer': 'xmlrpc.server',
+    'SimpleHTTPServer': 'http.server',
+    'CGIHTTPServer': 'http.server',
+    # For compatibility with broken pickles saved in old Python 3 versions
+    'UserDict': 'collections',
+    'UserList': 'collections',
+    'UserString': 'collections',
+    'whichdb': 'dbm',
+    'StringIO':  'io',
+    'cStringIO': 'io',
+})
+
+REVERSE_IMPORT_MAPPING.update({
+    '_bz2': 'bz2',
+    '_dbm': 'dbm',
+    '_functools': 'functools',
+    '_gdbm': 'gdbm',
+    '_pickle': 'pickle',
+})
+
+NAME_MAPPING.update({
+    ('__builtin__', 'basestring'): ('builtins', 'str'),
+    ('exceptions', 'StandardError'): ('builtins', 'Exception'),
+    ('UserDict', 'UserDict'): ('collections', 'UserDict'),
+    ('socket', '_socketobject'): ('socket', 'SocketType'),
+})
+
+REVERSE_NAME_MAPPING.update({
+    ('_functools', 'reduce'): ('__builtin__', 'reduce'),
+    ('tkinter.filedialog', 'FileDialog'): ('FileDialog', 'FileDialog'),
+    ('tkinter.filedialog', 'LoadFileDialog'): ('FileDialog', 'LoadFileDialog'),
+    ('tkinter.filedialog', 'SaveFileDialog'): ('FileDialog', 'SaveFileDialog'),
+    ('tkinter.simpledialog', 'SimpleDialog'): ('SimpleDialog', 'SimpleDialog'),
+    ('xmlrpc.server', 'ServerHTMLDoc'): ('DocXMLRPCServer', 'ServerHTMLDoc'),
+    ('xmlrpc.server', 'XMLRPCDocGenerator'):
+        ('DocXMLRPCServer', 'XMLRPCDocGenerator'),
+    ('xmlrpc.server', 'DocXMLRPCRequestHandler'):
+        ('DocXMLRPCServer', 'DocXMLRPCRequestHandler'),
+    ('xmlrpc.server', 'DocXMLRPCServer'):
+        ('DocXMLRPCServer', 'DocXMLRPCServer'),
+    ('xmlrpc.server', 'DocCGIXMLRPCRequestHandler'):
+        ('DocXMLRPCServer', 'DocCGIXMLRPCRequestHandler'),
+    ('http.server', 'SimpleHTTPRequestHandler'):
+        ('SimpleHTTPServer', 'SimpleHTTPRequestHandler'),
+    ('http.server', 'CGIHTTPRequestHandler'):
+        ('CGIHTTPServer', 'CGIHTTPRequestHandler'),
+    ('_socket', 'socket'): ('socket', '_socketobject'),
+})
+
+PYTHON3_OSERROR_EXCEPTIONS = (
+    'BrokenPipeError',
+    'ChildProcessError',
+    'ConnectionAbortedError',
+    'ConnectionError',
+    'ConnectionRefusedError',
+    'ConnectionResetError',
+    'FileExistsError',
+    'FileNotFoundError',
+    'InterruptedError',
+    'IsADirectoryError',
+    'NotADirectoryError',
+    'PermissionError',
+    'ProcessLookupError',
+    'TimeoutError',
+)
+
+for excname in PYTHON3_OSERROR_EXCEPTIONS:
+    REVERSE_NAME_MAPPING[('builtins', excname)] = ('exceptions', 'OSError')
+
+PYTHON3_IMPORTERROR_EXCEPTIONS = (
+    'ModuleNotFoundError',
+)
+
+for excname in PYTHON3_IMPORTERROR_EXCEPTIONS:
+    REVERSE_NAME_MAPPING[('builtins', excname)] = ('exceptions', 'ImportError')

janus/lib/python3.10/contextvars.py

@@ -0,0 +1,4 @@
+from _contextvars import Context, ContextVar, Token, copy_context
+
+
+__all__ = ('Context', 'ContextVar', 'Token', 'copy_context')

janus/lib/python3.10/copyreg.py

@@ -0,0 +1,219 @@
+"""Helper to provide extensibility for pickle.
+
+This is only useful to add pickle support for extension types defined in
+C, not for instances of user-defined classes.
+"""
+
+__all__ = ["pickle", "constructor",
+           "add_extension", "remove_extension", "clear_extension_cache"]
+
+dispatch_table = {}
+
+def pickle(ob_type, pickle_function, constructor_ob=None):
+    if not callable(pickle_function):
+        raise TypeError("reduction functions must be callable")
+    dispatch_table[ob_type] = pickle_function
+
+    # The constructor_ob function is a vestige of safe for unpickling.
+    # There is no reason for the caller to pass it anymore.
+    if constructor_ob is not None:
+        constructor(constructor_ob)
+
+def constructor(object):
+    if not callable(object):
+        raise TypeError("constructors must be callable")
+
+# Example: provide pickling support for complex numbers.
+
+try:
+    complex
+except NameError:
+    pass
+else:
+
+    def pickle_complex(c):
+        return complex, (c.real, c.imag)
+
+    pickle(complex, pickle_complex, complex)
+
+def pickle_union(obj):
+    import functools, operator
+    return functools.reduce, (operator.or_, obj.__args__)
+
+pickle(type(int | str), pickle_union)
+
+# Support for pickling new-style objects
+
+def _reconstructor(cls, base, state):
+    if base is object:
+        obj = object.__new__(cls)
+    else:
+        obj = base.__new__(cls, state)
+        if base.__init__ != object.__init__:
+            base.__init__(obj, state)
+    return obj
+
+_HEAPTYPE = 1<<9
+_new_type = type(int.__new__)
+
+# Python code for object.__reduce_ex__ for protocols 0 and 1
+
+def _reduce_ex(self, proto):
+    assert proto < 2
+    cls = self.__class__
+    for base in cls.__mro__:
+        if hasattr(base, '__flags__') and not base.__flags__ & _HEAPTYPE:
+            break
+        new = base.__new__
+        if isinstance(new, _new_type) and new.__self__ is base:
+            break
+    else:
+        base = object # not really reachable
+    if base is object:
+        state = None
+    else:
+        if base is cls:
+            raise TypeError(f"cannot pickle {cls.__name__!r} object")
+        state = base(self)
+    args = (cls, base, state)
+    try:
+        getstate = self.__getstate__
+    except AttributeError:
+        if getattr(self, "__slots__", None):
+            raise TypeError(f"cannot pickle {cls.__name__!r} object: "
+                            f"a class that defines __slots__ without "
+                            f"defining __getstate__ cannot be pickled "
+                            f"with protocol {proto}") from None
+        try:
+            dict = self.__dict__
+        except AttributeError:
+            dict = None
+    else:
+        dict = getstate()
+    if dict:
+        return _reconstructor, args, dict
+    else:
+        return _reconstructor, args
+
+# Helper for __reduce_ex__ protocol 2
+
+def __newobj__(cls, *args):
+    return cls.__new__(cls, *args)
+
+def __newobj_ex__(cls, args, kwargs):
+    """Used by pickle protocol 4, instead of __newobj__ to allow classes with
+    keyword-only arguments to be pickled correctly.
+    """
+    return cls.__new__(cls, *args, **kwargs)
+
+def _slotnames(cls):
+    """Return a list of slot names for a given class.
+
+    This needs to find slots defined by the class and its bases, so we
+    can't simply return the __slots__ attribute.  We must walk down
+    the Method Resolution Order and concatenate the __slots__ of each
+    class found there.  (This assumes classes don't modify their
+    __slots__ attribute to misrepresent their slots after the class is
+    defined.)
+    """
+
+    # Get the value from a cache in the class if possible
+    names = cls.__dict__.get("__slotnames__")
+    if names is not None:
+        return names
+
+    # Not cached -- calculate the value
+    names = []
+    if not hasattr(cls, "__slots__"):
+        # This class has no slots
+        pass
+    else:
+        # Slots found -- gather slot names from all base classes
+        for c in cls.__mro__:
+            if "__slots__" in c.__dict__:
+                slots = c.__dict__['__slots__']
+                # if class has a single slot, it can be given as a string
+                if isinstance(slots, str):
+                    slots = (slots,)
+                for name in slots:
+                    # special descriptors
+                    if name in ("__dict__", "__weakref__"):
+                        continue
+                    # mangled names
+                    elif name.startswith('__') and not name.endswith('__'):
+                        stripped = c.__name__.lstrip('_')
+                        if stripped:
+                            names.append('_%s%s' % (stripped, name))
+                        else:
+                            names.append(name)
+                    else:
+                        names.append(name)
+
+    # Cache the outcome in the class if at all possible
+    try:
+        cls.__slotnames__ = names
+    except:
+        pass # But don't die if we can't
+
+    return names
+
+# A registry of extension codes.  This is an ad-hoc compression
+# mechanism.  Whenever a global reference to <module>, <name> is about
+# to be pickled, the (<module>, <name>) tuple is looked up here to see
+# if it is a registered extension code for it.  Extension codes are
+# universal, so that the meaning of a pickle does not depend on
+# context.  (There are also some codes reserved for local use that
+# don't have this restriction.)  Codes are positive ints; 0 is
+# reserved.
+
+_extension_registry = {}                # key -> code
+_inverted_registry = {}                 # code -> key
+_extension_cache = {}                   # code -> object
+# Don't ever rebind those names:  pickling grabs a reference to them when
+# it's initialized, and won't see a rebinding.
+
+def add_extension(module, name, code):
+    """Register an extension code."""
+    code = int(code)
+    if not 1 <= code <= 0x7fffffff:
+        raise ValueError("code out of range")
+    key = (module, name)
+    if (_extension_registry.get(key) == code and
+        _inverted_registry.get(code) == key):
+        return # Redundant registrations are benign
+    if key in _extension_registry:
+        raise ValueError("key %s is already registered with code %s" %
+                         (key, _extension_registry[key]))
+    if code in _inverted_registry:
+        raise ValueError("code %s is already in use for key %s" %
+                         (code, _inverted_registry[code]))
+    _extension_registry[key] = code
+    _inverted_registry[code] = key
+
+def remove_extension(module, name, code):
+    """Unregister an extension code.  For testing only."""
+    key = (module, name)
+    if (_extension_registry.get(key) != code or
+        _inverted_registry.get(code) != key):
+        raise ValueError("key %s is not registered with code %s" %
+                         (key, code))
+    del _extension_registry[key]
+    del _inverted_registry[code]
+    if code in _extension_cache:
+        del _extension_cache[code]
+
+def clear_extension_cache():
+    _extension_cache.clear()
+
+# Standard extension code assignments
+
+# Reserved ranges
+
+# First  Last Count  Purpose
+#     1   127   127  Reserved for Python standard library
+#   128   191    64  Reserved for Zope
+#   192   239    48  Reserved for 3rd parties
+#   240   255    16  Reserved for private use (will never be assigned)
+#   256   Inf   Inf  Reserved for future assignment
+
+# Extension codes are assigned by the Python Software Foundation.

janus/lib/python3.10/fnmatch.py

@@ -0,0 +1,199 @@
+"""Filename matching with shell patterns.
+
+fnmatch(FILENAME, PATTERN) matches according to the local convention.
+fnmatchcase(FILENAME, PATTERN) always takes case in account.
+
+The functions operate by translating the pattern into a regular
+expression.  They cache the compiled regular expressions for speed.
+
+The function translate(PATTERN) returns a regular expression
+corresponding to PATTERN.  (It does not compile it.)
+"""
+import os
+import posixpath
+import re
+import functools
+
+__all__ = ["filter", "fnmatch", "fnmatchcase", "translate"]
+
+# Build a thread-safe incrementing counter to help create unique regexp group
+# names across calls.
+from itertools import count
+_nextgroupnum = count().__next__
+del count
+
+def fnmatch(name, pat):
+    """Test whether FILENAME matches PATTERN.
+
+    Patterns are Unix shell style:
+
+    *       matches everything
+    ?       matches any single character
+    [seq]   matches any character in seq
+    [!seq]  matches any char not in seq
+
+    An initial period in FILENAME is not special.
+    Both FILENAME and PATTERN are first case-normalized
+    if the operating system requires it.
+    If you don't want this, use fnmatchcase(FILENAME, PATTERN).
+    """
+    name = os.path.normcase(name)
+    pat = os.path.normcase(pat)
+    return fnmatchcase(name, pat)
+
+@functools.lru_cache(maxsize=256, typed=True)
+def _compile_pattern(pat):
+    if isinstance(pat, bytes):
+        pat_str = str(pat, 'ISO-8859-1')
+        res_str = translate(pat_str)
+        res = bytes(res_str, 'ISO-8859-1')
+    else:
+        res = translate(pat)
+    return re.compile(res).match
+
+def filter(names, pat):
+    """Construct a list from those elements of the iterable NAMES that match PAT."""
+    result = []
+    pat = os.path.normcase(pat)
+    match = _compile_pattern(pat)
+    if os.path is posixpath:
+        # normcase on posix is NOP. Optimize it away from the loop.
+        for name in names:
+            if match(name):
+                result.append(name)
+    else:
+        for name in names:
+            if match(os.path.normcase(name)):
+                result.append(name)
+    return result
+
+def fnmatchcase(name, pat):
+    """Test whether FILENAME matches PATTERN, including case.
+
+    This is a version of fnmatch() which doesn't case-normalize
+    its arguments.
+    """
+    match = _compile_pattern(pat)
+    return match(name) is not None
+
+
+def translate(pat):
+    """Translate a shell PATTERN to a regular expression.
+
+    There is no way to quote meta-characters.
+    """
+
+    STAR = object()
+    res = []
+    add = res.append
+    i, n = 0, len(pat)
+    while i < n:
+        c = pat[i]
+        i = i+1
+        if c == '*':
+            # compress consecutive `*` into one
+            if (not res) or res[-1] is not STAR:
+                add(STAR)
+        elif c == '?':
+            add('.')
+        elif c == '[':
+            j = i
+            if j < n and pat[j] == '!':
+                j = j+1
+            if j < n and pat[j] == ']':
+                j = j+1
+            while j < n and pat[j] != ']':
+                j = j+1
+            if j >= n:
+                add('\\[')
+            else:
+                stuff = pat[i:j]
+                if '-' not in stuff:
+                    stuff = stuff.replace('\\', r'\\')
+                else:
+                    chunks = []
+                    k = i+2 if pat[i] == '!' else i+1
+                    while True:
+                        k = pat.find('-', k, j)
+                        if k < 0:
+                            break
+                        chunks.append(pat[i:k])
+                        i = k+1
+                        k = k+3
+                    chunk = pat[i:j]
+                    if chunk:
+                        chunks.append(chunk)
+                    else:
+                        chunks[-1] += '-'
+                    # Remove empty ranges -- invalid in RE.
+                    for k in range(len(chunks)-1, 0, -1):
+                        if chunks[k-1][-1] > chunks[k][0]:
+                            chunks[k-1] = chunks[k-1][:-1] + chunks[k][1:]
+                            del chunks[k]
+                    # Escape backslashes and hyphens for set difference (--).
+                    # Hyphens that create ranges shouldn't be escaped.
+                    stuff = '-'.join(s.replace('\\', r'\\').replace('-', r'\-')
+                                     for s in chunks)
+                # Escape set operations (&&, ~~ and ||).
+                stuff = re.sub(r'([&~|])', r'\\\1', stuff)
+                i = j+1
+                if not stuff:
+                    # Empty range: never match.
+                    add('(?!)')
+                elif stuff == '!':
+                    # Negated empty range: match any character.
+                    add('.')
+                else:
+                    if stuff[0] == '!':
+                        stuff = '^' + stuff[1:]
+                    elif stuff[0] in ('^', '['):
+                        stuff = '\\' + stuff
+                    add(f'[{stuff}]')
+        else:
+            add(re.escape(c))
+    assert i == n
+
+    # Deal with STARs.
+    inp = res
+    res = []
+    add = res.append
+    i, n = 0, len(inp)
+    # Fixed pieces at the start?
+    while i < n and inp[i] is not STAR:
+        add(inp[i])
+        i += 1
+    # Now deal with STAR fixed STAR fixed ...
+    # For an interior `STAR fixed` pairing, we want to do a minimal
+    # .*? match followed by `fixed`, with no possibility of backtracking.
+    # We can't spell that directly, but can trick it into working by matching
+    #    .*?fixed
+    # in a lookahead assertion, save the matched part in a group, then
+    # consume that group via a backreference. If the overall match fails,
+    # the lookahead assertion won't try alternatives. So the translation is:
+    #     (?=(?P<name>.*?fixed))(?P=name)
+    # Group names are created as needed: g0, g1, g2, ...
+    # The numbers are obtained from _nextgroupnum() to ensure they're unique
+    # across calls and across threads. This is because people rely on the
+    # undocumented ability to join multiple translate() results together via
+    # "|" to build large regexps matching "one of many" shell patterns.
+    while i < n:
+        assert inp[i] is STAR
+        i += 1
+        if i == n:
+            add(".*")
+            break
+        assert inp[i] is not STAR
+        fixed = []
+        while i < n and inp[i] is not STAR:
+            fixed.append(inp[i])
+            i += 1
+        fixed = "".join(fixed)
+        if i == n:
+            add(".*")
+            add(fixed)
+        else:
+            groupnum = _nextgroupnum()
+            add(f"(?=(?P<g{groupnum}>.*?{fixed}))(?P=g{groupnum})")
+    assert i == n
+    res = "".join(res)
+    return fr'(?s:{res})\Z'

janus/lib/python3.10/lzma.py

@@ -0,0 +1,356 @@
+"""Interface to the liblzma compression library.
+
+This module provides a class for reading and writing compressed files,
+classes for incremental (de)compression, and convenience functions for
+one-shot (de)compression.
+
+These classes and functions support both the XZ and legacy LZMA
+container formats, as well as raw compressed data streams.
+"""
+
+__all__ = [
+    "CHECK_NONE", "CHECK_CRC32", "CHECK_CRC64", "CHECK_SHA256",
+    "CHECK_ID_MAX", "CHECK_UNKNOWN",
+    "FILTER_LZMA1", "FILTER_LZMA2", "FILTER_DELTA", "FILTER_X86", "FILTER_IA64",
+    "FILTER_ARM", "FILTER_ARMTHUMB", "FILTER_POWERPC", "FILTER_SPARC",
+    "FORMAT_AUTO", "FORMAT_XZ", "FORMAT_ALONE", "FORMAT_RAW",
+    "MF_HC3", "MF_HC4", "MF_BT2", "MF_BT3", "MF_BT4",
+    "MODE_FAST", "MODE_NORMAL", "PRESET_DEFAULT", "PRESET_EXTREME",
+
+    "LZMACompressor", "LZMADecompressor", "LZMAFile", "LZMAError",
+    "open", "compress", "decompress", "is_check_supported",
+]
+
+import builtins
+import io
+import os
+from _lzma import *
+from _lzma import _encode_filter_properties, _decode_filter_properties
+import _compression
+
+
+_MODE_CLOSED   = 0
+_MODE_READ     = 1
+# Value 2 no longer used
+_MODE_WRITE    = 3
+
+
+class LZMAFile(_compression.BaseStream):
+
+    """A file object providing transparent LZMA (de)compression.
+
+    An LZMAFile can act as a wrapper for an existing file object, or
+    refer directly to a named file on disk.
+
+    Note that LZMAFile provides a *binary* file interface - data read
+    is returned as bytes, and data to be written must be given as bytes.
+    """
+
+    def __init__(self, filename=None, mode="r", *,
+                 format=None, check=-1, preset=None, filters=None):
+        """Open an LZMA-compressed file in binary mode.
+
+        filename can be either an actual file name (given as a str,
+        bytes, or PathLike object), in which case the named file is
+        opened, or it can be an existing file object to read from or
+        write to.
+
+        mode can be "r" for reading (default), "w" for (over)writing,
+        "x" for creating exclusively, or "a" for appending. These can
+        equivalently be given as "rb", "wb", "xb" and "ab" respectively.
+
+        format specifies the container format to use for the file.
+        If mode is "r", this defaults to FORMAT_AUTO. Otherwise, the
+        default is FORMAT_XZ.
+
+        check specifies the integrity check to use. This argument can
+        only be used when opening a file for writing. For FORMAT_XZ,
+        the default is CHECK_CRC64. FORMAT_ALONE and FORMAT_RAW do not
+        support integrity checks - for these formats, check must be
+        omitted, or be CHECK_NONE.
+
+        When opening a file for reading, the *preset* argument is not
+        meaningful, and should be omitted. The *filters* argument should
+        also be omitted, except when format is FORMAT_RAW (in which case
+        it is required).
+
+        When opening a file for writing, the settings used by the
+        compressor can be specified either as a preset compression
+        level (with the *preset* argument), or in detail as a custom
+        filter chain (with the *filters* argument). For FORMAT_XZ and
+        FORMAT_ALONE, the default is to use the PRESET_DEFAULT preset
+        level. For FORMAT_RAW, the caller must always specify a filter
+        chain; the raw compressor does not support preset compression
+        levels.
+
+        preset (if provided) should be an integer in the range 0-9,
+        optionally OR-ed with the constant PRESET_EXTREME.
+
+        filters (if provided) should be a sequence of dicts. Each dict
+        should have an entry for "id" indicating ID of the filter, plus
+        additional entries for options to the filter.
+        """
+        self._fp = None
+        self._closefp = False
+        self._mode = _MODE_CLOSED
+
+        if mode in ("r", "rb"):
+            if check != -1:
+                raise ValueError("Cannot specify an integrity check "
+                                 "when opening a file for reading")
+            if preset is not None:
+                raise ValueError("Cannot specify a preset compression "
+                                 "level when opening a file for reading")
+            if format is None:
+                format = FORMAT_AUTO
+            mode_code = _MODE_READ
+        elif mode in ("w", "wb", "a", "ab", "x", "xb"):
+            if format is None:
+                format = FORMAT_XZ
+            mode_code = _MODE_WRITE
+            self._compressor = LZMACompressor(format=format, check=check,
+                                              preset=preset, filters=filters)
+            self._pos = 0
+        else:
+            raise ValueError("Invalid mode: {!r}".format(mode))
+
+        if isinstance(filename, (str, bytes, os.PathLike)):
+            if "b" not in mode:
+                mode += "b"
+            self._fp = builtins.open(filename, mode)
+            self._closefp = True
+            self._mode = mode_code
+        elif hasattr(filename, "read") or hasattr(filename, "write"):
+            self._fp = filename
+            self._mode = mode_code
+        else:
+            raise TypeError("filename must be a str, bytes, file or PathLike object")
+
+        if self._mode == _MODE_READ:
+            raw = _compression.DecompressReader(self._fp, LZMADecompressor,
+                trailing_error=LZMAError, format=format, filters=filters)
+            self._buffer = io.BufferedReader(raw)
+
+    def close(self):
+        """Flush and close the file.
+
+        May be called more than once without error. Once the file is
+        closed, any other operation on it will raise a ValueError.
+        """
+        if self._mode == _MODE_CLOSED:
+            return
+        try:
+            if self._mode == _MODE_READ:
+                self._buffer.close()
+                self._buffer = None
+            elif self._mode == _MODE_WRITE:
+                self._fp.write(self._compressor.flush())
+                self._compressor = None
+        finally:
+            try:
+                if self._closefp:
+                    self._fp.close()
+            finally:
+                self._fp = None
+                self._closefp = False
+                self._mode = _MODE_CLOSED
+
+    @property
+    def closed(self):
+        """True if this file is closed."""
+        return self._mode == _MODE_CLOSED
+
+    def fileno(self):
+        """Return the file descriptor for the underlying file."""
+        self._check_not_closed()
+        return self._fp.fileno()
+
+    def seekable(self):
+        """Return whether the file supports seeking."""
+        return self.readable() and self._buffer.seekable()
+
+    def readable(self):
+        """Return whether the file was opened for reading."""
+        self._check_not_closed()
+        return self._mode == _MODE_READ
+
+    def writable(self):
+        """Return whether the file was opened for writing."""
+        self._check_not_closed()
+        return self._mode == _MODE_WRITE
+
+    def peek(self, size=-1):
+        """Return buffered data without advancing the file position.
+
+        Always returns at least one byte of data, unless at EOF.
+        The exact number of bytes returned is unspecified.
+        """
+        self._check_can_read()
+        # Relies on the undocumented fact that BufferedReader.peek() always
+        # returns at least one byte (except at EOF)
+        return self._buffer.peek(size)
+
+    def read(self, size=-1):
+        """Read up to size uncompressed bytes from the file.
+
+        If size is negative or omitted, read until EOF is reached.
+        Returns b"" if the file is already at EOF.
+        """
+        self._check_can_read()
+        return self._buffer.read(size)
+
+    def read1(self, size=-1):
+        """Read up to size uncompressed bytes, while trying to avoid
+        making multiple reads from the underlying stream. Reads up to a
+        buffer's worth of data if size is negative.
+
+        Returns b"" if the file is at EOF.
+        """
+        self._check_can_read()
+        if size < 0:
+            size = io.DEFAULT_BUFFER_SIZE
+        return self._buffer.read1(size)
+
+    def readline(self, size=-1):
+        """Read a line of uncompressed bytes from the file.
+
+        The terminating newline (if present) is retained. If size is
+        non-negative, no more than size bytes will be read (in which
+        case the line may be incomplete). Returns b'' if already at EOF.
+        """
+        self._check_can_read()
+        return self._buffer.readline(size)
+
+    def write(self, data):
+        """Write a bytes object to the file.
+
+        Returns the number of uncompressed bytes written, which is
+        always the length of data in bytes. Note that due to buffering,
+        the file on disk may not reflect the data written until close()
+        is called.
+        """
+        self._check_can_write()
+        if isinstance(data, (bytes, bytearray)):
+            length = len(data)
+        else:
+            # accept any data that supports the buffer protocol
+            data = memoryview(data)
+            length = data.nbytes
+
+        compressed = self._compressor.compress(data)
+        self._fp.write(compressed)
+        self._pos += length
+        return length
+
+    def seek(self, offset, whence=io.SEEK_SET):
+        """Change the file position.
+
+        The new position is specified by offset, relative to the
+        position indicated by whence. Possible values for whence are:
+
+            0: start of stream (default): offset must not be negative
+            1: current stream position
+            2: end of stream; offset must not be positive
+
+        Returns the new file position.
+
+        Note that seeking is emulated, so depending on the parameters,
+        this operation may be extremely slow.
+        """
+        self._check_can_seek()
+        return self._buffer.seek(offset, whence)
+
+    def tell(self):
+        """Return the current file position."""
+        self._check_not_closed()
+        if self._mode == _MODE_READ:
+            return self._buffer.tell()
+        return self._pos
+
+
+def open(filename, mode="rb", *,
+         format=None, check=-1, preset=None, filters=None,
+         encoding=None, errors=None, newline=None):
+    """Open an LZMA-compressed file in binary or text mode.
+
+    filename can be either an actual file name (given as a str, bytes,
+    or PathLike object), in which case the named file is opened, or it
+    can be an existing file object to read from or write to.
+
+    The mode argument can be "r", "rb" (default), "w", "wb", "x", "xb",
+    "a", or "ab" for binary mode, or "rt", "wt", "xt", or "at" for text
+    mode.
+
+    The format, check, preset and filters arguments specify the
+    compression settings, as for LZMACompressor, LZMADecompressor and
+    LZMAFile.
+
+    For binary mode, this function is equivalent to the LZMAFile
+    constructor: LZMAFile(filename, mode, ...). In this case, the
+    encoding, errors and newline arguments must not be provided.
+
+    For text mode, an LZMAFile object is created, and wrapped in an
+    io.TextIOWrapper instance with the specified encoding, error
+    handling behavior, and line ending(s).
+
+    """
+    if "t" in mode:
+        if "b" in mode:
+            raise ValueError("Invalid mode: %r" % (mode,))
+    else:
+        if encoding is not None:
+            raise ValueError("Argument 'encoding' not supported in binary mode")
+        if errors is not None:
+            raise ValueError("Argument 'errors' not supported in binary mode")
+        if newline is not None:
+            raise ValueError("Argument 'newline' not supported in binary mode")
+
+    lz_mode = mode.replace("t", "")
+    binary_file = LZMAFile(filename, lz_mode, format=format, check=check,
+                           preset=preset, filters=filters)
+
+    if "t" in mode:
+        encoding = io.text_encoding(encoding)
+        return io.TextIOWrapper(binary_file, encoding, errors, newline)
+    else:
+        return binary_file
+
+
+def compress(data, format=FORMAT_XZ, check=-1, preset=None, filters=None):
+    """Compress a block of data.
+
+    Refer to LZMACompressor's docstring for a description of the
+    optional arguments *format*, *check*, *preset* and *filters*.
+
+    For incremental compression, use an LZMACompressor instead.
+    """
+    comp = LZMACompressor(format, check, preset, filters)
+    return comp.compress(data) + comp.flush()
+
+
+def decompress(data, format=FORMAT_AUTO, memlimit=None, filters=None):
+    """Decompress a block of data.
+
+    Refer to LZMADecompressor's docstring for a description of the
+    optional arguments *format*, *check* and *filters*.
+
+    For incremental decompression, use an LZMADecompressor instead.
+    """
+    results = []
+    while True:
+        decomp = LZMADecompressor(format, memlimit, filters)
+        try:
+            res = decomp.decompress(data)
+        except LZMAError:
+            if results:
+                break  # Leftover data is not a valid LZMA/XZ stream; ignore it.
+            else:
+                raise  # Error on the first iteration; bail out.
+        results.append(res)
+        if not decomp.eof:
+            raise LZMAError("Compressed data ended before the "
+                            "end-of-stream marker was reached")
+        data = decomp.unused_data
+        if not data:
+            break
+    return b"".join(results)