h%SrSSKJr SSKrSSKrSSKrSSKrSSKrSSKJ r SSK rSSK r SSK r SSK Jr SSKJrJrJr SSKJrJr SSKJr SSKJr SS KJrJr SSKrSS KJrJrJ r J!r! SS K"J#r# SS K$J%r% \ RL"S 5r'/SQr("SS\5r)"SS\5r*\"SS55r+\"SS55r,"SS\5r-0r.S\/S'Sq0S\/S'S1Sjr1S2Sjr2S3Sjr3S4S jr4S5S!jr5S6S"jr6S7S#jr7S8S$jr8S9S%jr9S:S&jr:S;S'jr;\RxSS*jjr>S?S@S+jjr?SASBS,jjr@S9S-jrA\.4S.SS)S/.SCS0jjjrBg)DzsFunctions for registering environments within gymnasium using public functions ``make``, ``register`` and ``spec``.) annotationsN) defaultdict)CallableIterableSequence) dataclassfield)Enum) ModuleType)AnyProtocol)EnvWrappererrorlogger)warn) AutoresetModezM^(?:(?P[\w:-]+)\/)?(?:(?P[\w:.-]+?))(?:-v(?P\d+))?$) registrycurrent_namespaceEnvSpec WrapperSpec VectorizeModeregistermakemake_vecspecpprint_registry register_envsc"\rSrSrSrSSjrSrg) EnvCreator0*Function type expected for an environment.c gNselfkwargss U/home/james-whalen/.local/lib/python3.13/site-packages/gymnasium/envs/registration.py__call__EnvCreator.__call__3scr%Nr(r returnr__name__ __module__ __qualname____firstlineno____doc__r*__static_attributes__r%r,r)r r 0s41r,r c"\rSrSrSrSSjrSrg)VectorEnvCreator6r"c gr$r%r&s r)r*VectorEnvCreator.__call__9ssr,r%N)r(r r.gym.vector.VectorEnvr/r%r,r)r7r76s4Br,r7c8\rSrSr%SrS\S'S\S'S\S'Srg ) r<a A specification for recording wrapper configs. * name: The name of the wrapper. * entry_point: The location of the wrapper to create from. * kwargs: Additional keyword arguments passed to the wrapper. If the wrapper doesn't inherit from EzPickle then this is ``None`` strname entry_pointdict[str, Any] | Noner(r%N)r0r1r2r3r4__annotations__r5r%r,r)rr<s I !!r,rc\rSrSr%SrS\S'\"SS9rS\S'\"SS9rS \S '\"S S9r S \S '\"SS9r S\S'\"SS9r S \S'\"S S9r S \S'\"\ S9rS\S'\"S S9rS\S'\"S S9rS\S'\"S S9rS\S'\"\S9rS\S'\"SS9rS\S'SrS&S jrS'S!jr\S(S"j5r\S)S#j5rS*S+S$jjrS%rg),rJaA specification for creating environments with :meth:`gymnasium.make`. * **id**: The string used to create the environment with :meth:`gymnasium.make` * **entry_point**: A string for the environment location, ``(import path):(environment name)`` or a function that creates the environment. * **reward_threshold**: The reward threshold for completing the environment. * **nondeterministic**: If the observation of an environment cannot be repeated with the same initial state, random number generator state and actions. * **max_episode_steps**: The max number of steps that the environment can take before truncation * **order_enforce**: If to enforce the order of :meth:`gymnasium.Env.reset` before :meth:`gymnasium.Env.step` and :meth:`gymnasium.Env.render` functions * **disable_env_checker**: If to disable the environment checker wrapper in :meth:`gymnasium.make`, by default False (runs the environment checker) * **kwargs**: Additional keyword arguments passed to the environment during initialisation * **additional_wrappers**: A tuple of additional wrappers applied to the environment (WrapperSpec) * **vector_entry_point**: The location of the vectorized environment to create from Changelogs: v1.0.0 - Autoreset attribute removed r>idNdefaultEnvCreator | str | Noner@ float | Nonereward_thresholdFboolnondeterministic int | Nonemax_episode_stepsT order_enforcedisable_env_checker)default_factorydictr()init str | None namespacer?versiontuple[WrapperSpec, ...]additional_wrappersVectorEnvCreator | str | Nonevector_entry_pointcT[UR5uUlUlUlg)zcCalls after the spec is created to extract the namespace, name and version from the environment id.N) parse_env_idrErUr?rV)r's r) __post_init__EnvSpec.__post_init__ws2>tww2G/ 4. Currently, Gymnasium does not support serialising callables.N)itemscallable ValueError)env_spec spec_namekeyvalues r)reEnvSpec._check_can_jsonifysg)/((:HV$ "..*JC ( 5=STYSZ[YZ+r,c\[R"U5n/nURS5HnUR[ S0UD65 M [S0UD6n[U5Ul U$![ an[ SUS35UeSnAff=f![ an[ SUS35UeSnAff=f)zConverts a JSON string into a specification stack. Args: json_env_spec: A JSON string representing the env specification. Returns: An environment spec rXz&An issue occurred when trying to make z a WrapperSpecNz an EnvSpecr%) rfloadsrdappendr ExceptionrnrtuplerX) json_env_specparsed_env_specapplied_wrapper_specswrapper_spec_jsoneros r) from_jsonEnvSpec.from_jsons**]335!0!4!45J!K  %,,[-M;L-MN"L 11H+01F+GH (   <=N"a'443CHH^4L3MSQQ M &Mr,)r?rUrVr-)r.r>)rodict[str, Any])ryr>r.r)FFF)rrKrrKrrKr.rT)r0r1r2r3r4rBr r@rJrLrNrOrPrRr(rUr?rVrxrXrZr]rri staticmethodrer~rr5r%r,r)rrJsK" G+0+>K(>&+4%8l8"51d1%*$$7z7-M4- %e 44.FD."u-Iz-5!D#!U+GZ+493O0O9>d8K5KH$)""@$%* 44#4 4  44r,rc$\rSrSrSrSrSrSrSrg)rz4All possible vectorization modes used in `make_vec`.asyncsyncrZr%N) r0r1r2r3r4ASYNCSYNCVECTOR_ENTRY_POINTr5r%r,r)rrs> E D-r,rdict[str, EnvSpec]rrTrc[RU5nU(d[R"SUS35eUR SSS5up#nUb [ U5nX#U4$)aGParse environment ID string format - ``[namespace/](env-name)[-v(version)]`` where the namespace and version are optional. Args: env_id: The environment id to parse Returns: A tuple of environment namespace, environment name and version number Raises: Error: If the environment id is not valid environment regex zMalformed environment ID: zd. (Currently all IDs must be of the form [namespace/](env-name)-v(version). (namespace is optional))rUr?rV) ENV_ID_RE fullmatchrErrorgroupint)env_idmatchnsr?rVs r)r\r\sn    'E kk(1U V   KCBgg, W r,c2UnUbUSU3nUbUSU3nU$)zGet the full env ID given a name and (optional) version and namespace. Inverse of :meth:`parse_env_id`. Args: ns: The environment namespace name: The environment name version: The environment version Returns: The environment id /z-vr%)rr?rV full_names r) get_env_idrs9I ~d!D6N  kG9- r,c[R5Vs/sHBnURU:XdMURU:XdM'URcM6URPMD nn[ USS9$s snf)a)Finds the highest registered version of the environment given the namespace and name in the registry. Args: ns: The environment namespace name: The environment name (id) Returns: The highest version of an environment with matching namespace and name, otherwise ``None`` is returned. NrF)rvaluesrUr?rVmax)rr?rorVs r)find_highest_versionr1sx!))H    #  MMT !     )  w %%sA,A, A,A,cLUcg[R5Vs1sHnURcMURiM nnX;ag[U5S:a[R "XSS9OSnU(a SUSS3nOSUS3n[ R"S US U35es snf) zJCheck if a namespace exists. If it doesn't, print a helpful error message.NrnzDid you mean: ``?z*Have you installed the proper package for ?z Namespace z not found. )rrrUrdifflibget_close_matchesrNamespaceNotFound)rro namespaces suggestionsuggestion_msgs r)_check_namespace_existsrEs z !))H    )  ;>j/A:M!!"A6SW*:a=/<EbTK  ! !Jrd,~>N"O PP#s B!B!cT[U5 [R5Vs1sH o"RU:XdMURiM" nnX;ag[ R "XSS9nU(aSU3OSnU(a SUSS3OSn[R"S US US U35es snf) zTCheck if an env exists in a namespace. If it doesn't, print a helpful error message.Nrrz in namespace z Did you mean: `rrz Environment `z` doesn't exist.) rrrrUr?rrr NameNotFound)rr?ronamesr namespace_msgrs r)_check_name_existsr`sB'/oo&7&7(;M;MQS;S  &7  }**4![UR=(d S5$)NrrVros r)'_check_version_exists..ss8;K;K;Qr7Rr,)rqz" It provides the default version `r`.rcUR$r$rVrs r)rrs H(_check_version_exists..s $Xi(r(*:*:);1%=isz' It provides versioned environments: [ z ].zEnvironment version vz for `z` is deprecated. Please use `z ` instead.)rrrrrUr?sortedrVrErr DeprecatedEnvrrVersionNotFound) rr?rVmessagero env_specs default_specversioned_specs latest_specversion_list_msgs r)_check_version_existsrvs"G$0r &wi/B:bX\C]B^^noG!))H    # (0 (= ) y&RSI-6SY:J:JHYLS7 Q8J8J7K2NN y>Q %%g. . "+!*X.>.>o+LVZ[K7-@-@#@99$Xi$XX<=M>** 6  $A7Ts*F*&F*8F*F/#F/1F4F4c^[U4Sj[R55SSS9n[U4Sj[R55S5nUb>TRb1[ R "STRSURS35eUb?TRc1[ R "S TRS URS 35egg) zRChecks whether the spec is valid to be registered. Helper function for `register`.c3># UHNnURTR:XdMURTR:XdM;URcMJUv MP g7fr$rUr?rVrro testing_specs r)r'_check_spec_register..W -!!\%;%;;  !2!22   H-AA A Ac,[UR5$r$r)spec_s r)r&_check_spec_register..s #emm,r,Nrc3># UHNnURTR:XdMURTR:XdM;URbMJUv MP g7fr$rrs r)rrrrz*Can't register the versioned environment `z$` when the unversioned environment `z"` of the same name already exists.z,Can't register the unversioned environment `z"` when the versioned environment `z` of the same name already exists. Note: the default behavior is that `gym.make` with the unversioned environment will return the latest versioned environment)rrrnextrVrRegistrationErrorrE)rlatest_versioned_specunversioned_specs` r)_check_spec_registerrs $OO-  -  $OO-   # (<(<(H%%  ! ##$$F H   *|/C/C/K%%:split importlib import_moduleModuleNotFoundErrorrrr\rr deprecationrrrrr) rmoduleenv_namer}rorr?rVlatest_version new_env_ids r) _find_specrs{ fc " "" "*-F):f~ S@QF    # #F +||H%H%X.Bg)"3N~9n>Vxj)&&4%5R 9 >5 '2 << + 6zlC77?j D b0kk)(4@ A   OC# %#""()Y[  sD D7 D22D7cnURS5up[R"U5n[X25nU$)aLoads an environment with name of style ``"(import path):(environment name)"`` and returns the environment creation function, normally the environment class type. Args: name: The environment name Returns: The environment constructor for the given environment name. r)rrrgetattr)r?mod_name attr_namemodfns r)load_env_creatorrs3**S/H  ! !( +C  B Ir,cg)zGA No-op function such that it can appear to IDEs that a module is used.Nr%) env_modules r)rr%sr,c#(# [nUqSv Uqg7f)z4Context manager for modifying the current namespace.N)r)r old_namespaces r)rUrU*s&M %sFc Uc UcS5e[U5upn U c [5n [bbU RS5bIU RS5[:wa0[R "SU RS5S[S35 [n OU n [ XU 5n[UUUUUUUU UUS9 n[U5 UR[;a$[R "SURS 35 U[UR'g) a\Registers an environment in gymnasium with an ``id`` to use with :meth:`gymnasium.make` with the ``entry_point`` being a string or callable for creating the environment. The ``id`` parameter corresponds to the name of the environment, with the syntax as follows: ``[namespace/](env_name)[-v(version)]`` where ``namespace`` and ``-v(version)`` is optional. It takes arbitrary keyword arguments, which are passed to the :class:`EnvSpec` ``kwargs`` parameter. Args: id: The environment id entry_point: The entry point for creating the environment reward_threshold: The reward threshold considered for an agent to have learnt the environment nondeterministic: If the environment is nondeterministic (even with knowledge of the initial seed and all actions, the same state cannot be reached) max_episode_steps: The maximum number of episodes steps before truncation. Used by the :class:`gymnasium.wrappers.TimeLimit` wrapper if not ``None``. order_enforce: If to enable the order enforcer wrapper to ensure users run functions in the correct order. If ``True``, then the :class:`gymnasium.wrappers.OrderEnforcing` is applied to the environment. disable_env_checker: If to disable the :class:`gymnasium.wrappers.PassiveEnvChecker` to the environment. additional_wrappers: Additional wrappers to apply the environment. vector_entry_point: The entry point for creating the vector environment kwargs: arbitrary keyword arguments which are passed to the environment constructor on initialisation. Changelogs: v1.0.0 - `autoreset` and `apply_api_compatibility` parameter was removed NzGEither `entry_point` or `vector_entry_point` (or both) must be providedrUzCustom namespace `z$` is being overridden by namespace `z`. If you are developing a plugin you shouldn't specify a namespace in `register` calls. The namespace is specified through the entry point package metadata. rEr@rJrLrNrOrPr(rXrZzOverriding environment z already in registry.) r\rRrrrrrrrrEr)rEr@rJrLrNrOrPrXrZr(rr?rVns_id full_env_idnew_specs r)rr4sH #5#AQPQA$R(Bg ~$ JJ{ # / ;'+<< KK$VZZ %<$==absatuWW  "U'2K ))+#//- H"{{h -hkk]:OPQ$HX[[r,c L [U[5(a4Un[US5(d [R"SU35 SUlO"[U[ 5(de[U5n[U[5(de[R"UR5nURU5 URc#[R"URS35e[!UR5(a URnO[#UR5nSn[US5(a0[%UR&5 UR&R)S5nUR)S5nS n S n UbUbX;aS S 1R+U5n US :Xa;[-U 5S :a,[R"S5 U R/5US'Sn O\UR1S5(a(US[-S5*U;aUS[-S5*US'Sn O[R"SU<SUS35 U"S0UD6n [U [8R:5(di[ U R<R>5S:Xd#[ U R<R>5S:Xa [3S5e[3S[7U 5S35e[URURUR@URBSS SUSURDS9 U RFl$U RHce[-U RHR 5nUR SUU RHR :waC[KUR U RHR 5Hunn[MS US!U35e US LdUc.URNS La[8RPRSU 5n URT(a[8RPRWU 5n US":waYUb [8RPRYX5n O6URZb)[8RPRYXRZ5n UR USHOnURc[MUR\S#35e[#UR5"SS$U 0URD6n MQ U (a![8RPR_U 5n U $U (a[8RPRaU 5n U $![2asn [ U 5R5S5S :a,U (a%[R"SURS35U e[7U 5"U SURSUS35eSn A ff=f)%aCreates an environment previously registered with :meth:`gymnasium.register` or a :class:`EnvSpec`. To find all available environments use ``gymnasium.envs.registry.keys()`` for all valid ids. Args: id: A string for the environment id or a :class:`EnvSpec`. Optionally if using a string, a module to import can be included, e.g. ``'module:Env-v0'``. This is equivalent to importing the module first to register the environment followed by making the environment. max_episode_steps: Maximum length of an episode, can override the registered :class:`EnvSpec` ``max_episode_steps`` with the value being passed to :class:`gymnasium.wrappers.TimeLimit`. Using ``max_episode_steps=-1`` will not apply the wrapper to the environment. disable_env_checker: If to add :class:`gymnasium.wrappers.PassiveEnvChecker`, ``None`` will default to the :class:`EnvSpec` ``disable_env_checker`` value otherwise use this value will be used. kwargs: Additional arguments to pass to the environment constructor. Returns: An instance of the environment with wrappers applied. Raises: Error: If the ``id`` doesn't exist in the :attr:`registry` Changelogs: v1.0.0 - `autoreset` and `apply_api_compatibility` was removed rXzhThe env spec passed to `make` does not have a `additional_wrappers`, set it to an empty tuple. Env_spec=r%Nz, registered but entry_point is not specifiedrr render_modeF rgb_arrayrgb_array_listhumanrzYou are trying to use 'human' rendering for an environment that doesn't natively support it. The HumanRendering wrapper is being applied to your environment.T_listz6The environment is being initialised with render_mode=z+ that is not in the possible render_modes ().z0got an unexpected keyword argument 'render_mode'z(You passed render_mode='human' although z doesn't implement human-rendering natively. Gym tried to apply the HumanRendering wrapper but it looks like your environment is using the old rendering API, which is not supported by the HumanRendering wrapper.z- was raised from the environment creator for z with kwargs ()zzzGym is incompatible with Gymnasium, please update the environment class to `gymnasium.Env`. See https://gymnasium.farama.org/introduction/create_custom_env/ for more info.zIThe environment must inherit from the gymnasium.Env class, actual class: zQ. See https://gymnasium.farama.org/introduction/create_custom_env/ for more info.r zThe environment's wrapper spec z: is different from the saved `EnvSpec` additional wrapper rzs wrapper does not inherit from `gymnasium.utils.RecordConstructorArgs`, therefore, the wrapper cannot be recreated.env)1rrhasattrrrrXr>rcopydeepcopyr(updater@rrrErmrrrr intersectionrrdendswith TypeErrorfindrgymr __class____base__rJrLrZ unwrappedrziprnrPwrappersPassiveEnvCheckerrOOrderEnforcing TimeLimitrNr?HumanRenderingRenderCollection)rErNrPr(roenv_spec_kwargs env_creatorrrapply_human_renderingapply_render_collectiondisplayable_modesrr}num_prior_wrappersenv_spec_wrapper_specrecreated_wrapper_specrs r)rrs:"gx!677 KKz|D{EF ,.H ("c""""b> h ( (( (mmHOO4O6"#kkX[[M)UVWW (&& ' '** 'x';';< &*L{J'' ,,-"++//? !%%m4K!#   $  +(*:;HHV ' !c*;&A  ( (#((*F*F> 9 !#912H1IJDEZD[\ > e##(D(D(Mll,,S1ll))#.B  (,,((@C  ' ' 3,,((.H.HIC 445G5HI    &$$%&YZ |778XSXLDWDWX Jll))#. J !ll++C0 Js   FKKJ Kq P%++:8;;-HWW   q'#B8;;-~^m]nnop  s4T&& V#0A.VV#c  ^^ ^ ^Uc0nTc/m[U[5(aUm OD[U[5(a [U5m O#[R "S[ U5S35e[R"T 5m T Rm[5T l TRSU5nTRSU5nTRSU5nTRST5mTRU5 Uc/T Rb[RnO[R nO [U5n[U[5(deSU UU4S jjm U[R :XahT R&c$[R "S T R(S 35e[*R,R."SS U 4S j[1U550UD6nGOU[R2:XaoT R&c$[R "S T R(S 35e[*R,R4"SS [1U5Vs/sHnT PM sn0UD6nGO1U[R:XGa[7U5S:a[R "SUS35e[7T5S:a[R "STS35e[7T R85S:a$[R "ST R8S35eT Rn U c[R "S US35e[;U 5(aU n O [=U 5n T R>bST;aT R>TS'U "SSU0TD6nO[R "SU35e[R"T 5n TR5U l US:waXRS'UR$U RS'[7U5S:aX;RS'[7T5S:aTU RS'XR@l!SURD;a[GSUSURD35 U$[URDS[H5(d([GSUS[ URDS5S35 U$!["a7 [#SU<S[Vs/sHofR$PM Os snfsn35ef=fs snf)a^Create a vector environment according to the given ID. To find all available environments use :func:`gymnasium.pprint_registry` or ``gymnasium.registry.keys()`` for all valid ids. We refer to the Vector environment as the vectorizor while the environment being vectorized is the base or vectorized environment (``vectorizor(vectorized env)``). Args: id: Name of the environment. Optionally, a module to import can be included, e.g. 'module:Env-v0' num_envs: Number of environments to create vectorization_mode: The vectorization method used, defaults to ``None`` such that if env id' spec has a ``vector_entry_point`` (not ``None``), this is first used otherwise defaults to ``sync`` to use the :class:`gymnasium.vector.SyncVectorEnv`. Valid modes are ``"async"``, ``"sync"`` or ``"vector_entry_point"``. Recommended to use the :class:`VectorizeMode` enum rather than strings. vector_kwargs: Additional arguments to pass to the vectorizor environment constructor, i.e., ``SyncVectorEnv(..., **vector_kwargs)``. wrappers: A sequence of wrapper functions to apply to the base environment. Can only be used in ``"sync"`` or ``"async"`` mode. **kwargs: Additional arguments passed to the base environment constructor. Returns: An instance of the environment. Raises: Error: If the ``id`` doesn't exist then an error is raised zInvalid id type: z. Expected `str` or `EnvSpec`num_envsvectorization_mode vector_kwargsr%zInvalid vectorization mode: z, valid modes: ch>[T40TR5D6nTcU$TH nU"U5nM U$r$)rr) single_envwrapperror+r%s r)create_single_env#make_vec..create_single_envsA(=o&:&:&<=   G ,J r,z)Cannot create vectorized environment for z0 because it doesn't have an entry point defined.env_fnsc3(># UHnTv M g7fr$r%)r_r:s r)rmake_vec..s@1&srzhCustom vector environment can be passed arguments only through kwargs and `vector_kwargs` is not empty (rzOCannot use `vector_entry_point` vectorization mode with the wrappers argument (rzsCannot use `vector_entry_point` vectorization mode with the additional_wrappers parameter in spec being not empty (z6 because it doesn't have a vector entry point defined.rNzUnknown vectorization mode: rautoreset_modezThe VectorEnv (z.) is missing AutoresetMode metadata, metadata=zB) metadata['autoreset_mode'] is not an instance of AutoresetMode, r)r.rr%)%rrr>rrrrrrr(rRrdrrZrrrrnrrr@rEr vector SyncVectorEnvrangerAsyncVectorEnvrrXrmrrNr#rrrr)rEr4r5r6r%r(moderr>r@r,copied_id_specr:ror+s ` @@@r)rr;s: "g B  b>kk-d2hZ7TUVV}}X&HooOfHO"":x8H(,,-ACUV#''GM"":x8H6"!  & & 2!.!A!A !.!3!3  !./A!B  (- 8 88 8]///    '++;HKK=Hxy jj&& @h@   }22 2    '++;HKK=Hxy jj'' 05h@1&@   }?? ? }  !++z|I{JJKL ]Q ++abjakkmn -- . 2++FGOGcGcFddfg 11  ++;B4?uv k " "%K*;7K  & & 2#?:3;3M3MO/ 0?8??kk89K8LMNN]]8,N+002N1},4j)2D2J2JN./ =A1>o. 8}q,4j)'MMs||+ cU"PQTQ]Q]P^ _  J  %56 F F cU"deijmjvjvxHkIfJeKKL M  J{ ./A.DE 8E F  FGI  DAs( R > S$ S!<SS!c[RU5nUc3[U5up#n[X#U5 [R "SU35e[ U[5(dSUS[U535eU$)aRetrieve the :class:`EnvSpec` for the environment id from the :attr:`registry`. Args: env_id: The environment id with the expected format of ``[(namespace)/]id[-v(version)]`` Returns: The environment spec if it exists Raises: Error: If the environment id doesn't exist rzExpected the registry for z$ to be an `EnvSpec`, actual type is ) rrr\rrrrrr)rrorr?rVs r)rrs||F#H(0'b0kk7x@AA g   e 'x/STXYaTbSc d e r,)num_colsexclude_namespacesrc[[5n[S5nUR5HnURnUc[ UR [5(ai[R"SSUR 5nURS5n [U 5S:aU SnO![U 5S:aU SnO URnXGRUR5 [U[UR55nM /n UR!5Hup{UbXr;aMS S US S S 3n [#[%U 5S5HLupXR'U5S -- n X-S :XdM%U R)S 5n U [U 5:wdMGU S - n MN U RU R)S 55 M U(aS R+U 5$[-S R+U 55 g) aPretty prints all environments in the :attr:`registry`. Note: All arguments are keyword only Args: print_registry: Environment registry to be printed. By default, :attr:`registry` num_cols: Number of columns to arrange environments in, for display. exclude_namespaces: A list of namespaces to be excluded from printing. Helpful if only ALE environments are wanted. disable_print: Whether to return a string of all the namespaces and environment IDs or to print the string to console. z-infNz:\w+rrrHrz=====  r)rrfloatrrUrr@r>resubrrr?rvrErrl enumeraterljustrstriprr)print_registryrIrJrnamespace_envs max_justifyrorenv_entry_pointsplit_entry_pointrenv_idsnamespace_outputcountrs r)rrs(,7t+r.z"tuple[str | None, str, int | None])rrTr?r>rVrMr.r>)rrTr?r>r.rM)rrT)rrTr?r>)rrTr?r>rVrM)rr)rr)rr>r.r)r?r>r.zEnvCreator | VectorEnvCreator)rr )rr>) NNFNTFr%NN)rEr>r@rHrJrIrLrKrNrMrOrKrPrKrXrWrZrYr(z dict | None)NN) rE str | EnvSpecrNrMrPz bool | Noner(r r.r)rNNN) rEr]r4rr5zVectorizeMode | str | Noner6rAr%z)Sequence[Callable[[Env], Wrapper]] | Noner.r;) rUrrIrrJzlist[str] | NonerrKr.rT)Cr4 __future__r contextlibrrbrrimportlib.metadatarimportlib.utilrfrP collectionsrcollections.abcrrrrr enumr typesr typingr r gymnasiumr rrrrgymnasium.loggerrgymnasium.vectorrcompiler__all__r r7rrrrrBrr\rrrrrrrrrrcontextmanagerrUrrrrrr%r,r)rmsy" % #88( 11!* JJT   22 CxC   " "  " jj jZ.D. " ! $:$0(&(Q6,7 t$ N $*Z   &&,0%)"$( %358<I% I%(I%#I% I% " I%  I%I%1I%6I% I%\%)'+xx!x%x x  xz59+/:> [[[3[) [ 8 [[|2*2J!+/ J!&J!J!) J!  J!  J!r,