# Table of Contents

* [mlagents\_envs.base\_env](#mlagents_envs.base_env)
  * [DecisionStep](#mlagents_envs.base_env.DecisionStep)
  * [DecisionSteps](#mlagents_envs.base_env.DecisionSteps)
    * [agent\_id\_to\_index](#mlagents_envs.base_env.DecisionSteps.agent_id_to_index)
    * [\_\_getitem\_\_](#mlagents_envs.base_env.DecisionSteps.__getitem__)
    * [empty](#mlagents_envs.base_env.DecisionSteps.empty)
  * [TerminalStep](#mlagents_envs.base_env.TerminalStep)
  * [TerminalSteps](#mlagents_envs.base_env.TerminalSteps)
    * [agent\_id\_to\_index](#mlagents_envs.base_env.TerminalSteps.agent_id_to_index)
    * [\_\_getitem\_\_](#mlagents_envs.base_env.TerminalSteps.__getitem__)
    * [empty](#mlagents_envs.base_env.TerminalSteps.empty)
  * [ActionTuple](#mlagents_envs.base_env.ActionTuple)
    * [discrete\_dtype](#mlagents_envs.base_env.ActionTuple.discrete_dtype)
  * [ActionSpec](#mlagents_envs.base_env.ActionSpec)
    * [is\_discrete](#mlagents_envs.base_env.ActionSpec.is_discrete)
    * [is\_continuous](#mlagents_envs.base_env.ActionSpec.is_continuous)
    * [discrete\_size](#mlagents_envs.base_env.ActionSpec.discrete_size)
    * [empty\_action](#mlagents_envs.base_env.ActionSpec.empty_action)
    * [random\_action](#mlagents_envs.base_env.ActionSpec.random_action)
    * [create\_continuous](#mlagents_envs.base_env.ActionSpec.create_continuous)
    * [create\_discrete](#mlagents_envs.base_env.ActionSpec.create_discrete)
  * [DimensionProperty](#mlagents_envs.base_env.DimensionProperty)
    * [UNSPECIFIED](#mlagents_envs.base_env.DimensionProperty.UNSPECIFIED)
    * [NONE](#mlagents_envs.base_env.DimensionProperty.NONE)
    * [TRANSLATIONAL\_EQUIVARIANCE](#mlagents_envs.base_env.DimensionProperty.TRANSLATIONAL_EQUIVARIANCE)
    * [VARIABLE\_SIZE](#mlagents_envs.base_env.DimensionProperty.VARIABLE_SIZE)
  * [ObservationType](#mlagents_envs.base_env.ObservationType)
    * [DEFAULT](#mlagents_envs.base_env.ObservationType.DEFAULT)
    * [GOAL\_SIGNAL](#mlagents_envs.base_env.ObservationType.GOAL_SIGNAL)
  * [ObservationSpec](#mlagents_envs.base_env.ObservationSpec)
  * [BehaviorSpec](#mlagents_envs.base_env.BehaviorSpec)
  * [BaseEnv](#mlagents_envs.base_env.BaseEnv)
    * [step](#mlagents_envs.base_env.BaseEnv.step)
    * [reset](#mlagents_envs.base_env.BaseEnv.reset)
    * [close](#mlagents_envs.base_env.BaseEnv.close)
    * [behavior\_specs](#mlagents_envs.base_env.BaseEnv.behavior_specs)
    * [set\_actions](#mlagents_envs.base_env.BaseEnv.set_actions)
    * [set\_action\_for\_agent](#mlagents_envs.base_env.BaseEnv.set_action_for_agent)
    * [get\_steps](#mlagents_envs.base_env.BaseEnv.get_steps)
* [mlagents\_envs.environment](#mlagents_envs.environment)
  * [UnityEnvironment](#mlagents_envs.environment.UnityEnvironment)
    * [\_\_init\_\_](#mlagents_envs.environment.UnityEnvironment.__init__)
    * [close](#mlagents_envs.environment.UnityEnvironment.close)
* [mlagents\_envs.registry](#mlagents_envs.registry)
* [mlagents\_envs.registry.unity\_env\_registry](#mlagents_envs.registry.unity_env_registry)
  * [UnityEnvRegistry](#mlagents_envs.registry.unity_env_registry.UnityEnvRegistry)
    * [register](#mlagents_envs.registry.unity_env_registry.UnityEnvRegistry.register)
    * [register\_from\_yaml](#mlagents_envs.registry.unity_env_registry.UnityEnvRegistry.register_from_yaml)
    * [clear](#mlagents_envs.registry.unity_env_registry.UnityEnvRegistry.clear)
    * [\_\_getitem\_\_](#mlagents_envs.registry.unity_env_registry.UnityEnvRegistry.__getitem__)
* [mlagents\_envs.side\_channel](#mlagents_envs.side_channel)
* [mlagents\_envs.side\_channel.raw\_bytes\_channel](#mlagents_envs.side_channel.raw_bytes_channel)
  * [RawBytesChannel](#mlagents_envs.side_channel.raw_bytes_channel.RawBytesChannel)
    * [on\_message\_received](#mlagents_envs.side_channel.raw_bytes_channel.RawBytesChannel.on_message_received)
    * [get\_and\_clear\_received\_messages](#mlagents_envs.side_channel.raw_bytes_channel.RawBytesChannel.get_and_clear_received_messages)
    * [send\_raw\_data](#mlagents_envs.side_channel.raw_bytes_channel.RawBytesChannel.send_raw_data)
* [mlagents\_envs.side\_channel.outgoing\_message](#mlagents_envs.side_channel.outgoing_message)
  * [OutgoingMessage](#mlagents_envs.side_channel.outgoing_message.OutgoingMessage)
    * [\_\_init\_\_](#mlagents_envs.side_channel.outgoing_message.OutgoingMessage.__init__)
    * [write\_bool](#mlagents_envs.side_channel.outgoing_message.OutgoingMessage.write_bool)
    * [write\_int32](#mlagents_envs.side_channel.outgoing_message.OutgoingMessage.write_int32)
    * [write\_float32](#mlagents_envs.side_channel.outgoing_message.OutgoingMessage.write_float32)
    * [write\_float32\_list](#mlagents_envs.side_channel.outgoing_message.OutgoingMessage.write_float32_list)
    * [write\_string](#mlagents_envs.side_channel.outgoing_message.OutgoingMessage.write_string)
    * [set\_raw\_bytes](#mlagents_envs.side_channel.outgoing_message.OutgoingMessage.set_raw_bytes)
* [mlagents\_envs.side\_channel.engine\_configuration\_channel](#mlagents_envs.side_channel.engine_configuration_channel)
  * [EngineConfigurationChannel](#mlagents_envs.side_channel.engine_configuration_channel.EngineConfigurationChannel)
    * [on\_message\_received](#mlagents_envs.side_channel.engine_configuration_channel.EngineConfigurationChannel.on_message_received)
    * [set\_configuration\_parameters](#mlagents_envs.side_channel.engine_configuration_channel.EngineConfigurationChannel.set_configuration_parameters)
    * [set\_configuration](#mlagents_envs.side_channel.engine_configuration_channel.EngineConfigurationChannel.set_configuration)
* [mlagents\_envs.side\_channel.side\_channel\_manager](#mlagents_envs.side_channel.side_channel_manager)
  * [SideChannelManager](#mlagents_envs.side_channel.side_channel_manager.SideChannelManager)
    * [process\_side\_channel\_message](#mlagents_envs.side_channel.side_channel_manager.SideChannelManager.process_side_channel_message)
    * [generate\_side\_channel\_messages](#mlagents_envs.side_channel.side_channel_manager.SideChannelManager.generate_side_channel_messages)
* [mlagents\_envs.side\_channel.stats\_side\_channel](#mlagents_envs.side_channel.stats_side_channel)
  * [StatsSideChannel](#mlagents_envs.side_channel.stats_side_channel.StatsSideChannel)
    * [on\_message\_received](#mlagents_envs.side_channel.stats_side_channel.StatsSideChannel.on_message_received)
    * [get\_and\_reset\_stats](#mlagents_envs.side_channel.stats_side_channel.StatsSideChannel.get_and_reset_stats)
* [mlagents\_envs.side\_channel.incoming\_message](#mlagents_envs.side_channel.incoming_message)
  * [IncomingMessage](#mlagents_envs.side_channel.incoming_message.IncomingMessage)
    * [\_\_init\_\_](#mlagents_envs.side_channel.incoming_message.IncomingMessage.__init__)
    * [read\_bool](#mlagents_envs.side_channel.incoming_message.IncomingMessage.read_bool)
    * [read\_int32](#mlagents_envs.side_channel.incoming_message.IncomingMessage.read_int32)
    * [read\_float32](#mlagents_envs.side_channel.incoming_message.IncomingMessage.read_float32)
    * [read\_float32\_list](#mlagents_envs.side_channel.incoming_message.IncomingMessage.read_float32_list)
    * [read\_string](#mlagents_envs.side_channel.incoming_message.IncomingMessage.read_string)
    * [get\_raw\_bytes](#mlagents_envs.side_channel.incoming_message.IncomingMessage.get_raw_bytes)
* [mlagents\_envs.side\_channel.float\_properties\_channel](#mlagents_envs.side_channel.float_properties_channel)
  * [FloatPropertiesChannel](#mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel)
    * [on\_message\_received](#mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel.on_message_received)
    * [set\_property](#mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel.set_property)
    * [get\_property](#mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel.get_property)
    * [list\_properties](#mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel.list_properties)
    * [get\_property\_dict\_copy](#mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel.get_property_dict_copy)
* [mlagents\_envs.side\_channel.environment\_parameters\_channel](#mlagents_envs.side_channel.environment_parameters_channel)
  * [EnvironmentParametersChannel](#mlagents_envs.side_channel.environment_parameters_channel.EnvironmentParametersChannel)
    * [set\_float\_parameter](#mlagents_envs.side_channel.environment_parameters_channel.EnvironmentParametersChannel.set_float_parameter)
    * [set\_uniform\_sampler\_parameters](#mlagents_envs.side_channel.environment_parameters_channel.EnvironmentParametersChannel.set_uniform_sampler_parameters)
    * [set\_gaussian\_sampler\_parameters](#mlagents_envs.side_channel.environment_parameters_channel.EnvironmentParametersChannel.set_gaussian_sampler_parameters)
    * [set\_multirangeuniform\_sampler\_parameters](#mlagents_envs.side_channel.environment_parameters_channel.EnvironmentParametersChannel.set_multirangeuniform_sampler_parameters)
* [mlagents\_envs.side\_channel.side\_channel](#mlagents_envs.side_channel.side_channel)
  * [SideChannel](#mlagents_envs.side_channel.side_channel.SideChannel)
    * [queue\_message\_to\_send](#mlagents_envs.side_channel.side_channel.SideChannel.queue_message_to_send)
    * [on\_message\_received](#mlagents_envs.side_channel.side_channel.SideChannel.on_message_received)
    * [channel\_id](#mlagents_envs.side_channel.side_channel.SideChannel.channel_id)

<a name="mlagents_envs.base_env"></a>
# mlagents\_envs.base\_env

Python Environment API for the ML-Agents Toolkit
The aim of this API is to expose Agents evolving in a simulation
to perform reinforcement learning on.
This API supports multi-agent scenarios and groups similar Agents (same
observations, actions spaces and behavior) together. These groups of Agents are
identified by their BehaviorName.
For performance reasons, the data of each group of agents is processed in a
batched manner. Agents are identified by a unique AgentId identifier that
allows tracking of Agents across simulation steps. Note that there is no
guarantee that the number or order of the Agents in the state will be
consistent across simulation steps.
A simulation steps corresponds to moving the simulation forward until at least
one agent in the simulation sends its observations to Python again. Since
Agents can request decisions at different frequencies, a simulation step does
not necessarily correspond to a fixed simulation time increment.

<a name="mlagents_envs.base_env.DecisionStep"></a>
## DecisionStep Objects

```python
class DecisionStep(NamedTuple)
```

Contains the data a single Agent collected since the last
simulation step.
 - obs is a list of numpy arrays observations collected by the agent.
 - reward is a float. Corresponds to the rewards collected by the agent
 since the last simulation step.
 - agent_id is an int and an unique identifier for the corresponding Agent.
 - action_mask is an optional list of one dimensional array of booleans.
 Only available when using multi-discrete actions.
 Each array corresponds to an action branch. Each array contains a mask
 for each action of the branch. If true, the action is not available for
 the agent during this simulation step.

<a name="mlagents_envs.base_env.DecisionSteps"></a>
## DecisionSteps Objects

```python
class DecisionSteps(Mapping)
```

Contains the data a batch of similar Agents collected since the last
simulation step. Note that all Agents do not necessarily have new
information to send at each simulation step. Therefore, the ordering of
agents and the batch size of the DecisionSteps are not fixed across
simulation steps.
 - obs is a list of numpy arrays observations collected by the batch of
 agent. Each obs has one extra dimension compared to DecisionStep: the
 first dimension of the array corresponds to the batch size of the batch.
 - reward is a float vector of length batch size. Corresponds to the
 rewards collected by each agent since the last simulation step.
 - agent_id is an int vector of length batch size containing unique
 identifier for the corresponding Agent. This is used to track Agents
 across simulation steps.
 - action_mask is an optional list of two dimensional array of booleans.
 Only available when using multi-discrete actions.
 Each array corresponds to an action branch. The first dimension of each
 array is the batch size and the second contains a mask for each action of
 the branch. If true, the action is not available for the agent during
 this simulation step.

<a name="mlagents_envs.base_env.DecisionSteps.agent_id_to_index"></a>
#### agent\_id\_to\_index

```python
 | @property
 | agent_id_to_index() -> Dict[AgentId, int]
```

**Returns**:

A Dict that maps agent_id to the index of those agents in
this DecisionSteps.

<a name="mlagents_envs.base_env.DecisionSteps.__getitem__"></a>
#### \_\_getitem\_\_

```python
 | __getitem__(agent_id: AgentId) -> DecisionStep
```

returns the DecisionStep for a specific agent.

**Arguments**:

- `agent_id`: The id of the agent

**Returns**:

The DecisionStep

<a name="mlagents_envs.base_env.DecisionSteps.empty"></a>
#### empty

```python
 | @staticmethod
 | empty(spec: "BehaviorSpec") -> "DecisionSteps"
```

Returns an empty DecisionSteps.

**Arguments**:

- `spec`: The BehaviorSpec for the DecisionSteps

<a name="mlagents_envs.base_env.TerminalStep"></a>
## TerminalStep Objects

```python
class TerminalStep(NamedTuple)
```

Contains the data a single Agent collected when its episode ended.
 - obs is a list of numpy arrays observations collected by the agent.
 - reward is a float. Corresponds to the rewards collected by the agent
 since the last simulation step.
 - interrupted is a bool. Is true if the Agent was interrupted since the last
 decision step. For example, if the Agent reached the maximum number of steps for
 the episode.
 - agent_id is an int and an unique identifier for the corresponding Agent.

<a name="mlagents_envs.base_env.TerminalSteps"></a>
## TerminalSteps Objects

```python
class TerminalSteps(Mapping)
```

Contains the data a batch of Agents collected when their episode
terminated. All Agents present in the TerminalSteps have ended their
episode.
 - obs is a list of numpy arrays observations collected by the batch of
 agent. Each obs has one extra dimension compared to DecisionStep: the
 first dimension of the array corresponds to the batch size of the batch.
 - reward is a float vector of length batch size. Corresponds to the
 rewards collected by each agent since the last simulation step.
 - interrupted is an array of booleans of length batch size. Is true if the
 associated Agent was interrupted since the last decision step. For example, if the
 Agent reached the maximum number of steps for the episode.
 - agent_id is an int vector of length batch size containing unique
 identifier for the corresponding Agent. This is used to track Agents
 across simulation steps.

<a name="mlagents_envs.base_env.TerminalSteps.agent_id_to_index"></a>
#### agent\_id\_to\_index

```python
 | @property
 | agent_id_to_index() -> Dict[AgentId, int]
```

**Returns**:

A Dict that maps agent_id to the index of those agents in
this TerminalSteps.

<a name="mlagents_envs.base_env.TerminalSteps.__getitem__"></a>
#### \_\_getitem\_\_

```python
 | __getitem__(agent_id: AgentId) -> TerminalStep
```

returns the TerminalStep for a specific agent.

**Arguments**:

- `agent_id`: The id of the agent

**Returns**:

obs, reward, done, agent_id and optional action mask for a
specific agent

<a name="mlagents_envs.base_env.TerminalSteps.empty"></a>
#### empty

```python
 | @staticmethod
 | empty(spec: "BehaviorSpec") -> "TerminalSteps"
```

Returns an empty TerminalSteps.

**Arguments**:

- `spec`: The BehaviorSpec for the TerminalSteps

<a name="mlagents_envs.base_env.ActionTuple"></a>
## ActionTuple Objects

```python
class ActionTuple(_ActionTupleBase)
```

An object whose fields correspond to actions of different types.
Continuous and discrete actions are numpy arrays of type float32 and
int32, respectively and are type checked on construction.
Dimensions are of (n_agents, continuous_size) and (n_agents, discrete_size),
respectively. Note, this also holds when continuous or discrete size is
zero.

<a name="mlagents_envs.base_env.ActionTuple.discrete_dtype"></a>
#### discrete\_dtype

```python
 | @property
 | discrete_dtype() -> np.dtype
```

The dtype of a discrete action.

<a name="mlagents_envs.base_env.ActionSpec"></a>
## ActionSpec Objects

```python
class ActionSpec(NamedTuple)
```

A NamedTuple containing utility functions and information about the action spaces
for a group of Agents under the same behavior.
- num_continuous_actions is an int corresponding to the number of floats which
constitute the action.
- discrete_branch_sizes is a Tuple of int where each int corresponds to
the number of discrete actions available to the agent on an independent action branch.

<a name="mlagents_envs.base_env.ActionSpec.is_discrete"></a>
#### is\_discrete

```python
 | is_discrete() -> bool
```

Returns true if this Behavior uses discrete actions

<a name="mlagents_envs.base_env.ActionSpec.is_continuous"></a>
#### is\_continuous

```python
 | is_continuous() -> bool
```

Returns true if this Behavior uses continuous actions

<a name="mlagents_envs.base_env.ActionSpec.discrete_size"></a>
#### discrete\_size

```python
 | @property
 | discrete_size() -> int
```

Returns a an int corresponding to the number of discrete branches.

<a name="mlagents_envs.base_env.ActionSpec.empty_action"></a>
#### empty\_action

```python
 | empty_action(n_agents: int) -> ActionTuple
```

Generates ActionTuple corresponding to an empty action (all zeros)
for a number of agents.

**Arguments**:

- `n_agents`: The number of agents that will have actions generated

<a name="mlagents_envs.base_env.ActionSpec.random_action"></a>
#### random\_action

```python
 | random_action(n_agents: int) -> ActionTuple
```

Generates ActionTuple corresponding to a random action (either discrete
or continuous) for a number of agents.

**Arguments**:

- `n_agents`: The number of agents that will have actions generated

<a name="mlagents_envs.base_env.ActionSpec.create_continuous"></a>
#### create\_continuous

```python
 | @staticmethod
 | create_continuous(continuous_size: int) -> "ActionSpec"
```

Creates an ActionSpec that is homogenously continuous

<a name="mlagents_envs.base_env.ActionSpec.create_discrete"></a>
#### create\_discrete

```python
 | @staticmethod
 | create_discrete(discrete_branches: Tuple[int]) -> "ActionSpec"
```

Creates an ActionSpec that is homogenously discrete

<a name="mlagents_envs.base_env.DimensionProperty"></a>
## DimensionProperty Objects

```python
class DimensionProperty(IntFlag)
```

The dimension property of a dimension of an observation.

<a name="mlagents_envs.base_env.DimensionProperty.UNSPECIFIED"></a>
#### UNSPECIFIED

No properties specified.

<a name="mlagents_envs.base_env.DimensionProperty.NONE"></a>
#### NONE

No Property of the observation in that dimension. Observation can be processed with
Fully connected networks.

<a name="mlagents_envs.base_env.DimensionProperty.TRANSLATIONAL_EQUIVARIANCE"></a>
#### TRANSLATIONAL\_EQUIVARIANCE

Means it is suitable to do a convolution in this dimension.

<a name="mlagents_envs.base_env.DimensionProperty.VARIABLE_SIZE"></a>
#### VARIABLE\_SIZE

Means that there can be a variable number of observations in this dimension.
The observations are unordered.

<a name="mlagents_envs.base_env.ObservationType"></a>
## ObservationType Objects

```python
class ObservationType(Enum)
```

An Enum which defines the type of information carried in the observation
of the agent.

<a name="mlagents_envs.base_env.ObservationType.DEFAULT"></a>
#### DEFAULT

Observation information is generic.

<a name="mlagents_envs.base_env.ObservationType.GOAL_SIGNAL"></a>
#### GOAL\_SIGNAL

Observation contains goal information for current task.

<a name="mlagents_envs.base_env.ObservationSpec"></a>
## ObservationSpec Objects

```python
class ObservationSpec(NamedTuple)
```

A NamedTuple containing information about the observation of Agents.
- shape is a Tuple of int : It corresponds to the shape of
an observation's dimensions.
- dimension_property is a Tuple of DimensionProperties flag, one flag for each
dimension.
- observation_type is an enum of ObservationType.

<a name="mlagents_envs.base_env.BehaviorSpec"></a>
## BehaviorSpec Objects

```python
class BehaviorSpec(NamedTuple)
```

A NamedTuple containing information about the observation and action
spaces for a group of Agents under the same behavior.
- observation_specs is a List of ObservationSpec NamedTuple containing
information about the information of the Agent's observations such as their shapes.
The order of the ObservationSpec is the same as the order of the observations of an
agent.
- action_spec is an ActionSpec NamedTuple.

<a name="mlagents_envs.base_env.BaseEnv"></a>
## BaseEnv Objects

```python
class BaseEnv(ABC)
```

<a name="mlagents_envs.base_env.BaseEnv.step"></a>
#### step

```python
 | @abstractmethod
 | step() -> None
```

Signals the environment that it must move the simulation forward
by one step.

<a name="mlagents_envs.base_env.BaseEnv.reset"></a>
#### reset

```python
 | @abstractmethod
 | reset() -> None
```

Signals the environment that it must reset the simulation.

<a name="mlagents_envs.base_env.BaseEnv.close"></a>
#### close

```python
 | @abstractmethod
 | close() -> None
```

Signals the environment that it must close.

<a name="mlagents_envs.base_env.BaseEnv.behavior_specs"></a>
#### behavior\_specs

```python
 | @property
 | @abstractmethod
 | behavior_specs() -> MappingType[str, BehaviorSpec]
```

Returns a Mapping from behavior names to behavior specs.
Agents grouped under the same behavior name have the same action and
observation specs, and are expected to behave similarly in the
environment.
Note that new keys can be added to this mapping as new policies are instantiated.

<a name="mlagents_envs.base_env.BaseEnv.set_actions"></a>
#### set\_actions

```python
 | @abstractmethod
 | set_actions(behavior_name: BehaviorName, action: ActionTuple) -> None
```

Sets the action for all of the agents in the simulation for the next
step. The Actions must be in the same order as the order received in
the DecisionSteps.

**Arguments**:

- `behavior_name`: The name of the behavior the agents are part of
- `action`: ActionTuple tuple of continuous and/or discrete action.
Actions are np.arrays with dimensions  (n_agents, continuous_size) and
(n_agents, discrete_size), respectively.

<a name="mlagents_envs.base_env.BaseEnv.set_action_for_agent"></a>
#### set\_action\_for\_agent

```python
 | @abstractmethod
 | set_action_for_agent(behavior_name: BehaviorName, agent_id: AgentId, action: ActionTuple) -> None
```

Sets the action for one of the agents in the simulation for the next
step.

**Arguments**:

- `behavior_name`: The name of the behavior the agent is part of
- `agent_id`: The id of the agent the action is set for
- `action`: ActionTuple tuple of continuous and/or discrete action
Actions are np.arrays with dimensions  (1, continuous_size) and
(1, discrete_size), respectively. Note, this initial dimensions of 1 is because
this action is meant for a single agent.

<a name="mlagents_envs.base_env.BaseEnv.get_steps"></a>
#### get\_steps

```python
 | @abstractmethod
 | get_steps(behavior_name: BehaviorName) -> Tuple[DecisionSteps, TerminalSteps]
```

Retrieves the steps of the agents that requested a step in the
simulation.

**Arguments**:

- `behavior_name`: The name of the behavior the agents are part of

**Returns**:

A tuple containing :
- A DecisionSteps NamedTuple containing the observations,
the rewards, the agent ids and the action masks for the Agents
of the specified behavior. These Agents need an action this step.
- A TerminalSteps NamedTuple containing the observations,
rewards, agent ids and interrupted flags of the agents that had their
episode terminated last step.

<a name="mlagents_envs.environment"></a>
# mlagents\_envs.environment

<a name="mlagents_envs.environment.UnityEnvironment"></a>
## UnityEnvironment Objects

```python
class UnityEnvironment(BaseEnv)
```

<a name="mlagents_envs.environment.UnityEnvironment.__init__"></a>
#### \_\_init\_\_

```python
 | __init__(file_name: Optional[str] = None, worker_id: int = 0, base_port: Optional[int] = None, seed: int = 0, no_graphics: bool = False, timeout_wait: int = 60, additional_args: Optional[List[str]] = None, side_channels: Optional[List[SideChannel]] = None, log_folder: Optional[str] = None, num_areas: int = 1)
```

Starts a new unity environment and establishes a connection with the environment.
Notice: Currently communication between Unity and Python takes place over an open socket without authentication.
Ensure that the network where training takes place is secure.

:string file_name: Name of Unity environment binary.
:int base_port: Baseline port number to connect to Unity environment over. worker_id increments over this.
If no environment is specified (i.e. file_name is None), the DEFAULT_EDITOR_PORT will be used.
:int worker_id: Offset from base_port. Used for training multiple environments simultaneously.
:bool no_graphics: Whether to run the Unity simulator in no-graphics mode
:int timeout_wait: Time (in seconds) to wait for connection from environment.
:list args: Addition Unity command line arguments
:list side_channels: Additional side channel for no-rl communication with Unity
:str log_folder: Optional folder to write the Unity Player log file into.  Requires absolute path.

<a name="mlagents_envs.environment.UnityEnvironment.close"></a>
#### close

```python
 | close()
```

Sends a shutdown signal to the unity environment, and closes the socket connection.

<a name="mlagents_envs.registry"></a>
# mlagents\_envs.registry

<a name="mlagents_envs.registry.unity_env_registry"></a>
# mlagents\_envs.registry.unity\_env\_registry

<a name="mlagents_envs.registry.unity_env_registry.UnityEnvRegistry"></a>
## UnityEnvRegistry Objects

```python
class UnityEnvRegistry(Mapping)
```

### UnityEnvRegistry
Provides a library of Unity environments that can be launched without the need
of downloading the Unity Editor.
The UnityEnvRegistry implements a Map, to access an entry of the Registry, use:
```python
registry = UnityEnvRegistry()
entry = registry[<environment_identifyier>]
```
An entry has the following properties :
 * `identifier` : Uniquely identifies this environment
 * `expected_reward` : Corresponds to the reward an agent must obtained for the task
 to be considered completed.
 * `description` : A human readable description of the environment.

To launch a Unity environment from a registry entry, use the `make` method:
```python
registry = UnityEnvRegistry()
env = registry[<environment_identifyier>].make()
```

<a name="mlagents_envs.registry.unity_env_registry.UnityEnvRegistry.register"></a>
#### register

```python
 | register(new_entry: BaseRegistryEntry) -> None
```

Registers a new BaseRegistryEntry to the registry. The
BaseRegistryEntry.identifier value will be used as indexing key.
If two are more environments are registered under the same key, the most
recentry added will replace the others.

<a name="mlagents_envs.registry.unity_env_registry.UnityEnvRegistry.register_from_yaml"></a>
#### register\_from\_yaml

```python
 | register_from_yaml(path_to_yaml: str) -> None
```

Registers the environments listed in a yaml file (either local or remote). Note
that the entries are registered lazily: the registration will only happen when
an environment is accessed.
The yaml file must have the following format :
```yaml
environments:
- <identifier of the first environment>:
    expected_reward: <expected reward of the environment>
    description: | <a multi line description of the environment>
      <continued multi line description>
    linux_url: <The url for the Linux executable zip file>
    darwin_url: <The url for the OSX executable zip file>
    win_url: <The url for the Windows executable zip file>

- <identifier of the second environment>:
    expected_reward: <expected reward of the environment>
    description: | <a multi line description of the environment>
      <continued multi line description>
    linux_url: <The url for the Linux executable zip file>
    darwin_url: <The url for the OSX executable zip file>
    win_url: <The url for the Windows executable zip file>

- ...
```

**Arguments**:

- `path_to_yaml`: A local path or url to the yaml file

<a name="mlagents_envs.registry.unity_env_registry.UnityEnvRegistry.clear"></a>
#### clear

```python
 | clear() -> None
```

Deletes all entries in the registry.

<a name="mlagents_envs.registry.unity_env_registry.UnityEnvRegistry.__getitem__"></a>
#### \_\_getitem\_\_

```python
 | __getitem__(identifier: str) -> BaseRegistryEntry
```

Returns the BaseRegistryEntry with the provided identifier. BaseRegistryEntry
can then be used to make a Unity Environment.

**Arguments**:

- `identifier`: The identifier of the BaseRegistryEntry

**Returns**:

The associated BaseRegistryEntry

<a name="mlagents_envs.side_channel"></a>
# mlagents\_envs.side\_channel

<a name="mlagents_envs.side_channel.raw_bytes_channel"></a>
# mlagents\_envs.side\_channel.raw\_bytes\_channel

<a name="mlagents_envs.side_channel.raw_bytes_channel.RawBytesChannel"></a>
## RawBytesChannel Objects

```python
class RawBytesChannel(SideChannel)
```

This is an example of what the SideChannel for raw bytes exchange would
look like. Is meant to be used for general research purpose.

<a name="mlagents_envs.side_channel.raw_bytes_channel.RawBytesChannel.on_message_received"></a>
#### on\_message\_received

```python
 | on_message_received(msg: IncomingMessage) -> None
```

Is called by the environment to the side channel. Can be called
multiple times per step if multiple messages are meant for that
SideChannel.

<a name="mlagents_envs.side_channel.raw_bytes_channel.RawBytesChannel.get_and_clear_received_messages"></a>
#### get\_and\_clear\_received\_messages

```python
 | get_and_clear_received_messages() -> List[bytes]
```

returns a list of bytearray received from the environment.

<a name="mlagents_envs.side_channel.raw_bytes_channel.RawBytesChannel.send_raw_data"></a>
#### send\_raw\_data

```python
 | send_raw_data(data: bytearray) -> None
```

Queues a message to be sent by the environment at the next call to
step.

<a name="mlagents_envs.side_channel.outgoing_message"></a>
# mlagents\_envs.side\_channel.outgoing\_message

<a name="mlagents_envs.side_channel.outgoing_message.OutgoingMessage"></a>
## OutgoingMessage Objects

```python
class OutgoingMessage()
```

Utility class for forming the message that is written to a SideChannel.
All data is written in little-endian format using the struct module.

<a name="mlagents_envs.side_channel.outgoing_message.OutgoingMessage.__init__"></a>
#### \_\_init\_\_

```python
 | __init__()
```

Create an OutgoingMessage with an empty buffer.

<a name="mlagents_envs.side_channel.outgoing_message.OutgoingMessage.write_bool"></a>
#### write\_bool

```python
 | write_bool(b: bool) -> None
```

Append a boolean value.

<a name="mlagents_envs.side_channel.outgoing_message.OutgoingMessage.write_int32"></a>
#### write\_int32

```python
 | write_int32(i: int) -> None
```

Append an integer value.

<a name="mlagents_envs.side_channel.outgoing_message.OutgoingMessage.write_float32"></a>
#### write\_float32

```python
 | write_float32(f: float) -> None
```

Append a float value. It will be truncated to 32-bit precision.

<a name="mlagents_envs.side_channel.outgoing_message.OutgoingMessage.write_float32_list"></a>
#### write\_float32\_list

```python
 | write_float32_list(float_list: List[float]) -> None
```

Append a list of float values. They will be truncated to 32-bit precision.

<a name="mlagents_envs.side_channel.outgoing_message.OutgoingMessage.write_string"></a>
#### write\_string

```python
 | write_string(s: str) -> None
```

Append a string value. Internally, it will be encoded to ascii, and the
encoded length will also be written to the message.

<a name="mlagents_envs.side_channel.outgoing_message.OutgoingMessage.set_raw_bytes"></a>
#### set\_raw\_bytes

```python
 | set_raw_bytes(buffer: bytearray) -> None
```

Set the internal buffer to a new bytearray. This will overwrite any existing data.

**Arguments**:

- `buffer`:

**Returns**:



<a name="mlagents_envs.side_channel.engine_configuration_channel"></a>
# mlagents\_envs.side\_channel.engine\_configuration\_channel

<a name="mlagents_envs.side_channel.engine_configuration_channel.EngineConfigurationChannel"></a>
## EngineConfigurationChannel Objects

```python
class EngineConfigurationChannel(SideChannel)
```

This is the SideChannel for engine configuration exchange. The data in the
engine configuration is as follows :
 - int width;
 - int height;
 - int qualityLevel;
 - float timeScale;
 - int targetFrameRate;
 - int captureFrameRate;

<a name="mlagents_envs.side_channel.engine_configuration_channel.EngineConfigurationChannel.on_message_received"></a>
#### on\_message\_received

```python
 | on_message_received(msg: IncomingMessage) -> None
```

Is called by the environment to the side channel. Can be called
multiple times per step if multiple messages are meant for that
SideChannel.
Note that Python should never receive an engine configuration from
Unity

<a name="mlagents_envs.side_channel.engine_configuration_channel.EngineConfigurationChannel.set_configuration_parameters"></a>
#### set\_configuration\_parameters

```python
 | set_configuration_parameters(width: Optional[int] = None, height: Optional[int] = None, quality_level: Optional[int] = None, time_scale: Optional[float] = None, target_frame_rate: Optional[int] = None, capture_frame_rate: Optional[int] = None) -> None
```

Sets the engine configuration. Takes as input the configurations of the
engine.

**Arguments**:

- `width`: Defines the width of the display. (Must be set alongside height)
- `height`: Defines the height of the display. (Must be set alongside width)
- `quality_level`: Defines the quality level of the simulation.
- `time_scale`: Defines the multiplier for the deltatime in the
simulation. If set to a higher value, time will pass faster in the
simulation but the physics might break.
- `target_frame_rate`: Instructs simulation to try to render at a
specified frame rate.
- `capture_frame_rate`: Instructs the simulation to consider time between
updates to always be constant, regardless of the actual frame rate.

<a name="mlagents_envs.side_channel.engine_configuration_channel.EngineConfigurationChannel.set_configuration"></a>
#### set\_configuration

```python
 | set_configuration(config: EngineConfig) -> None
```

Sets the engine configuration. Takes as input an EngineConfig.

<a name="mlagents_envs.side_channel.side_channel_manager"></a>
# mlagents\_envs.side\_channel.side\_channel\_manager

<a name="mlagents_envs.side_channel.side_channel_manager.SideChannelManager"></a>
## SideChannelManager Objects

```python
class SideChannelManager()
```

<a name="mlagents_envs.side_channel.side_channel_manager.SideChannelManager.process_side_channel_message"></a>
#### process\_side\_channel\_message

```python
 | process_side_channel_message(data: bytes) -> None
```

Separates the data received from Python into individual messages for each
registered side channel and calls on_message_received on them.

**Arguments**:

- `data`: The packed message sent by Unity

<a name="mlagents_envs.side_channel.side_channel_manager.SideChannelManager.generate_side_channel_messages"></a>
#### generate\_side\_channel\_messages

```python
 | generate_side_channel_messages() -> bytearray
```

Gathers the messages that the registered side channels will send to Unity
and combines them into a single message ready to be sent.

<a name="mlagents_envs.side_channel.stats_side_channel"></a>
# mlagents\_envs.side\_channel.stats\_side\_channel

<a name="mlagents_envs.side_channel.stats_side_channel.StatsSideChannel"></a>
## StatsSideChannel Objects

```python
class StatsSideChannel(SideChannel)
```

Side channel that receives (string, float) pairs from the environment, so that they can eventually
be passed to a StatsReporter.

<a name="mlagents_envs.side_channel.stats_side_channel.StatsSideChannel.on_message_received"></a>
#### on\_message\_received

```python
 | on_message_received(msg: IncomingMessage) -> None
```

Receive the message from the environment, and save it for later retrieval.

**Arguments**:

- `msg`:

**Returns**:



<a name="mlagents_envs.side_channel.stats_side_channel.StatsSideChannel.get_and_reset_stats"></a>
#### get\_and\_reset\_stats

```python
 | get_and_reset_stats() -> EnvironmentStats
```

Returns the current stats, and resets the internal storage of the stats.

**Returns**:



<a name="mlagents_envs.side_channel.incoming_message"></a>
# mlagents\_envs.side\_channel.incoming\_message

<a name="mlagents_envs.side_channel.incoming_message.IncomingMessage"></a>
## IncomingMessage Objects

```python
class IncomingMessage()
```

Utility class for reading the message written to a SideChannel.
Values must be read in the order they were written.

<a name="mlagents_envs.side_channel.incoming_message.IncomingMessage.__init__"></a>
#### \_\_init\_\_

```python
 | __init__(buffer: bytes, offset: int = 0)
```

Create a new IncomingMessage from the bytes.

<a name="mlagents_envs.side_channel.incoming_message.IncomingMessage.read_bool"></a>
#### read\_bool

```python
 | read_bool(default_value: bool = False) -> bool
```

Read a boolean value from the message buffer.

**Arguments**:

- `default_value`: Default value to use if the end of the message is reached.

**Returns**:

The value read from the message, or the default value if the end was reached.

<a name="mlagents_envs.side_channel.incoming_message.IncomingMessage.read_int32"></a>
#### read\_int32

```python
 | read_int32(default_value: int = 0) -> int
```

Read an integer value from the message buffer.

**Arguments**:

- `default_value`: Default value to use if the end of the message is reached.

**Returns**:

The value read from the message, or the default value if the end was reached.

<a name="mlagents_envs.side_channel.incoming_message.IncomingMessage.read_float32"></a>
#### read\_float32

```python
 | read_float32(default_value: float = 0.0) -> float
```

Read a float value from the message buffer.

**Arguments**:

- `default_value`: Default value to use if the end of the message is reached.

**Returns**:

The value read from the message, or the default value if the end was reached.

<a name="mlagents_envs.side_channel.incoming_message.IncomingMessage.read_float32_list"></a>
#### read\_float32\_list

```python
 | read_float32_list(default_value: List[float] = None) -> List[float]
```

Read a list of float values from the message buffer.

**Arguments**:

- `default_value`: Default value to use if the end of the message is reached.

**Returns**:

The value read from the message, or the default value if the end was reached.

<a name="mlagents_envs.side_channel.incoming_message.IncomingMessage.read_string"></a>
#### read\_string

```python
 | read_string(default_value: str = "") -> str
```

Read a string value from the message buffer.

**Arguments**:

- `default_value`: Default value to use if the end of the message is reached.

**Returns**:

The value read from the message, or the default value if the end was reached.

<a name="mlagents_envs.side_channel.incoming_message.IncomingMessage.get_raw_bytes"></a>
#### get\_raw\_bytes

```python
 | get_raw_bytes() -> bytes
```

Get a copy of the internal bytes used by the message.

<a name="mlagents_envs.side_channel.float_properties_channel"></a>
# mlagents\_envs.side\_channel.float\_properties\_channel

<a name="mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel"></a>
## FloatPropertiesChannel Objects

```python
class FloatPropertiesChannel(SideChannel)
```

This is the SideChannel for float properties shared with Unity.
You can modify the float properties of an environment with the commands
set_property, get_property and list_properties.

<a name="mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel.on_message_received"></a>
#### on\_message\_received

```python
 | on_message_received(msg: IncomingMessage) -> None
```

Is called by the environment to the side channel. Can be called
multiple times per step if multiple messages are meant for that
SideChannel.

<a name="mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel.set_property"></a>
#### set\_property

```python
 | set_property(key: str, value: float) -> None
```

Sets a property in the Unity Environment.

**Arguments**:

- `key`: The string identifier of the property.
- `value`: The float value of the property.

<a name="mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel.get_property"></a>
#### get\_property

```python
 | get_property(key: str) -> Optional[float]
```

Gets a property in the Unity Environment. If the property was not
found, will return None.

**Arguments**:

- `key`: The string identifier of the property.

**Returns**:

The float value of the property or None.

<a name="mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel.list_properties"></a>
#### list\_properties

```python
 | list_properties() -> List[str]
```

Returns a list of all the string identifiers of the properties
currently present in the Unity Environment.

<a name="mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel.get_property_dict_copy"></a>
#### get\_property\_dict\_copy

```python
 | get_property_dict_copy() -> Dict[str, float]
```

Returns a copy of the float properties.

**Returns**:



<a name="mlagents_envs.side_channel.environment_parameters_channel"></a>
# mlagents\_envs.side\_channel.environment\_parameters\_channel

<a name="mlagents_envs.side_channel.environment_parameters_channel.EnvironmentParametersChannel"></a>
## EnvironmentParametersChannel Objects

```python
class EnvironmentParametersChannel(SideChannel)
```

This is the SideChannel for sending environment parameters to Unity.
You can send parameters to an environment with the command
set_float_parameter.

<a name="mlagents_envs.side_channel.environment_parameters_channel.EnvironmentParametersChannel.set_float_parameter"></a>
#### set\_float\_parameter

```python
 | set_float_parameter(key: str, value: float) -> None
```

Sets a float environment parameter in the Unity Environment.

**Arguments**:

- `key`: The string identifier of the parameter.
- `value`: The float value of the parameter.

<a name="mlagents_envs.side_channel.environment_parameters_channel.EnvironmentParametersChannel.set_uniform_sampler_parameters"></a>
#### set\_uniform\_sampler\_parameters

```python
 | set_uniform_sampler_parameters(key: str, min_value: float, max_value: float, seed: int) -> None
```

Sets a uniform environment parameter sampler.

**Arguments**:

- `key`: The string identifier of the parameter.
- `min_value`: The minimum of the sampling distribution.
- `max_value`: The maximum of the sampling distribution.
- `seed`: The random seed to initialize the sampler.

<a name="mlagents_envs.side_channel.environment_parameters_channel.EnvironmentParametersChannel.set_gaussian_sampler_parameters"></a>
#### set\_gaussian\_sampler\_parameters

```python
 | set_gaussian_sampler_parameters(key: str, mean: float, st_dev: float, seed: int) -> None
```

Sets a gaussian environment parameter sampler.

**Arguments**:

- `key`: The string identifier of the parameter.
- `mean`: The mean of the sampling distribution.
- `st_dev`: The standard deviation of the sampling distribution.
- `seed`: The random seed to initialize the sampler.

<a name="mlagents_envs.side_channel.environment_parameters_channel.EnvironmentParametersChannel.set_multirangeuniform_sampler_parameters"></a>
#### set\_multirangeuniform\_sampler\_parameters

```python
 | set_multirangeuniform_sampler_parameters(key: str, intervals: List[Tuple[float, float]], seed: int) -> None
```

Sets a multirangeuniform environment parameter sampler.

**Arguments**:

- `key`: The string identifier of the parameter.
- `intervals`: The lists of min and max that define each uniform distribution.
- `seed`: The random seed to initialize the sampler.

<a name="mlagents_envs.side_channel.side_channel"></a>
# mlagents\_envs.side\_channel.side\_channel

<a name="mlagents_envs.side_channel.side_channel.SideChannel"></a>
## SideChannel Objects

```python
class SideChannel(ABC)
```

The side channel just get access to a bytes buffer that will be shared
between C# and Python. For example, We will create a specific side channel
for properties that will be a list of string (fixed size) to float number,
that can be modified by both C# and Python. All side channels are passed
to the Env object at construction.

<a name="mlagents_envs.side_channel.side_channel.SideChannel.queue_message_to_send"></a>
#### queue\_message\_to\_send

```python
 | queue_message_to_send(msg: OutgoingMessage) -> None
```

Queues a message to be sent by the environment at the next call to
step.

<a name="mlagents_envs.side_channel.side_channel.SideChannel.on_message_received"></a>
#### on\_message\_received

```python
 | @abstractmethod
 | on_message_received(msg: IncomingMessage) -> None
```

Is called by the environment to the side channel. Can be called
multiple times per step if multiple messages are meant for that
SideChannel.

<a name="mlagents_envs.side_channel.side_channel.SideChannel.channel_id"></a>
#### channel\_id

```python
 | @property
 | channel_id() -> uuid.UUID
```

**Returns**:

The type of side channel used. Will influence how the data is
processed in the environment.
