
    nic                        S r SSKrSSKrSSKrSSKr\R
                  R                  \R
                  R                  \R                  " \R                  " 5       5      5      5      r
\R
                  R                  \R
                  R                  \
5      5      r\R                  R
                  R                  S\5        SSKrSSKJr  SSKJr  SSKrSSKrSSKJr  SSKrSSKJr  SSKJr  SSKJr  SS	KJr  SS
KJr  SSKJr  SSK J!r!  Sr"Sr#\#\"-   r$\$\"-   r%\%\"-   r&Sr'Sr(Sr)Sr*\RV                  r+Sr,Sr-Sr.Sr/\,\R`                  \-\Rb                  \.\Rd                  0r3S r4 " S S\Rj                  5      r6g)z7This file implements the gym environment of minitaur.

    N)spaces)seeding)bullet_client)minitaur)minitaur_derpy)minitaur_logging)minitaur_logging_pb2)minitaur_rainbow_dash)motor)parse_version   {Gz?ih  i  defaultderpy_v0rainbow_dash_v0i,  c                 D     [        U 5        U $ ! [         a    U /s $ f = fN)iter	TypeError)objs    f/home/james-whalen/.local/lib/python3.13/site-packages/pybullet_envs/minitaur/envs/minitaur_gym_env.pyconvert_to_listr   1   s)    IJ	 5Ls    c                      \ rS rSrSrSS/SS.r\R                  " 5       SSS	S
S
\" S5      \	S\
R                  SSSSSSS
S
SSSSSSSSS\" S5      SS4S jrS rS rS.S jrS/S jrS rS rS0S jrS rS rS rS rS rS rS rS  r\S! 5       rS" rS# rS$ r S% r!S& r"\#" \$RJ                  5      \#" S'5      :  a  \r&\r'\r(\r)S1S( jr*\S) 5       r+\S* 5       r,\,RZ                  S+ 5       r,\S, 5       r.S-r/g)2MinitaurGymEnv9   ac  The gym environment for the minitaur.

It simulates the locomotion of a minitaur, a quadruped robot. The state space
include the angles, velocities and torques for all the motors and the action
space is the desired motor angle for each motor. The reward function is based
on how far the minitaur walks in 1000 steps and penalizes the energy
expenditure.

human	rgb_arrayd   )zrender.modeszvideo.frames_per_secondN      ?g{Gzt?        infTFg{Gz?i     c                 >   UU l         [        R                  " U5      U l        Ub  UU l        UU l        UU-  U l        OIU(       d  U(       a  SU l        SU l        OSU l        SU l        U R                  U R
                  -  U l        [        [        U R
                  -  5      U l	        Xl
        Xl        Xl        / U l        / U l        / U l        X4Xe/U l        SU l        UU l        UU l        / SQU l        X0l        X@l        X`l        XPl        Xpl        Xl        SU l        Xl        Xl        Xl        Xl        Xl         UU l!        UU l"        UU l#        UU l$        SU l%        SU l&        S	U l'        UU l(        S
U l)        SU l*        UU l+        UU l,        X l-        SU l.        UU l/        U(       a  [a        U5      O/ U l1        [d        Rf                  " 5       U l4        U R&                  (       a(  [j        Rl                  " [n        Rp                  S9U l9        O[j        Rl                  " 5       U l9        U RZ                  c  [t        U l-        U Rr                  Rw                  SS9  U Ry                  5         U R{                  5         U R}                  5       [~        -   nU R                  5       [~        -
  n [        n![        R                  " U R6                  /U!-  5      n"[        R                  " U"* U"5      U lF        [        R                  " U U5      U lG        SU lH        UU l)        g)a  Initialize the minitaur gym environment.

Args:
  urdf_root: The path to the urdf data folder.
  urdf_version: [DEFAULT_URDF_VERSION, DERPY_V0_URDF_VERSION,
    RAINBOW_DASH_V0_URDF_VERSION] are allowable
    versions. If None, DEFAULT_URDF_VERSION is used. DERPY_V0_URDF_VERSION
    is the result of first pass system identification for derpy.
    We will have a different URDF and related Minitaur class each time we
    perform system identification. While the majority of the code of the
    class remains the same, some code changes (e.g. the constraint location
    might change). __init__() will choose the right Minitaur class from
    different minitaur modules based on
    urdf_version.
  distance_weight: The weight of the distance term in the reward.
  energy_weight: The weight of the energy term in the reward.
  shake_weight: The weight of the vertical shakiness term in the reward.
  drift_weight: The weight of the sideways drift term in the reward.
  distance_limit: The maximum distance to terminate the episode.
  observation_noise_stdev: The standard deviation of observation noise.
  self_collision_enabled: Whether to enable self collision in the sim.
  motor_velocity_limit: The velocity limit of each motor.
  pd_control_enabled: Whether to use PD controller for each motor.
  leg_model_enabled: Whether to use a leg motor to reparameterize the action
    space.
  accurate_motor_model_enabled: Whether to use the accurate DC motor model.
  remove_default_joint_damping: Whether to remove the default joint damping.
  motor_kp: proportional gain for the accurate motor model.
  motor_kd: derivative gain for the accurate motor model.
  control_latency: It is the delay in the controller between when an
    observation is made at some point, and when that reading is reported
    back to the Neural Network.
  pd_latency: latency of the PD controller loop. PD calculates PWM based on
    the motor angle and velocity. The latency measures the time between when
    the motor angle and velocity are observed on the microcontroller and
    when the true state happens on the motor. It is typically (0.001-
    0.002s).
  torque_control_enabled: Whether to use the torque control, if set to
    False, pose control will be used.
  motor_overheat_protection: Whether to shutdown the motor that has exerted
    large torque (OVERHEAT_SHUTDOWN_TORQUE) for an extended amount of time
    (OVERHEAT_SHUTDOWN_TIME). See ApplyAction() in minitaur.py for more
    details.
  hard_reset: Whether to wipe the simulation and load everything when reset
    is called. If set to false, reset just place the minitaur back to start
    position and set its pose to initial configuration.
  on_rack: Whether to place the minitaur on rack. This is only used to debug
    the walking gait. In this mode, the minitaur's base is hanged midair so
    that its walking gait is clearer to visualize.
  render: Whether to render the simulation.
  num_steps_to_log: The max number of control steps in one episode that will
    be logged. If the number of steps is more than num_steps_to_log, the
    environment will still be running, but only first num_steps_to_log will
    be recorded in logging.
  action_repeat: The number of simulation steps before actions are applied.
  control_time_step: The time step between two successive control signals.
  env_randomizer: An instance (or a list) of EnvRandomizer(s). An
    EnvRandomizer may randomize the physical property of minitaur, change
      the terrrain during reset(), or add perturbation forces during step().
  forward_reward_cap: The maximum value that forward reward is capped at.
    Disabled (Inf) by default.
  log_path: The path to write out logs. For the details of logging, refer to
    minitaur_logging.proto.
Raises:
  ValueError: If the urdf_version is not supported.
NgMb`?   r   r"   r   r   r   r   r   iTr    )connection_modeenableConeFriction)I	_log_pathr   MinitaurLoggingloggingcontrol_time_step_action_repeat
_time_stepintNUM_SIMULATION_ITERATION_STEPS_num_bullet_solver_iterations
_urdf_root_self_collision_enabled_motor_velocity_limit_observation_true_observation_objectives_objective_weights_env_step_counter_num_steps_to_log
_is_render_last_base_position_distance_weight_energy_weight_drift_weight_shake_weight_distance_limit_observation_noise_stdev_action_bound_pd_control_enabled_leg_model_enabled_accurate_motor_model_enabled_remove_default_joint_damping	_motor_kp	_motor_kd_torque_control_enabled_motor_overheat_protection_on_rack	_cam_dist_cam_yaw
_cam_pitch_forward_reward_cap_hard_reset_last_frame_time_control_latency_pd_latency_urdf_version
_ground_id_reflectionr   _env_randomizersr	   MinitaurEpisode_episode_protobcBulletClientpybulletGUI_pybullet_clientDEFAULT_URDF_VERSIONsetPhysicsEngineParameterseedreset_get_observation_upper_boundOBSERVATION_EPS_get_observation_lower_bound
NUM_MOTORSnparrayr   Boxaction_spaceobservation_spaceviewer)#self	urdf_rooturdf_versiondistance_weightenergy_weightshake_weightdrift_weightdistance_limitobservation_noise_stdevself_collision_enabledmotor_velocity_limitpd_control_enabledleg_model_enabledaccurate_motor_model_enabledremove_default_joint_dampingmotor_kpmotor_kdcontrol_latency
pd_latencytorque_control_enabledmotor_overheat_protection
hard_reseton_rackrendernum_steps_to_logaction_repeatr,   env_randomizerforward_reward_cap
reflectionlog_pathobservation_highobservation_low
action_dimaction_highs#                                      r   __init__MinitaurGymEnv.__init__E   s   D DN#33H=DL$0d)d)M9do 
&);#1D1DDd),-KdNaNa-a)bD&O#9 !5DDD.|ZDD-DDO(D+'%%)$;!D1/)E&)E&NDN#9D &?D#DMDNDMDO1DDD+D!D%DO!D?MON;SUD.>>@D oohllKd oo/d!/d33q3IIIKJJL99;oM88:_LOJ((D../*<=K

K<=D#ZZ9IJDDK!D    c                     U R                   S:  a%  U R                  R                  U R                  5        U R                  R                  5         g )Nr   )r9   r+   save_episoderZ   r   	Terminatern   s    r   closeMinitaurGymEnv.close   s8    !
ll 3 34MMr   c                 :    U R                   R                  U5        g r   )rX   append)rn   r   s     r   add_env_randomizer!MinitaurGymEnv.add_env_randomizer   s      0r   c                    U R                   R                  U R                   R                  S5        U R                  S:  a%  U R                  R                  U R                  5        [        R                  " 5       U l        [        R                  " U R                  U R                  5        U R                  (       GaP  U R                   R                  5         U R                   R                  [        U R                   5      S9  U R                   R#                  U R$                  5        U R                   R'                  SU R(                  -  5      U l        U R,                  (       aa  U R                   R/                  U R*                  S/ SQS9  U R                   R                  U R                   R0                  U R*                  5        U R                   R3                  SSS5        U R4                  nU R6                  nU R8                  [:        ;  a  [=        SU R8                  -  5      e[:        U R8                     " S0 S	U R                   _S
U R>                  _SU R(                  _SU R$                  _SU R@                  _SU RB                  _SU RD                  _SU_SU RF                  _SU RH                  _SU RJ                  _SU RL                  _SU RN                  _SU RP                  _SU RR                  _SU_SU RT                  _6U l+        U RV                  RY                  SUUS9  U RZ                   H  nUR]                  U 5        M     U R                   R                  SS9  SU l        / SQU l/        / U l0        U R                   Rc                  U Rd                  U Rf                  U Rh                  / SQ5        U R                   R                  U R                   R                  S5        U Rk                  5       $ ) Nr   numSolverIterationsz%s/plane.urdf)r"   r"   r"   g?)	rgbaColoriz#%s is not a supported urdf_version.pybullet_clientr   ro   	time_steprw   rx   ry   r{   r|   r}   r~   r   r   rv   r   r   r   F)reload_urdfdefault_motor_angles
reset_timer'   r%   r"    )6r_   configureDebugVisualizerCOV_ENABLE_RENDERINGr9   r+   r   rZ   r	   rY   r   preallocate_episode_protor:   rQ   resetSimulationra   r/   r1   setTimeStepr.   loadURDFr2   rV   rW   changeVisualShapeCOV_ENABLE_PLANAR_REFLECTION
setGravityrF   rK   rU   MINIATUR_URDF_VERSION_MAP
ValueErrorr-   r3   r4   rD   rG   rH   rI   rS   rT   rB   rJ   rL   r   ResetrX   randomize_envr<   r7   resetDebugVisualizerCamerarM   rN   rO   _get_observation)rn   initial_motor_anglesreset_duration	acc_motormotor_protectr   s         r   rc   MinitaurGymEnv.reset   sx   2243H3H3]3]_`a!
ll 3 34.>>@D..t/B/BDDZDZ[
++-
55!$"D"DE 6 G
''8--667XYdo


//~/^66!!>>	Q
&&q!S144i55m			#<	<>ASASSTT243E3EF # 11#--# oo# oo	#
 $(#?#?# "&!;!;#  $77# *3# *.)K)K# ^^# ^^# !11# ''# %)$A$A# $(#?#?#  '4!#" MM##$ 	MME-A#1  3
 //""4( 0 	33q3ID(DD44T^^T]]59__iQ2243H3H3]3]_`a  ""r   c                 D    [         R                  " U5      u  U l        nU/$ r   )r   	np_random)rn   rb   s     r   rb   MinitaurGymEnv.seed4  s     ",,T2DND6Mr   c                    U R                   (       a{  [        U5       HQ  u  p#U R                  * [        -
  Us=::  a  U R                  [        -   ::  a  M7  O  [	        SR                  X#5      5      e   U R                  R                  U5      nU$ )Nz{}th action {} out of bounds.)rE   	enumeraterC   
ACTION_EPSr   formatr   ConvertFromLegModel)rn   actioniaction_components       r   "_transform_action_to_motor_command1MinitaurGymEnv._transform_action_to_motor_command8  s{    !*6!2
!###j04D 0""Z/0:AA!VW
W "3 }}008fMr   c                    U R                   R                  5       U l        U R                  (       a  [        R                  " 5       U R
                  -
  n[        R                  " 5       U l        U R                  U-
  nUS:  a  [        R                  " U5        U R                   R                  5       nU R                  R                  5       SS u  pVnU R                  R                  XuXd5        U R                   H  nUR                  U 5        M     U R                  U5      nU R                   R                  U5        U R                  5       n	U R!                  5       n
U R"                  b7  [$        R&                  " U R(                  U R                   UU R*                  5        U =R*                  S-  sl        U
(       a  U R                   R-                  5         [.        R0                  " U R3                  5       5      X0 4$ )a  Step forward the simulation, given the action.

Args:
  action: A list of desired motor angles for eight motors.

Returns:
  observations: The angles, velocities and torques of all motors.
  reward: The reward for the current state-action pair.
  done: Whether the episode has ended.
  info: A dictionary that stores diagnostic information.

Raises:
  ValueError: The action dimension is not the same as the number of motors.
  ValueError: The magnitude of actions is out of bounds.
r   r      r"   )r   GetBasePositionr<   r;   timerR   r,   sleepr_   getDebugVisualizerCamerar   rX   randomize_stepr   Step_reward_terminationr)   r   update_episode_protorZ   r9   r   rh   ri   r   )rn   r   
time_spenttime_to_sleepbase_posyawpitchdistr   rewarddones              r   stepMinitaurGymEnv.stepA  s      $}}<<>D 99;!6!66j"iikd,,z9m		

=!..0h00IIKAbQs4
66t%R//##D) 0 44V<FMMv\\^FD~~!++D,?,?PV,0,B,BDa
mm88D))+,fB>>r   c           	         US:w  a  [         R                  " / 5      $ U R                  R                  5       nU R                  R                  UU R                  U R                  U R                  SSS9nU R                  R                  S[        [        5      [        -  SSS9nU R                  R                  [        [        U R                  R                  UUS	9u    pg  n[         R                  " U5      nUS S 2S S 2S S
24   nU$ )Nr   r      )cameraTargetPositiondistancer   r   rollupAxisIndex<   g?g      Y@)fovaspectnearValfarVal)widthheightrenderer
viewMatrixprojectionMatrix   )rh   ri   r   r   r_   !computeViewMatrixFromYawPitchRollrM   rN   rO   computeProjectionMatrixFOVfloatRENDER_WIDTHRENDER_HEIGHTgetCameraImageER_BULLET_HARDWARE_OPENGL)	rn   moder   r   view_matrixproj_matrix_pxr   s	            r   r   MinitaurGymEnv.rendero  s   {XXb\}},,.H''II%MMoo J K ''BBrJOP\J]CPKQKNJO	 C QK
 ,,;;&&@@$ < &Qq! I!Q(#Ir   c                 f    [         R                  " U R                  [        [        [        -    5      $ )zLGet the minitaur's motor angles.

Returns:
  A numpy array of motor angles.
)rh   ri   r5   MOTOR_ANGLE_OBSERVATION_INDEXrg   r   s    r   get_minitaur_motor_angles(MinitaurGymEnv.get_minitaur_motor_angles  s1     88D%%&CDa&0E1 2 3 3r   c                 f    [         R                  " U R                  [        [        [        -    5      $ )zTGet the minitaur's motor velocities.

Returns:
  A numpy array of motor velocities.
)rh   ri   r5    MOTOR_VELOCITY_OBSERVATION_INDEXrg   r   s    r   get_minitaur_motor_velocities,MinitaurGymEnv.get_minitaur_motor_velocities  s1     88:;[$<% 	&' 'r   c                 f    [         R                  " U R                  [        [        [        -    5      $ )zNGet the minitaur's motor torques.

Returns:
  A numpy array of motor torques.
)rh   ri   r5   MOTOR_TORQUE_OBSERVATION_INDEXrg   r   s    r   get_minitaur_motor_torques)MinitaurGymEnv.get_minitaur_motor_torques  s1     8889W$:% 	&' 'r   c                 P    [         R                  " U R                  [        S 5      $ )zwGet the minitaur's base orientation, represented by a quaternion.

Returns:
  A numpy array of minitaur's orientation.
N)rh   ri   r5   "BASE_ORIENTATION_OBSERVATION_INDEXr   s    r   get_minitaur_base_orientation,MinitaurGymEnv.get_minitaur_base_orientation  s"     88D%%&H&IJKKr   c                 P   U R                   R                  5       nU R                  R                  U5      nUSS nU R                   R	                  5       n[
        R                  " [
        R                  " / SQ5      [
        R                  " U5      5      S:  =(       d    US   S:  $ )aJ  Decide whether the minitaur has fallen.

If the up directions between the base and the world is larger (the dot
product is smaller than 0.85) or the base is very low on the ground
(the height is smaller than 0.13 meter), the minitaur is considered fallen.

Returns:
  Boolean value that indicates whether the minitaur has fallen.
   N)r   r   r"   g333333?r   gp=
ף?)r   GetBaseOrientationr_   getMatrixFromQuaternionr   rh   dotasarray)rn   orientationrot_matlocal_upposs        r   	is_fallenMinitaurGymEnv.is_fallen  s     --224K##;;KHGqr{H
--
'
'
)CFF2::i("**X*>?$FW#a&SW-Xr   c                     U R                   R                  5       n[        R                  " US   S-  US   S-  -   5      nU R	                  5       =(       d    X R
                  :  $ )Nr   r   r"   )r   r   mathsqrtr  rA   )rn   positionr   s      r   r   MinitaurGymEnv._termination  sR    }},,.Hyy!a(1+q.89H>>>x*>*>>>r   c                 T   U R                   R                  5       nUS   U R                  S   -
  n[        X R                  5      n[        US   U R                  S   -
  5      * nU R                   R                  5       n[        R                  " U5      nUSS  n[        [        R                  " [        R                  " / SQ5      [        R                  " U5      5      5      * n[        R
                  " [        R                  " U R                   R                  5       U R                   R                  5       5      5      * U R                  -  nX(X7/n	[        XR                   5       V
Vs/ s H	  u  pX-  PM     nn
n[#        U5      nU R$                  R'                  U	5        U$ s  snn
f )Nr   r"   r  )r"   r"   r   )r   r   r<   minrP   absr  r]   r  rh   r  r  GetMotorTorquesGetMotorVelocitiesr.   zipr8   sumr7   r   )rn   current_base_positionforward_rewarddrift_rewardr  
rot_matrixlocal_up_vecshake_rewardenergy_reward
objectivesowweighted_objectivesr   s                 r   r   MinitaurGymEnv._reward  s`    MM99;*1-0H0H0KKN)A)ABN-a043K3KA3NNOOL--224K11+>Jab>Lrzz)4bjj6NOPPLVV
t}},,.}}//1	34 46:ooFM !LJ-0=T=T-UV-UTQ15-UV$%FJ'M Ws   )F$c                     U R                   $ r   )r7   r   s    r   get_objectivesMinitaurGymEnv.get_objectives  s    r   c                     U R                   $ )zAccessor for the weights for all the objectives.

Returns:
  List of floating points that corresponds to weights for the objectives in
  the order that objectives are stored.
)r8   r   s    r   objective_weights MinitaurGymEnv.objective_weights  s     """r   c                    / nUR                  U R                  R                  5       R                  5       5        UR                  U R                  R	                  5       R                  5       5        UR                  U R                  R                  5       R                  5       5        UR                  [        U R                  R                  5       5      5        Xl        U R                  $ )as  Get observation of this environment, including noise and latency.

The minitaur class maintains a history of true observations. Based on the
latency, this function will find the observation at the right time,
interpolate if necessary. Then Gaussian noise is added to this observation
based on self.observation_noise_stdev.

Returns:
  The noisy observation with latency.
)	extendr   GetMotorAnglestolistr!  r   listr  r5   rn   observations     r   r   MinitaurGymEnv._get_observation  s     Kt}}335<<>?t}}779@@BCt}}446==?@tDMM<<>?@#r   c                    / nUR                  U R                  R                  5       R                  5       5        UR                  U R                  R	                  5       R                  5       5        UR                  U R                  R                  5       R                  5       5        UR                  [        U R                  R                  5       5      5        Xl        U R                  $ )aV  Get the observations of this environment.

It includes the angles, velocities, torques and the orientation of the base.

Returns:
  The observation list. observation[0:8] are motor angles. observation[8:16]
  are motor velocities, observation[16:24] are motor torques.
  observation[24:28] is the orientation of the base, in quaternion form.
)	r7  r   GetTrueMotorAnglesr9  GetTrueMotorVelocitiesGetTrueMotorTorquesr:  GetTrueBaseOrientationr6   r;  s     r   _get_true_observation$MinitaurGymEnv._get_true_observation  s     Kt}}779@@BCt}};;=DDFGt}}88:AACDtDMM@@BCD(!!!r   c                    [         R                  " U R                  5       5      nU R                  R                  n[
        R                  USU& [        R                  XSU-  & [        R                  USU-  SU-  & SUSU-  S& U$ )zGet the upper bound of the observation.

Returns:
  The upper bound of an observation. See GetObservation() for the details
    of each element of an observation.
r   r   r   r   N)
rh   zeros_get_observation_dimensionr   
num_motorsr  pir   MOTOR_SPEED_LIMITOBSERVED_TORQUE_LIMIT)rn   upper_boundrH  s      r   rd   +MinitaurGymEnv._get_observation_upper_bound  s~     ((4::<=K))J $K*.3.E.EK1z>*272M2MKJq:~.#&KJ r   c                 $    U R                  5       * $ )z'Get the lower bound of the observation.)rd   r   s    r   rf   +MinitaurGymEnv._get_observation_lower_bound  s    --///r   c                 4    [        U R                  5       5      $ )zXGet the length of the observation list.

Returns:
  The length of the observation list.
)lenr   r   s    r   rG  )MinitaurGymEnv._get_observation_dimension  s     t$$&''r   z0.9.6c                    X:  a  [        S5      eXl        X l        [        [	        X-  5      5      U l        [        U R
                  -  U l        U R                  R                  U R                  S9  U R                  R                  U R                  5        U R                  R                  U R
                  U R                  S9  g)a  Sets the time step of the environment.

Args:
  control_step: The time period (in seconds) between two adjacent control
    actions are applied.
  simulation_step: The simulation time step in PyBullet. By default, the
    simulation step is 0.001s, which is a good trade-off between simulation
    speed and accuracy.
Raises:
  ValueError: If the control step is smaller than the simulation step.
z?Control step should be larger than or equal to simulation step.r   )r   simulation_stepN)r   r,   r.   r/   roundr-   r0   r1   r_   ra   r   r   SetTimeSteps)rn   control_steprT  s      r   set_time_stepMinitaurGymEnv.set_time_step-  s     %XYY)%OeL$BCDD*H4K^K^*^D&33 >> 4 @%%doo6MMT-@-@RVRaRabr   c                     U R                   $ r   )r_   r   s    r   r   MinitaurGymEnv.pybullet_clientD  s       r   c                     U R                   $ r   rV   r   s    r   	ground_idMinitaurGymEnv.ground_idH  s    ??r   c                     Xl         g r   r]  )rn   new_ground_ids     r   r^  r_  L  s    #Or   c                     U R                   $ r   )r9   r   s    r   env_step_counterMinitaurGymEnv.env_step_counterP  s    !!!r   )4rF   rC   r-   rM   rO   rN   rS   rA   r=   r?   r>   rX   r9   rZ   rP   rV   rQ   r;   r<   rR   rE   r)   rI   rH   rK   r4   r1   r:   r8   r7   r5   rB   rL   rD   rT   r_   rW   rG   r3   r@   r.   rJ   r6   r2   rU   rk   r,   r+   r   r   rl   rm   )Nr   r   )r   F)gMbP?)0__name__
__module____qualname____firstlineno____doc__metadatapybullet_datagetDataPathr   SENSOR_NOISE_STDDEVrh   r!   r   r   r   rc   rb   r   r   r   r   r  r  r
  r  r   r   r1  propertyr4  r   rC  rd   rf   rG  r   gym__version___render_reset_seed_steprX  r   r^  setterrc  __static_attributes__r   r   r   r   r   9   s     '4QTU( '224 ""#El':&*$&FF"'!%,1,1"&+). $!%""',=l"\
17#r,?\43''LY ?
* # #("&0( 3??#mG&<<GFEEc. ! !   $ $ " "r   r   )7ri  r  r   osinspectpathdirnameabspathgetfilecurrentframe
currentdir	parentdirsysinsertro  r   	gym.utilsr   numpyrh   r]   pybullet_utilsr   r[   rk  pybullet_envs.minitaur.envsr   r   r   r	   r
   r   pkg_resourcesr   rg   r   r  r  r	  r   re   r   r   rm  r`   DERPY_V0_URDF_VERSIONRAINBOW_DASH_V0_URDF_VERSIONr0   MinitaurMinitaurDerpyMinitaurRainbowDashr   r   Envr   r   r   r   <module>r     sN     WW__RWW__W__W=Q=Q=S-TUV
GGOOBGGOOJ78	   1i   
     .  0 6 8 < = - '
 ! #@:#M  !AJ!N %Cj%P "
22   " 0 !$  (++>77 "7"K"K Y"SWW Y"r   