h_6SrSSKJr SSKJr SSKJrJrJrJ r SSK r SSK r SSKJrJrJr SSKJr SSKJr \(aSS KJr \ "S 5r/S Qr"S S \5r"SS\\\\45r"SS\5r"SS\5r"SS\5r"SS\5rg)z'Base class for vectorized environments.) annotations)Enum) TYPE_CHECKINGAnyGenericTypeVarN)ActTypeObsType RenderFrame)warn)seeding)EnvSpec ArrayType) VectorEnv VectorWrapperVectorObservationWrapperVectorActionWrapperVectorRewardWrapperr AutoresetModec$\rSrSrSrSrSrSrSrg)r!zSEnum representing the different autoreset modes, next step, same step and disabled.NextStepSameStepDisabledN) __name__ __module__ __qualname____firstlineno____doc__ NEXT_STEP SAME_STEPDISABLED__static_attributes__rU/home/james-whalen/.local/lib/python3.13/site-packages/gymnasium/vector/vector_env.pyrr!s]IIHr%rcx\rSrSr%Sr0rS\S'SrS\S'SrS\S 'S r S \S 'S \S'S \S'S \S'S \S'S\S'Sr S\S'Sr S\S'SSS.S&Sjjr S'Sjr S(SjrS)SjrS)Sjr\S*Sj5r\R&S+Sj5r\S,S j5r\S!5rS-S"jrS#rS.S$jrS%rg)/r)aBase class for vectorized environments to run multiple independent copies of the same environment in parallel. Vector environments can provide a linear speed-up in the steps taken per second through sampling multiple sub-environments at the same time. Gymnasium contains two generalised Vector environments: :class:`AsyncVectorEnv` and :class:`SyncVectorEnv` along with several custom vector environment implementations. For :func:`reset` and :func:`step` batches `observations`, `rewards`, `terminations`, `truncations` and `info` for each sub-environment, see the example below. For the `rewards`, `terminations`, and `truncations`, the data is packaged into a NumPy array of shape `(num_envs,)`. For `observations` (and `actions`, the batching process is dependent on the type of observation (and action) space, and generally optimised for neural network input/outputs. For `info`, the data is kept as a dictionary such that a key will give the data for all sub-environment. For creating environments, :func:`make_vec` is a vector environment equivalent to :func:`make` for easily creating vector environments that contains several unique arguments for modifying environment qualities, number of environment, vectorizer type, vectorizer arguments. To avoid having to wait for all sub-environments to terminated before resetting, implementations can autoreset sub-environments on episode end (`terminated or truncated is True`). This is crucial for correct implementing training algorithms with vector environments. By default, Gymnasium's implementation uses `next-step` autoreset, with :class:`AutoresetMode` enum as the options. The mode used by vector environment should be available in `metadata["autoreset_mode"]`. Warning, some vector implementations or training algorithms will only support particular autoreset modes. For more information, read https://farama.org/Vector-Autoreset-Mode. Note: The info parameter of :meth:`reset` and :meth:`step` was originally implemented before v0.25 as a list of dictionary for each sub-environment. However, this was modified in v0.25+ to be a dictionary with a NumPy array for each key. To use the old info style, utilise the :class:`DictInfoToList` wrapper. Examples: >>> import gymnasium as gym >>> envs = gym.make_vec("CartPole-v1", num_envs=3, vectorization_mode="sync", wrappers=(gym.wrappers.TimeAwareObservation,)) >>> envs = gym.wrappers.vector.ClipReward(envs, min_reward=0.2, max_reward=0.8) >>> envs >>> envs.num_envs 3 >>> envs.action_space MultiDiscrete([2 2 2]) >>> envs.observation_space Box([[-4.80000019 -inf -0.41887903 -inf 0. ] [-4.80000019 -inf -0.41887903 -inf 0. ] [-4.80000019 -inf -0.41887903 -inf 0. ]], [[4.80000019e+00 inf 4.18879032e-01 inf 5.00000000e+02] [4.80000019e+00 inf 4.18879032e-01 inf 5.00000000e+02] [4.80000019e+00 inf 4.18879032e-01 inf 5.00000000e+02]], (3, 5), float64) >>> observations, infos = envs.reset(seed=123) >>> observations array([[ 0.01823519, -0.0446179 , -0.02796401, -0.03156282, 0. ], [ 0.02852531, 0.02858594, 0.0469136 , 0.02480598, 0. ], [ 0.03517495, -0.000635 , -0.01098382, -0.03203924, 0. ]]) >>> infos {} >>> _ = envs.action_space.seed(123) >>> actions = envs.action_space.sample() >>> observations, rewards, terminations, truncations, infos = envs.step(actions) >>> observations array([[ 0.01734283, 0.15089367, -0.02859527, -0.33293587, 1. ], [ 0.02909703, -0.16717631, 0.04740972, 0.3319138 , 1. ], [ 0.03516225, -0.19559774, -0.01162461, 0.25715804, 1. ]]) >>> rewards array([0.8, 0.8, 0.8]) >>> terminations array([False, False, False]) >>> truncations array([False, False, False]) >>> infos {} >>> envs.close() The Vector Environments have the additional attributes for users to understand the implementation - :attr:`num_envs` - The number of sub-environment in the vector environment - :attr:`observation_space` - The batched observation space of the vector environment - :attr:`single_observation_space` - The observation space of a single sub-environment - :attr:`action_space` - The batched action space of the vector environment - :attr:`single_action_space` - The action space of a single sub-environment dict[str, Any]metadataNEnvSpec | Nonespecz str | None render_modeFboolclosed gym.Spaceobservation_space action_spacesingle_observation_spacesingle_action_spaceintnum_envsznp.random.Generator | None _np_random int | None_np_random_seedseedoptionscRUb$[R"U5uUlUlgg)aReset all parallel environments and return a batch of initial observations and info. Args: seed: The environment reset seed options: If to return the options Returns: A batch of observations and info from the vectorized environment. Example: >>> import gymnasium as gym >>> envs = gym.make_vec("CartPole-v1", num_envs=3, vectorization_mode="sync") >>> observations, infos = envs.reset(seed=42) >>> observations array([[ 0.0273956 , -0.00611216, 0.03585979, 0.0197368 ], [ 0.01522993, -0.04562247, -0.04799704, 0.03392126], [-0.03774345, -0.02418869, -0.00942293, 0.0469184 ]], dtype=float32) >>> infos {} N)r np_randomr7r9selfr;r<s r&resetVectorEnv.resets)6  4;4E4Ed4K 1DOT1 r%c:[UR5S35e)aWTake an action for each parallel environment. Args: actions: Batch of actions with the :attr:`action_space` shape. Returns: Batch of (observations, rewards, terminations, truncations, infos) Note: As the vector environments autoreset for a terminating and truncating sub-environments, this will occur on the next step after `terminated or truncated is True`. Example: >>> import gymnasium as gym >>> import numpy as np >>> envs = gym.make_vec("CartPole-v1", num_envs=3, vectorization_mode="sync") >>> _ = envs.reset(seed=42) >>> actions = np.array([1, 0, 1], dtype=np.int32) >>> observations, rewards, terminations, truncations, infos = envs.step(actions) >>> observations array([[ 0.02727336, 0.18847767, 0.03625453, -0.26141977], [ 0.01431748, -0.24002443, -0.04731862, 0.3110827 ], [-0.03822722, 0.1710671 , -0.00848456, -0.2487226 ]], dtype=float32) >>> rewards array([1., 1., 1.]) >>> terminations array([False, False, False]) >>> terminations array([False, False, False]) >>> infos {} z" step function is not implemented.NotImplementedError__str__r@actionss r&stepVectorEnv.stepsH"T\\^$44V"WXXr%c:[UR5S35e)zReturns the rendered frames from the parallel environments. Returns: A tuple of rendered frames from the parallel environments z$ render function is not implemented.rDr@s r&renderVectorEnv.renders# "||~B C  r%c ZUR(agUR"S0UD6 SUlg)aClose all parallel environments and release resources. It also closes all the existing image viewers, then calls :meth:`close_extras` and set :attr:`closed` as ``True``. Warnings: This function itself does not close the environments, it should be handled in :meth:`close_extras`. This is generic for both synchronous and asynchronous vectorized environments. Note: This will be automatically called when garbage collected or program exited. Args: **kwargs: Keyword arguments passed to :meth:`close_extras` NTr)r/ close_extrasr@kwargss r&closeVectorEnv.closes&" ;;  #F# r%c g)zCClean up the extra resources e.g. beyond what's in this base class.NrrQs r&rPVectorEnv.close_extrass r%cxURc"[R"5uUlUlUR$zReturns the environment's internal :attr:`_np_random` that if not set will initialise with a random seed. Returns: Instances of `np.random.Generator` )r7r r>r9rLs r&r>VectorEnv.np_randoms0 ?? "4;4E4E4G 1DOT1r%cXlSUlg)N)r7r9r@values r&r>rYs!r%cxURc"[R"5uUlUlUR$)aqReturns the environment's internal :attr:`_np_random_seed` that if not set will first initialise with a random int as seed. If :attr:`np_random_seed` was set directly instead of through :meth:`reset` or :meth:`set_np_random_through_seed`, the seed will take the value -1. Returns: int: the seed of the current `np_random` or -1, if the seed of the rng is unknown )r9r r>r7rLs r&np_random_seedVectorEnv.np_random_seeds4    '4;4E4E4G 1DOT1###r%cU$)zReturn the base environment.rrLs r& unwrappedVectorEnv.unwrappeds  r%c UR5GHupEUS:Xa6SU;aUSnO$[R"URS[S9nXVU'GO0[ U[ 5(a#URURU05XS5nOXA;a[U5[[[4;d([[U5[R5(a)[R"UR[U5S9nO[ U[R 5(a8[R"UR/UR"Q7UR$S9nO)[R"URS[S9nOXnXVU'URSU3[R"UR[R&S95nSXs'XgsX'USU3'GM U$)a\Add env info to the info dictionary of the vectorized environment. Given the `info` of a single environment add it to the `infos` dictionary which represents all the infos of the vectorized environment. Every `key` of `info` is paired with a boolean mask `_key` representing whether or not the i-indexed environment has this `info`. Args: vector_infos (dict): the infos of the vectorized environment env_info (dict): the info coming from the single environment env_num (int): the index of the single environment Returns: infos (dict): the (updated) infos of the vectorized environment final_obsN) fill_valuedtype)rg_T)itemsnpfullr6object isinstancedict _add_infogettyper5floatr. issubclassnumberzerosndarrayshapergbool_)r@ vector_infosenv_infoenv_numkeyr]array array_masks r&roVectorEnv._add_infos$#..*JCk!,.(5EGGDMMd&QE!&gE4((|'7'7R'@%Q*E{sE4&88JU RYY==!#d5k J#E2::66 "!]]9U[[9! !# $f U)-E"'g&))C5 288DMMBJ#'J :? 6L |auI6U+Vr%cJ[USS5(dUR5 gg)zCloses the vector environment.r/TN)getattrrSrLs r&__del__VectorEnv.__del__SstXt,, JJL-r%cURc&URRSURS3$URRSURRSURS3$)zReturns a string representation of the vector environment. Returns: A string containing the class name, number of environments and environment spec id z (num_envs=)(z , num_envs=)r, __class__rr6idrLs r&__repr__VectorEnv.__repr__Xse 99 nn--.jqI I>>**+1TYY\\N+dmm_TUV r%)r7r9r/)r;r8r<dict[str, Any] | Nonereturntuple[ObsType, dict[str, Any]]rHr rz?tuple[ObsType, ArrayType, ArrayType, ArrayType, dict[str, Any]]rztuple[RenderFrame, ...] | NonerRrrnp.random.Generatorr]rrr8)ryr)rzr)r{r5rr))rstr)rrrrr r*__annotations__r,r-r/r7r9rArIrMrSrPpropertyr>setterr_rbrorrr$rr%r&rr)sBM^ "Hn!D."K"FD  ''""M-1J*1"&OZ&  )- LL' L ( L<$Y$Y H$YL . "" $ $=*=6D=OR= =~ r%rcj\rSrSrSrS SjrSSS.S!SjjrS"SjrS#SjrS$S jr S$S jr \ S 5r S r \ S%S j5r\RS&Sj5r\ S%Sj5r\RS&Sj5r\ S%Sj5r\RS&Sj5r\ S%Sj5r\RS5r\ S'Sj5r\ S(Sj5r\RS)Sj5r\ S*Sj5r\ S5r\RS5r\ S+Sj5r\ S#Sj5r\ S5r\RS,Sj5rSrg)-rifaWraps the vectorized environment to allow a modular transformation. This class is the base class for all wrappers for vectorized environments. The subclass could override some methods to change the behavior of the original vectorized environment without touching the original code. Note: Don't forget to call ``super().__init__(env)`` if the subclass overrides :meth:`__init__`. cXl[U[5(dS[U535eSUlSUlSUlSUlSUlg)zWInitialize the vectorized environment wrapper. Args: env: The environment to wrap z:Expected env to be a `gymnasium.vector.VectorEnv` but got N) envrmrrq_observation_space _action_space_single_observation_space_single_action_space _metadata)r@rs r&__init__VectorWrapper.__init__qsc     T GS { S T 59/3;?&6:!04r%Nr:c4URRXS9$)z-Reset all environment using seed and options.r:)rrAr?s r&rAVectorWrapper.resetsxx~~4~99r%c8URRU5$)zKStep through all environments using the actions returning the batched data.)rrIrGs r&rIVectorWrapper.stepsxx}}W%%r%c6URR5$)z9Returns the render mode from the base vector environment.)rrMrLs r&rMVectorWrapper.rendersxx  r%c :URR"S0UD6$)zClose all environments.r)rrSrQs r&rSVectorWrapper.closesxx~~'''r%c :URR"S0UD6$)zClose all extra resources.r)rrPrQs r&rPVectorWrapper.close_extrassxx$$.v..r%c.URR$)z(Return the base non-wrapped environment.)rrbrLs r&rbVectorWrapper.unwrappedsxx!!!r%cPSURRSURS3$)z?Return the string representation of the vectorized environment.)rrrrLs r&rVectorWrapper.__repr__s&4>>**+2dhhZq99r%c`URcURR$UR$)z5Gets the observation space of the vector environment.)rrr1rLs r&r1VectorWrapper.observation_spaces,  " " *88-- -&&&r%cXlg)z5Sets the observation space of the vector environment.N)rr@spaces r&r1rs #(r%c`URcURR$UR$)z0Gets the action space of the vector environment.)rrr2rLs r&r2VectorWrapper.action_spaces,    %88(( (!!!r%cXlg)z0Sets the action space of the vector environment.N)rrs r&r2rs #r%c`URcURR$UR$)zrLs r&r>VectorWrapper.np_randomsxx!!!r%c$XRlgNrr\s r&r>rs "r%c.URR$)zBThe seeds of the vector environment's internal :attr:`_np_random`.)rr_rLs r&r_VectorWrapper.np_random_seedsxx&&&r%c`URb UR$URR$)z'The metadata of the vector environment.)rrr*rLs r&r*VectorWrapper.metadatas( >> %>> !xx   r%cXlgr)rr\s r&r*rsr%c.URR$)z2Gets the specification of the wrapped environment.)rr,rLs r&r,VectorWrapper.specsxx}}r%c.URR$)z4Returns the `render_mode` from the base environment.)rr-rLs r&r-VectorWrapper.render_modesxx###r%c.URR$)zIf the environment has closes.rr/rLs r&r/VectorWrapper.closedsxxr%c$XRlgrrr\s r&r/rs r%)rrrrrrrrr;zint | list[int] | Noner<rrrrrr)rr0)rr0)rr5rrr)rr+)r]r.)rrrrr rrArIrMrSrPrrbrr1rr2r3r4r6r>r_r*r,r-r/r$rr%r&rrfs5((,)- :%:' : ( :&& H& !(/"":'' (("" ##.. $$/%/)) * *!!""##''!! __$$ ]]  r%rcj^\rSrSrSrS U4SjjrSSS.S SjjrS SjrS SjrS r U=r $)ri zWraps the vectorized environment to allow a modular transformation of the observation. Equivalent to :class:`gymnasium.ObservationWrapper` for vectorized environments. c>[TU]U5 SUR;a[SUS35 gURS[R :Xd$URS[R :Xdegg)zcVector observation wrapper that batch transforms observations. Args: env: Vector environment. autoreset_modezVector environment (z+) is missing `autoreset_mode` metadata key.N)superrr*r rr!r#)r@rrs r&r!VectorObservationWrapper.__init__sy  3<< / &se+VW   -.-2I2II<< 01]5K5KK LKJr%Nr:c^URRXS9up4URU5U4$)z_Modifies the observation returned from the environment ``reset`` using the :meth:`observation`.r:)rrA observations)r@r;r<rinfoss r&rAVectorObservationWrapper.reset#s1#hhnn$nH   .55r%clURRU5up#pEnURU5UUUU4$)z^Modifies the observation returned from the environment ``step`` using the :meth:`observation`.)rrIrr@rHrrewards terminations truncationsrs r&rIVectorObservationWrapper.step-sDCG((--PWBX? |%   l +       r%c[e)zDefines the vector observation transformation. Args: observations: A vector observation from the environment Returns: the transformed observation rE)r@rs r&r%VectorObservationWrapper.observations: "!r%rrrr)rr rr ) rrrrr rrArIrr$ __classcell__)rs@r&rr sW ((,)- 6%6' 6 ( 6    H   " "r%rc4\rSrSrSrSSjrSSjrSrg) riFzWraps the vectorized environment to allow a modular transformation of the actions. Equivalent of :class:`gymnasium.ActionWrapper` for vectorized environments. cVURRURU55$)zHSteps through the environment using a modified action by :meth:`action`.)rrIrHrGs r&rIVectorActionWrapper.stepLs xx}}T\\'233r%c[e)zTransform the actions before sending them to the environment. Args: actions (ActType): the actions to transform Returns: ActType: the transformed actions rrGs r&rHVectorActionWrapper.actionsRrr%rNr)rHr rr )rrrrr rIrHr$rr%r&rrFs! 44 H4 "r%rc4\rSrSrSrSSjrSSjrSrg) ri^zWraps the vectorized environment to allow a modular transformation of the reward. Equivalent of :class:`gymnasium.RewardWrapper` for vectorized environments. chURRU5up#pEnX RU5XEU4$)zLSteps through the environment returning a reward modified by :meth:`reward`.)rrIrrs r&rIVectorRewardWrapper.stepds6CG((--PWBX? |%\\'2LuTTr%c[e)zTransform the reward before returning it. Args: rewards (array): the reward to transform Returns: array: the transformed reward r)r@rs r&rVectorRewardWrapper.rewardskrr%rNr)rrrr)rrrrr rIrr$rr%r&rr^s$ UU HU "r%r) r __future__renumrtypingrrrrnumpyrj gymnasiumgymgymnasium.corer r r gymnasium.loggerr gymnasium.utilsr gymnasium.envs.registrationrr__all__rrrrrrrr%r&rs-"7788!#3 K  Dz)34zz c Ic L7"}7"t"-"0"-"r%