h}SrSSKJr SSKJrJr SSKJrJr SSK r SSK r SSK J r SSKJrJrJr SSKJr /S QrSS KJr "S S \ R.\\\4\ R0R25r"S S\\\\4\ R0R25r"SS\\\\4\ R0R25r"SS\\\\4\ R0R25r"SS\\\\4\ R0R25r"SS\\\\4\ R0R25r"SS\\\\4\ R0R25r "SS\\\\4\ R0R25r!"SS\\\\4\ R0R25r""SS\\\\4\ R0R25r#g)aDA collection of observation wrappers using a lambda function. * ``TransformObservation`` - Transforms the observation with a function * ``FilterObservation`` - Filters a ``Tuple`` or ``Dict`` to only include certain keys * ``FlattenObservation`` - Flattens the observations * ``GrayscaleObservation`` - Converts a RGB observation to a grayscale observation * ``ResizeObservation`` - Resizes an array-based observation (normally a RGB observation) * ``ReshapeObservation`` - Reshapes an array-based observation * ``RescaleObservation`` - Rescales an observation to between a minimum and maximum value * ``DtypeObservation`` - Convert an observation to a dtype * ``RenderObservation`` - Allows the observation to the rendered frame * ``DiscretizeObservation`` - Discretize a continuous Box observation space into a single Discrete space ) annotations)CallableSequence)AnyFinalN)spaces)ActTypeObsTypeWrapperObsType)DependencyNotInstalled) TransformObservationFilterObservationFlattenObservationGrayscaleObservationResizeObservationReshapeObservationRescaleObservationDtypeObservationAddRenderObservationDiscretizeObservation) rescale_boxc8\rSrSrSrSSjrSSjrSrg) r ,aJApplies a function to the ``observation`` received from the environment's :meth:`Env.reset` and :meth:`Env.step` that is passed back to the user. The function :attr:`func` will be applied to all observations. If the observations from :attr:`func` are outside the bounds of the ``env``'s observation space, provide an updated :attr:`observation_space`. A vector version of the wrapper exists :class:`gymnasium.wrappers.vector.TransformObservation`. Example: >>> import gymnasium as gym >>> from gymnasium.wrappers import TransformObservation >>> import numpy as np >>> np.random.seed(0) >>> env = gym.make("CartPole-v1") >>> env.reset(seed=42) (array([ 0.0273956 , -0.00611216, 0.03585979, 0.0197368 ], dtype=float32), {}) >>> env = gym.make("CartPole-v1") >>> env = TransformObservation(env, lambda obs: obs + 0.1 * np.random.random(obs.shape), env.observation_space) >>> env.reset(seed=42) (array([0.08227695, 0.06540678, 0.09613613, 0.07422512]), {}) Change logs: * v0.15.4 - Initially added * v1.0.0 - Add requirement of ``observation_space`` c[RRRXUS9 [RRX5 UbX0lX lg)aConstructor for the transform observation wrapper. Args: env: The environment to wrap func: A function that will transform an observation. If this transformed observation is outside the observation space of ``env.observation_space`` then provide an `observation_space`. observation_space: The observation spaces of the wrapper, if None, then it is assumed the same as ``env.observation_space``. funcobservation_spaceN)gymutilsRecordConstructorArgs__init__ObservationWrapperrr)selfenvrrs b/home/james-whalen/.local/lib/python3.13/site-packages/gymnasium/wrappers/transform_observation.pyr!TransformObservation.__init__IsN ''00 /@ 1  ''2  (%6 " c$URU5$)z"Apply function to the observation.)r)r# observations r%r) TransformObservation.observation`syy%%r'rN)r$gym.Env[ObsType, ActType]rzCallable[[ObsType], Any]rz gym.Space[WrapperObsType] | None)r)r returnr)__name__ __module__ __qualname____firstlineno____doc__r!r)__static_attributes__r'r%r r ,s-2 &'< .&r'r c*\rSrSrSrSSjrSrg)reauFilters a Dict or Tuple observation spaces by a set of keys or indexes. A vector version of the wrapper exists :class:`gymnasium.wrappers.vector.FilterObservation`. Example: >>> import gymnasium as gym >>> from gymnasium.wrappers import FilterObservation >>> env = gym.make("CartPole-v1") >>> env = gym.wrappers.TimeAwareObservation(env, flatten=False) >>> env.observation_space Dict('obs': Box([-4.8 -inf -0.41887903 -inf], [4.8 inf 0.41887903 inf], (4,), float32), 'time': Box(0, 500, (1,), int32)) >>> env.reset(seed=42) ({'obs': array([ 0.0273956 , -0.00611216, 0.03585979, 0.0197368 ], dtype=float32), 'time': array([0], dtype=int32)}, {}) >>> env = FilterObservation(env, filter_keys=['time']) >>> env.reset(seed=42) ({'time': array([0], dtype=int32)}, {}) >>> env.step(0) ({'time': array([1], dtype=int32)}, 1.0, False, False, {}) Change logs: * v0.12.3 - Initially added, originally called `FilterObservationWrapper` * v1.0.0 - Rename to `FilterObservation` and add support for tuple observation spaces with integer ``filter_keys`` c ^^[T[5(d[S[T535e[R R RUTS9 [TR[R5(Ga[ST55(de[U4SjT55(a{TVs/sH/nUTRRR5;dM-UPM1 nn[STS[TRRR55SU35e[R"TVs0sHo3TRU_M sn5n[!U5S:Xa [S 5e["RUTU4S jUS 9 GOZ[TR[R$5(Ga[S T55(de[!['T55[!T5:Xd S T35e[U4SjT55(a\TVs/sH(nSU:dM U[!TR5:dM&UPM* nn[STS[!TR5SU35e[R$"U4SjT55n[!U5S:Xa [S5e["RUTU4SjUS 9 O![S[TR535eTUlgs snfs snfs snf)zConstructor for the filter observation wrapper. Args: env: The environment to wrap filter_keys: The set of subspaces to be *included*, use a list of strings for ``Dict`` and integers for ``Tuple`` spaces z5Expects `filter_keys` to be a Sequence, actual type:  filter_keysc3B# UHn[U[5v M g7fN) isinstancestr.0keys r% -FilterObservation.__init__..C{z#s++{c3p># UH+oTRRR5;v M- g7fr:)rrkeysr>r?r$s r%r@rAs,JU330077<<>>+s36zNAll the `filter_keys` must be included in the observation space. Filter keys: z Observation keys: z Missing keys: rz@The observation space is empty due to filtering all of the keys.c8>TVs0sHoX_M sn$s snfr:r3)obsr?r8s r%,FilterObservation.__init__..s;!G;Csx-;!G!Gsr$rrc3B# UHn[U[5v M g7fr:)r;intr=s r%r@rArBrCz#Duplicate keys exist, filter_keys: c3l># UH)nSU:=(a U[TR5:v M+ g7frN)lenrrFs r%r@rAs0IT#C=C3s'<'<#===s14z\All the `filter_keys` must be included in the length of the observation space. Filter keys: z, length of observation: z, missing indexes: c3B># UHnTRUv M g7fr:)rrFs r%r@rAs26As%%c*ksz9The observation space is empty due to filtering all keys.c0>^[U4SjT55$)Nc3.># UH nTUv M g7fr:r3)r>r?rHs r%r@?FilterObservation.__init__....s&G;Cs3x;s)tuple)rHr8s`r%rIrJs&G;&G!Gr'z\FilterObservation wrapper is only usable with `Dict` and `Tuple` observations, actual type: N)r;r TypeErrortyperrr r!rrDictallanyrE ValueErrorlistrPr Tuplesetr8)r#r$r8r? missing_keysnew_observation_space missing_indexnew_observation_spacess `` r%r!FilterObservation.__init__sL+x00G[HYGZ[  ''00;0O c++V[[ 9 9C{CCC CCJU + *#"7"7">">"C"C"EE*  !$$/=1))-c.C.C.J.J.O.O.Q)R(ST%%1N4%+KK>> import gymnasium as gym >>> from gymnasium.wrappers import FlattenObservation >>> env = gym.make("CarRacing-v3") >>> env.observation_space.shape (96, 96, 3) >>> env = FlattenObservation(env) >>> env.observation_space.shape (27648,) >>> obs, _ = env.reset() >>> obs.shape (27648,) Change logs: * v0.15.0 - Initially added c^[RRRU5 [RUTU4Sj[ RR TR5S9 g)zConstructor for any environment's observation space that implements ``spaces.utils.flatten_space`` and ``spaces.utils.flatten``. Args: env: The environment to wrap cX>[RRTRU5$r:)rrflattenr)rHr$s r%rI-FlattenObservation.__init__..sV\\11#2G2GMr'rKN)rrr r!r r flatten_spacer)r#r$s `r%r!FlattenObservation.__init__sQ ''006%% M$ll889N9NO & r'r3N)r$r+rdr3r'r%rrs *  r'rc&\rSrSrSrSSSjjrSrg)ria$Converts an image observation computed by ``reset`` and ``step`` from RGB to Grayscale. The :attr:`keep_dim` will keep the channel dimension. A vector version of the wrapper exists :class:`gymnasium.wrappers.vector.GrayscaleObservation`. Example: >>> import gymnasium as gym >>> from gymnasium.wrappers import GrayscaleObservation >>> env = gym.make("CarRacing-v3") >>> env.observation_space.shape (96, 96, 3) >>> grayscale_env = GrayscaleObservation(env) >>> grayscale_env.observation_space.shape (96, 96) >>> grayscale_env = GrayscaleObservation(env, keep_dim=True) >>> grayscale_env.observation_space.shape (96, 96, 1) Change logs: * v0.15.0 - Initially added, originally called ``GrayScaleObservation`` * v1.0.0 - Renamed to ``GrayscaleObservation`` c[UR[R5(de[ URR 5S:XaURR SS:Xde[ R"URRS:H5(aZ[ R"URRS:H5(a(URR[ R:Xde[RRRXS9 X lU(aW[R"SSURR SSS-[ RS 9n["RUUS US 9 g[R"SSURR SS[ RS 9n["RUUS US 9 g) zConstructor for an RGB image based environments to make the image grayscale. Args: env: The environment to wrap keep_dim: If to keep the channel in the observation, if ``True``, ``obs.shape == 3`` else ``obs.shape == 2`` rkeep_dimN)lowhighshapedtypec [R"[R"[R"U[R"/SQ55SS9R [R 5SS9$N)g333333?gjq?gL F%u?rp)axis)np expand_dimssummultiplyarrayastypeuint8rHs r%rI/GrayscaleObservation.__init__..>sEFF C2J)KLSUfRXX& "r'rKc [R"[R"U[R"/SQ55SS9R [R 5$r|)r~rrrrrrs r%rIrMs:KKRXX.F%GHr"&""#r')r;rrBoxrPryr~rYrwrxrzrrrr r!rsr )r#r$rsr`s r%r!GrayscaleObservation.__init__ s#//<<<< %%++ , 1%%++B/14  5 FF3((,,1 2 2s,,11S899%%++rxx7  8 ''000I%- $*JJ++11"15<hh % ! ! ) ) #8 * %+JJCs'<'<'B'B2A'Fbhh% ! ! ) )##8 * r'rrNF)r$r+rsboolrdr3r'r%rrs011r'rc"\rSrSrSrSSjrSrg)riTa4Resizes image observations using OpenCV to a specified shape. A vector version of the wrapper exists :class:`gymnasium.wrappers.vector.ResizeObservation`. Example: >>> import gymnasium as gym >>> from gymnasium.wrappers import ResizeObservation >>> env = gym.make("CarRacing-v3") >>> env.observation_space.shape (96, 96, 3) >>> resized_env = ResizeObservation(env, (32, 32)) >>> resized_env.observation_space.shape (32, 32, 3) Change logs: * v0.12.6 - Initially added * v1.0.0 - Requires ``shape`` with a tuple of two integers c^^[UR[R5(de[ URR 5S;de[ R"URRS:H5(a2[ R"URRS:H5(deURR[ R:Xde[U[5(de[ U5S:Xde[SU55(de[SU55(deSSK m[U5TlUS US4Tl[R"SSTR URR SS-[ RS 9n["R$R&R)TUS 9 [*R)TUUU4S jUS 9 g![an[S5UeSnAff=f)zConstructor that requires an image environment observation space with a shape. Args: env: The environment to wrap shape: The resized observation shape >rtrorrqrtc3~# UH3n[R"[U5[R5v M5 g7fr:r~ issubdtyperWintegerr>elems r%r@-ResizeObservation.__init__..{&KUT2==dRZZ88U;=c3*# UH oS:v M g7frOr3r>xs r%r@r|s(%Qq5%sNzCopencv (cv2) is not installed, run `pip install "gymnasium[other]"`rurvrycN>TRUTRTRS9$)N) interpolation)resize cv2_shape INTER_AREA)rHcv2r#s r%rI,ResizeObservation.__init__..s"SZZT^^3>>(r'rK)r;rrrrPryr~rYrwrxrzrrUr ImportErrorr rrrr r!r )r#r$ryer`rs` @r%r!ResizeObservation.__init__ks#//<<<<3((../6999vvc++//1455"&&  ! ! & &# -; ;   $$**bhh666%''''5zQKUKKKKK(%(((((   .35\ 27(E!H1E & **s44::12>>(( !  ''00U0C%% 4 & # (U  s>G.. H 8 HH )rryN)r$r+ryztuple[int, int]rdr3r'r%rrTs &- r'rc"\rSrSrSrSSjrSrg)riaReshapes Array based observations to a specified shape. A vector version of the wrapper exists :class:`gymnasium.wrappers.vector.RescaleObservation`. Example: >>> import gymnasium as gym >>> from gymnasium.wrappers import ReshapeObservation >>> env = gym.make("CarRacing-v3") >>> env.observation_space.shape (96, 96, 3) >>> reshape_env = ReshapeObservation(env, (24, 4, 96, 1, 3)) >>> reshape_env.observation_space.shape (24, 4, 96, 1, 3) Change logs: * v1.0.0 - Initially added cR^[UR[R5(de[R "T5[R "URR 5:Xde[T[5(de[ST55(de[ST55(de[R"[R"[R"URR5T5[R"[R"URR5T5TURRS9nTUl[RR R#UTS9 [$R#UUU4SjUS9 g)zConstructor for env with ``Box`` observation space that has a shape product equal to the new shape product. Args: env: The environment to wrap shape: The reshaped observation space c3~# UH3n[R"[U5[R5v M5 g7fr:rrs r%r@.ReshapeObservation.__init__..rrc3B# UHoS:=(d US:Hv M g7f)rrpNr3rs r%r@rs3Uq5#AG#UrCrvrc2>[R"UT5$r:)r~reshape)rHrys r%rI-ReshapeObservation.__init__..sRZZU3r'rKN)r;rrrr~prodryrUrYrravelrwrxrzrrr r!r )r#r$ryr`s ` r%r!ReshapeObservation.__init__s:#//<<<<wwu~)>)>)D)D!EEEE%''''KUKKKKK3U33333 &  288C$9$9$=$=>FBHHS%:%:%?%?@%H''-- !    ''00U0C%% 33 & r'rN)r$r+ryint | tuple[int, ...]rdr3r'r%rrs $ r'rc.\rSrSrSrSSjrSrg)ria,Affinely (linearly) rescales a ``Box`` observation space of the environment to within the range of ``[min_obs, max_obs]``. For unbounded components in the original observation space, the corresponding target bounds must also be infinite and vice versa. A vector version of the wrapper exists :class:`gymnasium.wrappers.vector.RescaleObservation`. Example: >>> import gymnasium as gym >>> from gymnasium.wrappers import RescaleObservation >>> env = gym.make("Pendulum-v1") >>> env.observation_space Box([-1. -1. -8.], [1. 1. 8.], (3,), float32) >>> env = RescaleObservation(env, np.array([-2, -1, -10], dtype=np.float32), np.array([1, 0, 1], dtype=np.float32)) >>> env.observation_space Box([ -2. -1. -10.], [1. 0. 1.], (3,), float32) Change logs: * v1.0.0 - Initially added c[UR[R5(de[R R RXUS9 [URX#5upEn[RUUUUS9 g)zConstructor that requires the env observation spaces to be a :class:`Box`. Args: env: The environment to wrap min_obs: The new minimum observation bound max_obs: The new maximum observation bound )min_obsmax_obsrKN) r;rrrrrr r!rr )r#r$rr obs_spacer_s r%r!RescaleObservation.__init__su#//<<<< ''00PW0X()>)>Q %% ' & r'r3N)r$r+r%np.floating | np.integer | np.ndarrayrrrdr3r'r%rrs(( & 7 7  r'rc"\rSrSrSrSSjrSrg)riaTModifies the dtype of an observation array to a specified dtype. Note: This is only compatible with :class:`Box`, :class:`Discrete`, :class:`MultiDiscrete` and :class:`MultiBinary` observation spaces A vector version of the wrapper exists :class:`gymnasium.wrappers.vector.DtypeObservation`. Change logs: * v1.0.0 - Initially added c^[UR[R[R[R [R 45(deTUl[UR[R5(a_[R"URRURRURRURS9nGOG[UR[R5(aa[R"URRURRURR-SURS9nO[UR[R 5(a*[R "URRTS9nOj[UR[R 5(a6[R"SSURRURS9nO [S5e[R R"R%UTS9 [&R%UUU4SjUS9 g ) zConstructor for Dtype observation wrapper. Args: env: The environment to wrap dtype: The new dtype of the observation rvr3rzrruzJDtypeObservation is only compatible with value / array-based observations.c>T"U5$r:r3)rHrzs r%rI+DtypeObservation.__init__..@s U3Zr'rKN)r;rrrDiscrete MultiDiscrete MultiBinaryrzrwrxrystartnnvecrVrrr r!r )r#r$rzr`s ` r%r!DtypeObservation.__init__s  ! ! ZZ&*>*>@R@R S     c++VZZ 8 8$*JJ))--**//++11jj % ! --v ? ?$*JJ))//**0033H3H3J3JJjj % ! --v/C/C D D$*$8$8%%**%% !--v/A/A B B$*JJ++11jj % !\  ''00U0C%% '3 & r'rN)r$r+rzrrdr3r'r%rrs  1 r'rc:\rSrSrSrSSSjjrSrg)riEaUIncludes the rendered observations in the environment's observations. Notes: This was previously called ``PixelObservationWrapper``. No vector version of the wrapper exists. Example - Replace the observation with the rendered image: >>> env = gym.make("CartPole-v1", render_mode="rgb_array") >>> env = AddRenderObservation(env, render_only=True) >>> env.observation_space Box(0, 255, (400, 600, 3), uint8) >>> obs, _ = env.reset(seed=123) >>> image = env.render() >>> np.all(obs == image) np.True_ >>> obs, *_ = env.step(env.action_space.sample()) >>> image = env.render() >>> np.all(obs == image) np.True_ Example - Add the rendered image to the original observation as a dictionary item: >>> env = gym.make("CartPole-v1", render_mode="rgb_array") >>> env = AddRenderObservation(env, render_only=False) >>> env.observation_space Dict('pixels': Box(0, 255, (400, 600, 3), uint8), 'state': Box([-4.8 -inf -0.41887903 -inf], [4.8 inf 0.41887903 inf], (4,), float32)) >>> obs, info = env.reset(seed=123) >>> obs.keys() dict_keys(['state', 'pixels']) >>> obs["state"] array([ 0.01823519, -0.0446179 , -0.02796401, -0.03156282], dtype=float32) >>> np.all(obs["pixels"] == env.render()) np.True_ >>> obs, reward, terminates, truncates, info = env.step(env.action_space.sample()) >>> image = env.render() >>> np.all(obs["pixels"] == image) np.True_ Change logs: * v0.15.0 - Initially added as ``PixelObservationWrapper`` * v1.0.0 - Renamed to ``AddRenderObservation`` c^^^[RRRTUTTS9 URbURS:wdeUR 5 UR 5nUb[U[R5(de[R"SSUR[RS9nU(aUn[RTUU4SjUS9 g[UR[R 5(atTURRR#5;de[R "TU0URRE5n[RTUUU4S jUS9 g[R "TURTU05n[RTUUUU4S jUS9 g) aIConstructor of the add render observation wrapper. Args: env: The environment to wrap. render_only (bool): If ``True`` (default), the original observation returned by the wrapped environment will be discarded, and a dictionary observation will only include pixels. If ``False``, the observation dictionary will contain both the original observations and the pixel observations. render_key: Optional custom string specifying the pixel key. Defaults to "pixels" obs_key: Optional custom string specifying the obs key. Defaults to "state" ) pixels_only pixels_keyobs_keyNhumanrrqrvc$>TR5$r:render)rr#s r%rI/AddRenderObservation.__init__..s dkkmr'rKc,>TTR50UE$r:r)rH render_keyr#s r%rIrs*dkkm!Cs!Cr'c,>TUTTR50$r:r)rHrrr#s r%rIrs'3 DKKM!Jr')rrr r! render_moderesetrr;r~ndarrayrrryrr rrXrE)r#r$ render_onlyrrpixels pixel_spacers` `` r%r!AddRenderObservation.__init__ts& ''00 #! 1 *s'/III !j&D&DDDjjQS BHHU #I ) )#$;y * --v{{ ; ;S%:%:%A%A%F%F%HH HH [IC,A,A,H,HII ! ) )C"+ *  #//[II ! ) )J"+ * r'r3N)Trstate)r$r+rrrr<rr<rdr3r'r%rrEsC)\!" : &:: :  ::r'rcJ\rSrSrSrS S SjjrSrSrSrSr Sr g ) riaUniformly discretizes a continuous Box observation space into a single Discrete space. Example 1 - Discretize MountainCar observation space: >>> env = gym.make("MountainCar-v0") >>> env.observation_space Box([-1.2 -0.07], [0.6 0.07], (2,), float32) >>> obs, _ = env.reset(seed=42) >>> obs array([-0.4452088, 0. ], dtype=float32) >>> env = DiscretizeObservation(env, bins=10) >>> env.observation_space Discrete(100) >>> obs, _ = env.reset(seed=42) >>> obs 45 Example 2 - Discretize LunarLander observation space: >>> env = gym.make("LunarLander-v3") >>> env.observation_space Box([ -2.5 -2.5 -10. -10. -6.2831855 -10. -0. -0. ], [ 2.5 2.5 10. 10. 6.2831855 10. 1. 1. ], (8,), float32) >>> obs, _ = env.reset(seed=42) >>> obs array([ 0.00229702, 1.4181306 , 0.2326471 , 0.3204666 , -0.00265488, -0.05269805, 0. , 0. ], dtype=float32) >>> env = DiscretizeObservation(env, bins=3) >>> env.observation_space Discrete(6561) >>> obs, _ = env.reset(seed=42) >>> obs 4005 Example 3 - Discretize LunarLander observation space with MultiDiscrete: >>> env = gym.make("LunarLander-v3") >>> env.observation_space Box([ -2.5 -2.5 -10. -10. -6.2831855 -10. -0. -0. ], [ 2.5 2.5 10. 10. 6.2831855 10. 1. 1. ], (8,), float32) >>> obs, _ = env.reset(seed=42) >>> obs array([ 0.00229702, 1.4181306 , 0.2326471 , 0.3204666 , -0.00265488, -0.05269805, 0. , 0. ], dtype=float32) >>> env = DiscretizeObservation(env, bins=3, multidiscrete=True) >>> env.observation_space MultiDiscrete([3 3 3 3 3 3 3 3]) >>> obs, _ = env.reset(seed=42) >>> obs array([1, 2, 1, 1, 1, 1, 0, 0]) c [UR[R5(d [ S5eURR UlURR UlUR RSUl[R"[R"UR 55(d9[R"[R"UR 55(a%[SUR SUR 35eX0l [RR R#XS9 [R$R#X5 [U[&5(a*[R("U/UR-5UlOT[-U5UR:Xd SURS[-U535e[R("U5Ul[/UR5Vs/sHHn[R0"UR UUR UUR*US-5SS PMJ snUlUR(a&[R4"UR*5Ulg [R6"[R8"UR*55Ulg s snf) zConstructor for the discretize observation wrapper. Args: env: The environment to wrap. bins: int or tuple of ints (number of bins per dimension). multidiscrete: If True, use MultiDiscrete space instead of flattening to Discrete. zJDiscretizeObservation is only compatible with Box continuous observations.rzCDiscretization requires observation space to be finite. Found: low=z, high=)binsz,bins must match action dimensions: expected z, got rurpN)r;rrrrVrwrxryn_dimsr~rZisinfr[ multidiscreterrr r!r"rMrrrPrangelinspace bin_edgesrrr)r#r$rris r%r!DiscretizeObservation.__init__s#//<<\ ((,,)).. hhnnQ' 66"((488$ % %0C)D)D"hhZwtyyk;  + ''000A ''2 dC $$++!56DID T[[( ]=dkk]&QTUYQZP[\ ](DI4;;' ' KK TYYq\499Qr) r~cliprwrxrrrMdigitizerrrint64_flatten_indices)r#r)clippedrindicess r%r)!DiscretizeObservation.observations''+xxT1ABEJ4;;EW EWC GJq(9: ;EW     88G2884 4t,,W56 6  s9CcHUR(a[R"U[S9nOUR U5n/n/n[ U5HpupV[R "URUURUURUS-5nURXv5 URXvS-5 Mr [R"X0RRRS9[R"X@RRRS94$)z_Reverts discretization. It returns the edges of the bin the discretized observation belongs to.rru)rr~asarrayrM_unflatten_index enumeraterrwrxrappendrr$rrz)r#rHrlowshighsridxedgess r%revert_observation(DiscretizeObservation.revert_observation*s   jjC0G++C0G(FAKK TYYq\499Q$>$D$DErxx 3399H   r'crSn[UR5HnX RU-nX!U- nM U$Nr)rrr)r#r flat_indexrs r%r&DiscretizeObservation._flatten_indices:s> t{{#A ))A, &J !* $J$r'cr/n[UR5HnURSX-5 X-nM U$r)reversedrinsert)r#rrbs r%r&DiscretizeObservation._unflatten_indexAs9$))$A NN1jn -  J%r')rrrxrwrrrNr)r$r+rrrr) r-r.r/r0r1r!r)rrrr2r3r'r%rrsG1n$ 0I &0I$0I 0Id7  r'r)$r1 __future__rcollections.abcrrtypingrrnumpyr~ gymnasiumrrgymnasium.corer r r gymnasium.errorr __all__gymnasium.wrappers.utilsrr"rr r rrrrrrrrrr3r'r%r s #.;;2 16&>7G;<II##6&rtC'9:II##tCn% '9:II##% PM'9:II##M`D '9:II##D N2 '9:II##2 j/ '9:II##/ d@ '9:II##@ Fi'9:II##iXU'9:II##Ur'