hi.SrSSKJr SSKJrJrJr SSKJr SSK r SSK J r SSK rSSKJr SSKJrJr "S S \\ \ R(5rg) zUImplementation of a space that represents the cartesian product of `Discrete` spaces.) annotations)IterableMappingSequence)AnyN)NDArray)Discrete) MaskNDArraySpacec^\rSrSrSr\R SS4SU4Sjjjr\SSj5r \S5r SSSjjr SSjr SS jr SS jrSS jrS rSS jrSrSSjrSU4SjjrSrU=r$) MultiDiscreteaEThis represents the cartesian product of arbitrary :class:`Discrete` spaces. It is useful to represent game controllers or keyboards where each key can be represented as a discrete action space. Note: Some environment wrappers assume a value of 0 always represents the NOOP action. e.g. Nintendo Game Controller - Can be conceptualized as 3 discrete action spaces: 1. Arrow Keys: Discrete 5 - NOOP[0], UP[1], RIGHT[2], DOWN[3], LEFT[4] - params: min: 0, max: 4 2. Button A: Discrete 2 - NOOP[0], Pressed[1] - params: min: 0, max: 1 3. Button B: Discrete 2 - NOOP[0], Pressed[1] - params: min: 0, max: 1 It can be initialized as ``MultiDiscrete([ 5, 2, 2 ])`` such that a sample might be ``array([3, 1, 0])``. Although this feature is rarely used, :class:`MultiDiscrete` spaces may also have several axes if ``nvec`` has several axes: Example: >>> from gymnasium.spaces import MultiDiscrete >>> import numpy as np >>> observation_space = MultiDiscrete(np.array([[1, 2], [3, 4]]), seed=42) >>> observation_space.sample() array([[0, 0], [2, 2]]) Nc>Uc [S5e[R"U5Ul[R"UR[R5(d[SURS35e[R "XSS9UlUb[R "XBSS9UlO.[R"UR RUS9UlURRUR R:XdS5eUR S :R5(dS 5e[TU]1UR RURU5 g) aConstructor of :class:`MultiDiscrete` space. The argument ``nvec`` will determine the number of values each categorical variable can take. If ``start`` is provided, it will define the minimal values corresponding to each categorical variable. Args: nvec: vector of counts of each categorical variable. This will usually be a list of integers. However, you may also pass a more complicated numpy array if you'd like the space to have several axes. dtype: This should be some kind of integer type. seed: Optionally, you can use this argument to seed the RNG that is used to sample from the space. start: Optionally, the starting value the element of each class will take (defaults to 0). Nz@MultiDiscrete dtype must be explicitly provided, cannot be None.zInvalid MultiDiscrete dtype (z), must be an integer dtypeT)dtypecopyrz2start and nvec (counts) should have the same shaperz!nvec (counts) have to be positive) ValueErrornpr issubdtypeintegerarraynvecstartzerosshapeallsuper__init__)selfrrseedr __class__s Y/home/james-whalen/.local/lib/python3.13/site-packages/gymnasium/spaces/multi_discrete.pyrMultiDiscrete.__init__,s( =R XXe_  djj"**55/ |;VW HHTT:  %4@DJ$))//?DJ JJ    / @ ? @ / A ""$$I&II$ $**d;cUR$)z7Has stricter type than :class:`gym.Space` - never None.)_shapers r"rMultiDiscrete.shapeYs{{r$cg)zDChecks whether this space can be flattened to a :class:`spaces.Box`.Tr's r"is_np_flattenableMultiDiscrete.is_np_flattenable^sr$cUbUb[SUSU35eUbD[R"URXRUR S5UR S9$UbD[R"URX RUR S5UR S9$URRURR5UR-RUR 5UR -$)a\Generates a single random sample from this space. Args: mask: An optional mask for multi-discrete, expects tuples with a ``np.ndarray`` mask in the position of each action with shape ``(n,)`` where ``n`` is the number of actions and ``dtype=np.int8``. Only ``mask values == 1`` are possible to sample unless all mask values for an action are ``0`` then the default action ``self.start`` (the smallest element) is sampled. probability: An optional probability mask for multi-discrete, expects tuples with a ``np.ndarray`` probability mask in the position of each action with shape ``(n,)`` where ``n`` is the number of actions and ``dtype=np.float64``. Only probability mask values within ``[0,1]`` are possible to sample as long as the sum of all values is ``1``. Returns: An ``np.ndarray`` of :meth:`Space.shape` zIOnly one of `mask` or `probability` can be provided, actual values: mask=z, probability=maskr probability) rrr _apply_maskrrr np_randomrandomrastype)rr.r/s r"sampleMultiDiscrete.samplecs$   7[\`[aaop{o|}  88  yy$**fEjj  $88  ii]Sjj  NN))$))//:TYYFNN   r$c [U[R5(a[U[5(dSUS[ U535e[ U5[ U5:XdS[ U5S[ U535e[ XU5VVVs/sHupVnURXVXt5PM snnn$[R"[ U5[R5(dSUS[ U535e[U[R5(dS[ U535e[ U5U:XdS[ U5SU35eUS :XaUR[R:XdS UR35eUS :Hn[R"[R"US :HU55(d S U35e[R"U5(a5URR![R""U5S 5U-$U$US:XGa)UR[R$:XdSUR35e[R&"US :US :*5n[R"[R"US :HU55(d SU35e[R("[R*"U5S 5(dS[R*"U535eU[R*"U5- n URR![R""U5S XS9U-$[-SU35es snnnf)z=Returns a sample using the provided mask or probability mask.z-Expects the mask to be a tuple for sub_nvec (z), actual type: zKExpects the mask length to be equal to the number of actions, mask length: z, nvec length: z0Expects the sub_nvec to be an action, actually: z, z4Expects the sub mask to be np.ndarray, actual type: z , action: r.z4Expects the mask dtype to be np.int8, actual dtype: rz3Expects all masks values to 0 or 1, actual values: r/z7Expects the mask dtype to be np.float64, actual dtype: z?Expects all masks values to be between 0 and 1, actual values: z8Expects the sum of all mask values to be 1, actual sum: )pzUnsupported mask type: ) isinstancerndarraytupletypelenzipr0rrrint8r logical_oranyr1choicewherefloat64 logical_andisclosesumr) rsub_masksub_nvec sub_start mask_typenew_masknew_nvec new_startvalid_action_masknormalized_sub_masks r"r0MultiDiscrete._apply_masks h + +% j>xjHXY]^fYgXhi jx=C% K\]`ai]j\kkz{~@H|I{JK K 69Y5W5W1H   YJ5W  }} NBJJ   [ =hZr$x.IY Z [  bjj   S A$x.AQ R S  MX % } XY\]eYfXggqrzq{ | } %  "'') WEhnnEUV W)!)A 66 h!m->? PDXJO Pvv'((~~,,RXX6G-H-KLyXX  - '"**, ZHHXY Z, "x!|X] K 66 h!m->? \PQYPZ[ \::x ! ]I"&&QYJZI[\ ]#+RVVH-="= %%HH./2)<&  29+>??csM c[U[5(a[R"U5n[ [U[R 5=(a UR UR :H=(as UR[:g=(aY [R"URU:*5=(a/ [R"XR- UR:55$)z?Return boolean specifying if x is a valid member of this space.) r9rrrboolr:rrobjectrrr)rxs r"containsMultiDiscrete.containss a " " A q"** % 34::% 36! 3tzzQ' 3q::~ 12   r$cLUVs/sHo"R5PM sn$s snf)zCConvert a batch of samples from this space to a JSONable data type.)tolistrsample_nr4s r" to_jsonableMultiDiscrete.to_jsonables /77hF h777s!ctUVs/sH&n[R"U[RS9PM( sn$s snf)zCConvert a JSONable data type to a batch of samples from this space.r)rrint64rZs r" from_jsonableMultiDiscrete.from_jsonables-@HHxVrxx0xHHHs-5c[R"URS:g5(aSURSURS3$SURS3$)z,Gives a string representation of this space.rzMultiDiscrete(z, start=))rrArrr's r"__repr__MultiDiscrete.__repr__sI 66$**/ " "#DII;htzzl!D D {!,,r$cURUnURUnURS:Xa [X#S9nO[ X R US9nUR RRUR RlU$)z5Extract a subspace from this ``MultiDiscrete`` space.r)r) rrndimr r rr1 bit_generatorstate)rindexrrsubspaces r" __getitem__MultiDiscrete.__getitem__snyy 5! 99>2H$T::UCH261M1M1S1S((.r$cURRS:a[RR S5 [ UR5$)z-Gives the ``len`` of samples from this space.z>Getting the length of a multi-dimensional MultiDiscrete space.)rrggymloggerwarnr=r's r"__len__MultiDiscrete.__len__s5 99>>Q  JJOOP 499~r$c[[U[5=(a URUR:H=(a URUR:H=(aa [ R "URUR:H5=(a- [ R "URUR:H55$)z7Check whether ``other`` is equivalent to this instance.) rSr9r rrrrrr)rothers r"__eq__MultiDiscrete.__eq__s um , 2 ekk) 2 ekk) 2tyyEJJ./ 2tzzU[[01   r$c>[U5nSU;a[R"USUSS9US'[TU]U5 g)zUsed when loading a pickled space. This method has to be implemented explicitly to allow for loading of legacy states. Args: state: The new state rr&rrN)dictrrr __setstate__)rrir!s r"r{MultiDiscrete.__setstate__ s?U  % XXeHoU7^LE'N U#r$)rrr)rz$NDArray[np.integer[Any]] | list[int]rzstr | type[np.integer[Any]]r z int | np.random.Generator | Nonerz+NDArray[np.integer[Any]] | list[int] | None)returnztuple[int, ...])NN)r.tuple[MaskNDArray, ...] | Noner/r~r}zNDArray[np.integer[Any]]) rHz%MaskNDArray | tuple[MaskNDArray, ...]rIMaskNDArray | np.integer[Any]rJrrKstrr}zint | list[Any])rUrr}rS)r[z"Sequence[NDArray[np.integer[Any]]]r}list[Sequence[int]])r[rr}zlist[NDArray[np.integer[Any]]])rjzint | tuple[int, ...])rvrr}rS)riz-Iterable[tuple[str, Any]] | Mapping[str, Any])__name__ __module__ __qualname____firstlineno____doc__rr_rpropertyrr+r4r0rVr\r`rdrlrsrwr{__static_attributes__ __classcell__)r!s@r"r r s,<.0XX15=A +<2+<++</ +< ; +<+rs?["77 .5H$E'"**-.H$r$