code: def __init__(
      self,
      level: LevelSelection,
      seed: int,
      frame_skip: int,
      human_control: bool,
      custom_reward_threshold: Union[int, float, None],
      visualization_parameters: VisualizationParameters,
      base_parameters: RobosuiteBaseParameters,
      extra_parameters: Dict[str, Any],
      robot: str,
      controller: str,
      target_success_rate: float = 1.0,
      apply_dr: bool = False,
      dr_every_n_steps_min: int = 10,
      dr_every_n_steps_max: int = 20,
      use_joint_vel_obs=False,
      custom_controller_config_fpath=None,
      **kwargs,
  ):
      super(RobosuiteEnvironment, self).__init__(
          level,
          seed,
          frame_skip,
          human_control,
          custom_reward_threshold,
          visualization_parameters,
          target_success_rate,
      )
  
      # Validate arguments
  
      self.frame_skip = max(1, self.frame_skip)
  
      def validate_input(input, supported, name):
          if input not in supported:
              raise ValueError(
                  "Unknown Robosuite {0} passed: '{1}' ; Supported {0}s are: {2}".format(
                      name, input, " | ".join(supported)
                  )
              )
  
      validate_input(self.env_id, robosuite_environments, "environment")
      validate_input(robot, robosuite_robots, "robot")
      self.robot = robot
      if controller is not None:
          validate_input(
              controller, robosuite_controllers, "controller"
          )
      self.controller = controller
  
      self.base_parameters = base_parameters
      self.base_parameters.has_renderer = (
          self.is_rendered and self.native_rendering
      )
      self.base_parameters.has_offscreen_renderer = (
          self.base_parameters.use_camera_obs
          or (self.is_rendered and not self.native_rendering)
      )
  
      # Seed
      if self.seed is not None:
          np.random.seed(self.seed)
          random.seed(self.seed)
  
      # Load and initialize environment
      env_args = self.base_parameters.env_kwargs_dict()
      env_args.update(extra_parameters)
  
      if (
          "reward_scale" not in env_args
          and self.env_id in DEFAULT_REWARD_SCALES
      ):
          env_args["reward_scale"] = DEFAULT_REWARD_SCALES[self.env_id]
  
      env_args["robots"] = self.robot
      controller_cfg = None
      if self.controller is not None:
          controller_cfg = robosuite.controllers.load_controller_config(
              default_controller=self.controller
          )
      elif custom_controller_config_fpath is not None:
          controller_cfg = robosuite.controllers.load_controller_config(
              custom_fpath=custom_controller_config_fpath
          )
  
      env_args["controller_configs"] = controller_cfg
  
      self.env = robosuite.make(self.env_id, **env_args)
  
      # TODO: Generalize this to filter any observation by name
      if not use_joint_vel_obs:
          self.env.modify_observable(
              "robot0_joint_vel", "active", False
          )
  
      # Wrap with a dummy wrapper so we get a consistent API (there are subtle changes between
      # wrappers and actual environments in Robosuite, for example action_spec as property vs. function)
      self.env = Wrapper(self.env)
      if apply_dr:
          self.env = DomainRandomizationWrapper(
              self.env,
              seed=self.seed,
              randomize_every_n_steps_min=dr_every_n_steps_min,
              randomize_every_n_steps_max=dr_every_n_steps_max,
          )
  
      # State space
      self.state_space = self._setup_state_space()
  
      # Action space
      low, high = self.env.unwrapped.action_spec
      self.action_space = BoxActionSpace(low.shape, low=low, high=high)
  
      self.reset_internal_state()
  
      if self.is_rendered:
          image = self.get_rendered_image()
          self.renderer.create_screen(image.shape[1], image.shape[0])
  
imports: from typing import Union, Dict, Any
  from enum import Enum, Flag, auto
  from copy import deepcopy
  import numpy
  import random
  from collections import namedtuple
  from rl_coach.base_parameters import Parameters, VisualizationParameters
  from rl_coach.environments.environment import Environment, EnvironmentParameters, LevelSelection
  from rl_coach.spaces import BoxActionSpace, VectorObservationSpace, StateSpace, PlanarMapsObservationSpace
  import rl_coach.environments.robosuite.cube_exp
label_desc: Use image node_id 1 to create a new RobosuiteEnvironment object from inherited base classes: Environment with example: obj = RobosuiteEnvironment(level, seed, frame_skip, human_control, custom_reward_threshold, visualization_parameters, base_parameters, extra_parameters, robot, controller, target_success_rate, apply_dr, dr_every_n_steps_min, dr_every_n_steps_max, use_joint_vel_obs, custom_controller_config_fpath)