Example #1
0
    def set_weather(self, weather_type):
        """Set the world's weather.

        The new weather will be applied when :meth:`tick` or :meth:`step` is called next.

        By the next tick, the lighting, skysphere, fog, and relevant particle systems will be
        updated and/or spawned
        to the given weather.

        If there is no skysphere, skylight, or directional source light in the world, this command
        will fail silently.

        ..note::
            Because this command can affect the fog density, any changes made by a
            ``change_fog_density`` command before a set_weather command called will be undone. It is
            recommended to call ``change_fog_density`` after calling set weather if you wish to
            apply your specific changes.

        In all downloadable worlds, the weather is clear by default.

        If the given type string is not available, the command will not be sent.

        Args:
            weather_type (:obj:`str`): The type of weather, which can be ``rain`` or ``cloudy``.

        """
        if not weather_type.lower() in ["rain", "cloudy"]:
            raise HolodeckException("Invalid weather type " + weather_type)

        self.send_world_command("SetWeather", string_params=[weather_type])
Example #2
0
    def __init__(self, name, shape, dtype=np.float32, uuid=""):
        self.shape = shape
        self.dtype = dtype
        size = reduce(lambda x, y: x * y, shape)
        size_bytes = np.dtype(dtype).itemsize * size

        self._mem_path = None
        self._mem_pointer = None
        if os.name == "nt":
            self._mem_path = "/HOLODECK_MEM" + uuid + "_" + name
            self._mem_pointer = mmap.mmap(0, size_bytes, self._mem_path)
        elif os.name == "posix":
            self._mem_path = "/dev/shm/HOLODECK_MEM" + uuid + "_" + name
            f = os.open(self._mem_path, os.O_CREAT | os.O_TRUNC | os.O_RDWR)
            self._mem_file = f
            os.ftruncate(f, size_bytes)
            os.fsync(f)

            # TODO - I think we are leaking a file object here. Unfortunately, we
            #        can't just .close() it since numpy acquires a reference to it
            #        below and I can't find a way to release it in __linux_unlink__()
            self._mem_pointer = mmap.mmap(f, size_bytes)
        else:
            raise HolodeckException("Currently unsupported os: " + os.name)

        self.np_array = np.ndarray(shape, dtype=dtype)
        self.np_array.data = (Shmem._numpy_to_ctype[dtype] * size).from_buffer(self._mem_pointer)
Example #3
0
def world_info(world_name, world_config=None, base_indent=0):
    """Gets and prints the information of a world.

    Args:
        world_name (:obj:`str`): the name of the world to retrieve information for
        world_config (:obj:`dict`, optional): A dictionary containing the world's configuration.
            Will find the config if None. Defaults to None.
        base_indent (:obj:`int`, optional): How much to indent output
    """
    if world_config is None:
        for config, _ in _iter_packages():
            for world in config["worlds"]:
                if world["name"] == world_name:
                    world_config = world

    if world_config is None:
        raise HolodeckException("Couldn't find world " + world_name)

    print(base_indent * ' ', world_config["name"])
    base_indent += 4

    if "agents" in world_config:
        _print_agent_info(world_config["agents"], base_indent)

    print(base_indent * ' ', "Scenarios:")
    for scenario, _ in _iter_scenarios(world_name):
        scenario_info(scenario=scenario, base_indent=base_indent + 2)
Example #4
0
    def add_agent(self, agent_def, is_main_agent=False):
        """Add an agent in the world.

        It will be spawn when :meth:`tick` or :meth:`step` is called next.

        The agent won't be able to be used until the next frame.

        Args:
            agent_def (:class:`~holodeck.agents.AgentDefinition`): The definition of the agent to
            spawn.
        """
        if agent_def.name in self.agents:
            raise HolodeckException("Error. Duplicate agent name. ")

        self.agents[agent_def.name] = AgentFactory.build_agent(
            self._client, agent_def)
        self._state_dict[agent_def.name] = self.agents[
            agent_def.name].agent_state_dict

        if not agent_def.existing:
            command_to_send = SpawnAgentCommand(
                location=agent_def.starting_loc,
                rotation=agent_def.starting_rot,
                name=agent_def.name,
                agent_type=agent_def.type.agent_type,
                is_main_agent=agent_def.is_main_agent)

            self._client.command_center.enqueue_command(command_to_send)
        self.agents[agent_def.name].add_sensors(agent_def.sensors)
        if is_main_agent:
            self._agent = self.agents[agent_def.name]
Example #5
0
def world_info(world_name, world_config=None, initial_indent="", next_indent="  "):
    """Gets and prints the information of a world.

    Args:
        world_name (str): the name of the world to retrieve information for
        world_config (dict optional): A dictionary containing the world's configuration. Will find the config if None. Defaults to None.
        initial_indent (str optional): This indent will apply to each output line. Defaults to "".
        next_indent (str optional): This indent will be applied within each nested line. Defaults to "  ".
    """
    if world_config is None:
        for config, _ in _iter_packages():
            for world in config["maps"]:
                if world["name"] == world_name:
                    world_config = world

    if world_config is None:
        raise HolodeckException("Couldn't find world " + world_name)

    second_indent = initial_indent + next_indent
    agent_indent = second_indent + next_indent
    sensor_indent = agent_indent + next_indent

    print(initial_indent, world_config["name"])
    print(second_indent, "Resolution:", world_config["window_width"], "x", world_config["window_height"])
    print(second_indent, "Agents:")
    for agent in world_config["agents"]:
        print(agent_indent, "Name:", agent["agent_name"])
        print(agent_indent, "Type:", agent["agent_type"])
        print(agent_indent, "Sensors:")
        for sensor in agent["sensors"]:
            print(sensor_indent, sensor)
Example #6
0
    def step(self, action):
        """Supplies an action to the main agent and tells the environment to tick once.
        Primary mode of interaction for single agent environments.

        Args:
            action (:obj:`np.ndarray`): An action for the main agent to carry out on the next tick.

        Returns:
            (:obj:`dict`, :obj:`float`, :obj:`bool`, info): A 4tuple:
                - State: Dictionary from sensor enum
                    (see :class:`~holodeck.sensors.HolodeckSensor`) to :obj:`np.ndarray`.
                - Reward (:obj:`float`): Reward returned by the environment.
                - Terminal: The bool terminal signal returned by the environment.
                - Info: Any additional info, depending on the world. Defaults to None.
        """
        if not self._initial_reset:
            raise HolodeckException("You must call .reset() before .step()")

        if self._agent is not None:
            self._agent.act(action)

        self._command_center.handle_buffer()
        self._client.release()
        self._client.acquire()

        reward, terminal = self._get_reward_terminal()
        return self._default_state_fn(), reward, terminal, None
Example #7
0
    def __linux_start_process__(self, binary_path, task_key, gl_version, verbose,
                                show_viewport=True):
        import posix_ipc
        out_stream = sys.stdout if verbose else open(os.devnull, 'w')
        loading_semaphore = \
            posix_ipc.Semaphore('/HOLODECK_LOADING_SEM' + self._uuid, os.O_CREAT | os.O_EXCL,
                                initial_value=0)
        # Copy the environment variables and re,pve the DISPLAY variable to hide viewport
        # https://answers.unrealengine.com/questions/815764/in-the-release-notes-it-says-the-engine-can-now-cr.html?sort=oldest
        environment = dict(os.environ.copy())
        if not show_viewport:
            del environment['DISPLAY']
        self._world_process = \
            subprocess.Popen([binary_path, task_key, '-HolodeckOn', '-opengl' + str(gl_version),
                              '-LOG=HolodeckLog.txt', '-ResX=' + str(self._window_size[1]),
                              '-ResY=' + str(self._window_size[0]), '--HolodeckUUID=' + self._uuid,
                              '-TicksPerSec=' + str(self._ticks_per_sec)],
                             stdout=out_stream,
                             stderr=out_stream,
                             env=environment)

        atexit.register(self.__on_exit__)

        try:
            loading_semaphore.acquire(10)
        except posix_ipc.BusyError:
            raise HolodeckException("Timed out waiting for binary to load. Ensure that holodeck is "
                                    "not being run with root priveleges.")
        loading_semaphore.unlink()
Example #8
0
 def unlink(self):
     """unlinks the shared memory"""
     if os.name == "posix":
         self.__linux_unlink__()
     elif os.name == "nt":
         self.__windows_unlink__()
     else:
         raise HolodeckException("Currently unsupported os: " + os.name)
Example #9
0
    def __init__(self, agent_definitions, binary_path=None, task_key=None, window_height=512, window_width=512,
                 camera_height=256, camera_width=256, start_world=True, uuid="", gl_version=4, verbose=False,
                 pre_start_steps=2):
        """Constructor for HolodeckEnvironment.
        Positional arguments:
        agent_definitions -- A list of AgentDefinition objects for which agents to expect in the environment
        Keyword arguments:
        binary_path -- The path to the binary to load the world from (default None)
        task_key -- The name of the map within the binary to load (default None)
        height -- The height to load the binary at (default 512)
        width -- The width to load the binary at (default 512)
        start_world -- Whether to load a binary or not (default True)
        uuid -- A unique identifier, used when running multiple instances of holodeck (default "")
        gl_version -- The version of OpenGL to use for Linux (default 4)
        """
        self._window_height = window_height
        self._window_width = window_width
        self._camera_height = camera_height
        self._camera_width = camera_width
        self._uuid = uuid
        self._pre_start_steps = pre_start_steps

        Sensors.set_primary_cam_size(window_height, window_width)
        Sensors.set_pixel_cam_size(camera_height, camera_width)

        if start_world:
            if os.name == "posix":
                self.__linux_start_process__(binary_path, task_key, gl_version, verbose=verbose)
            elif os.name == "nt":
                self.__windows_start_process__(binary_path, task_key, verbose=verbose)
            else:
                raise HolodeckException("Unknown platform: " + os.name)

        # Set up and add the agents
        self._client = HolodeckClient(self._uuid)
        self._sensor_map = dict()
        self._all_agents = list()
        self.agents = dict()
        self._hyperparameters_map = dict()
        self._add_agents(agent_definitions)
        self._agent = self._all_agents[0]

        # Set the default state function
        self.num_agents = len(self._all_agents)
        self._default_state_fn = self._get_single_state if self.num_agents == 1 else self._get_full_state

        # Subscribe settings
        self._reset_ptr = self._client.malloc("RESET", [1], np.bool)
        self._reset_ptr[0] = False
        self._command_bool_ptr = self._client.malloc("command_bool", [1], np.bool)
        megabyte = 1048576  # This is the size of the command buffer that Holodeck expects/will read.
        self._command_buffer_ptr = self._client.malloc("command_buffer", [megabyte], np.byte)

        # self._commands holds commands that are queued up to write to the command buffer on tick.
        self._commands = CommandsGroup()
        self._should_write_to_command_buffer = False

        self._client.acquire()
Example #10
0
    def __init__(self, agent_definitions=None, binary_path=None, window_size=(720, 1280),
                 start_world=True, uuid="", gl_version=4, verbose=False, pre_start_steps=2,
                 show_viewport=True, ticks_per_sec=30, copy_state=True, scenario=None):

        if agent_definitions is None:
            agent_definitions = []

        # Initialize variables
        self._window_size = window_size
        self._uuid = uuid
        self._pre_start_steps = pre_start_steps
        self._copy_state = copy_state
        self._ticks_per_sec = ticks_per_sec
        self._scenario = scenario
        self._initial_agent_defs = agent_definitions
        self._spawned_agent_defs = []

        # Start world based on OS
        if start_world:
            world_key = self._scenario["world"]
            if os.name == "posix":
                self.__linux_start_process__(binary_path, world_key, gl_version, verbose=verbose,
                                             show_viewport=show_viewport)
            elif os.name == "nt":
                self.__windows_start_process__(binary_path, world_key, verbose=verbose)
            else:
                raise HolodeckException("Unknown platform: " + os.name)

        # Initialize Client
        self._client = HolodeckClient(self._uuid, start_world)
        self._command_center = CommandCenter(self._client)
        self._client.command_center = self._command_center
        self._reset_ptr = self._client.malloc("RESET", [1], np.bool)
        self._reset_ptr[0] = False

        # Set up agents already in the world
        self.agents = dict()
        self._state_dict = dict()
        self._agent = None

        # Spawn agents not yet in the world.
        # TODO implement this section for future build automation update

        # Set the default state function
        self.num_agents = len(self.agents)

        if self.num_agents == 1:
            self._default_state_fn = self._get_single_state
        else:
            self._default_state_fn = self._get_full_state

        self._client.acquire()

        # Flag indicates if the user has called .reset() before .tick() and .step()
        self._initial_reset = False
        self.reset()
Example #11
0
    def _load_scenario(self):
        """Loads the scenario defined in self._scenario_key.

        Instantiates all agents and sensors.

        If no scenario is defined, does nothing.
        """
        if self._scenario is None:
            return

        for agent in self._scenario['agents']:
            sensors = []
            for sensor in agent['sensors']:
                if 'sensor_type' not in sensor:
                    raise HolodeckException(
                        "Sensor for agent {} is missing required key "
                        "'sensor_type'".format(agent['agent_name']))

                # Default values for a sensor
                sensor_config = {
                    'location': [0, 0, 0],
                    'rotation': [0, 0, 0],
                    'socket': "",
                    'configuration': {},
                    'sensor_name': sensor['sensor_type']
                }
                # Overwrite the default values with what is defined in the scenario config
                sensor_config.update(sensor)

                sensors.append(SensorDefinition(agent['agent_name'],
                                                sensor_config['sensor_name'],
                                                sensor_config['sensor_type'],
                                                socket=sensor_config['socket'],
                                                location=sensor_config['location'],
                                                rotation=sensor_config['rotation'],
                                                config=sensor_config['configuration']))
            # Default values for an agent
            agent_config = {
                'location': [0, 0, 0],
                'rotation': [0, 0, 0],
                'agent_name': agent['agent_type']
            }

            agent_config.update(agent)
            agent_def = AgentDefinition(agent_config['agent_name'], agent_config['agent_type'],
                                        starting_loc=agent_config["location"],
                                        starting_rot=agent_config["rotation"],  sensors=sensors)

            is_main_agent = False
            if "main_agent" in self._scenario:
                is_main_agent = self._scenario["main_agent"] == agent["agent_name"]

            self.add_agent(agent_def, is_main_agent)
            self.agents[agent['agent_name']].set_control_scheme(agent['control_scheme'])
            self._spawned_agent_defs.append(agent_def)
Example #12
0
    def set_location(self, location):
        """Set where agent will be spawned.

        Args:
            location (:obj:`list` of :obj:`float`): ``[x, y, z]`` location to spawn agent (see :ref:`coordinate-system`)

        """
        if len(location) != 3:
            raise HolodeckException(
                "Invalid location given to spawn agent command")
        self.add_number_parameters(location)
Example #13
0
def remove(package_name):
    """Removes a holodeck package.

    Args:
        package_name (str): the name of the package to remove
    """
    if package_name not in packages:
        raise HolodeckException("Unknown package name " + package_name)
    for config, path in _iter_packages():
        if config["name"] == package_name:
            shutil.rmtree(path)
Example #14
0
    def set_rotation(self, rotation):
        """Set where agent will be spawned.

        Args:
            rotation (:obj:`list` of :obj:`float`): ``[roll, pitch, yaw]`` rotation for agent.
                (see :ref:`rotations`)

        """
        if len(rotation) != 3:
            raise HolodeckException(
                "Invalid rotation given to spawn agent command")
        self.add_number_parameters(rotation)
Example #15
0
 def __windows_start_process__(self, binary_path, task_key, verbose):
     import win32event
     out_stream = sys.stdout if verbose else open(os.devnull, 'w')
     loading_semaphore = win32event.CreateSemaphore(None, 0, 1, "Global\\HOLODECK_LOADING_SEM" + self._uuid)
     self._world_process = subprocess.Popen([binary_path, task_key, '-HolodeckOn', '-LOG=HolodeckLog.txt',
                                             '-ResX=' + str(self._window_width), "-ResY=" + str(self._window_height),
                                             '-CamResX=' + str(self._camera_width),
                                             '-CamResY=' + str(self._camera_height), "--HolodeckUUID=" + self._uuid],
                                            stdout=out_stream, stderr=out_stream)
     atexit.register(self.__on_exit__)
     response = win32event.WaitForSingleObject(loading_semaphore, 100000)  # 100 second timeout
     if response == win32event.WAIT_TIMEOUT:
         raise HolodeckException("Timed out waiting for binary to load")
Example #16
0
    def start_day_cycle(self, day_length):
        """Queue up a day cycle command to start the day cycle. It will be applied when `tick` or `step` is called next.
        The sky sphere will now update each tick with an updated sun angle as it moves about the sky. The length of a
        day will be roughly equivalent to the number of minutes given.

        Args:
            day_length (int): The number of minutes each day will be.
        """
        if day_length <= 0:
            raise HolodeckException("The given day length should be between above 0!")

        self._should_write_to_command_buffer = True
        command_to_send = DayCycleCommand(True)
        command_to_send.set_day_length(day_length)
        self._commands.add_command(command_to_send)
Example #17
0
    def set_fog_density(self, density):
        """Queue up a change fog density command. It will be applied when `tick` or `step` is called next.
        By the next tick, the exponential height fog in the world will have the new density. If there is no fog in the
        world, it will be automatically created with the given density.

        Args:
            density (float): The new density value, between 0 and 1. The command will not be sent if the given
        density is invalid.
        """
        if density < 0 or density > 1:
            raise HolodeckException("Fog density should be between 0 and 1")

        self._should_write_to_command_buffer = True
        command_to_send = ChangeFogDensityCommand(density)
        self._commands.add_command(command_to_send)
Example #18
0
    def set_fog_density(self, density):
        """Change the fog density.

        The change will occur when :meth:`tick` or :meth:`step` is called next.

        By the next tick, the exponential height fog in the world will have the new density. If
        there is no fog in the world, it will be created with the given density.

        Args:
            density (:obj:`float`): The new density value, between 0 and 1. The command will not be
                sent if the given density is invalid.
        """
        if density < 0 or density > 1:
            raise HolodeckException("Fog density should be between 0 and 1")

        self.send_world_command("SetFogDensity", num_params=[density])
Example #19
0
    def _write_to_command_buffer(self, to_write):
        """Write input to the command buffer.

        Reformat input string to the correct format.

        Args:
            to_write (:class:`str`): The string to write to the command buffer.

        """
        np.copyto(self._command_bool_ptr, True)
        to_write += '0'  # The gason JSON parser in holodeck expects a 0 at the end of the file.
        input_bytes = str.encode(to_write)
        if len(input_bytes) > self.max_buffer:
            raise HolodeckException(
                "Error: Command length exceeds buffer size")
        for index, val in enumerate(input_bytes):
            self._command_buffer_ptr[index] = val
Example #20
0
    def tick(self):
        """Ticks the environment once. Normally used for multi-agent environments.

        Returns:
            :obj:`dict`: A dictionary from agent name to its full state. The full state is another
                dictionary from :obj:`holodeck.sensors.Sensors` enum to np.ndarray, containing the
                sensors information for each sensor. The sensors always include the reward and
                terminal sensors.
        """
        if not self._initial_reset:
            raise HolodeckException("You must call .reset() before .tick()")

        self._command_center.handle_buffer()

        self._client.release()
        self._client.acquire()

        return self._default_state_fn()
Example #21
0
    def start_day_cycle(self, day_length):
        """Start the day cycle.

        The cycle will start when :meth:`tick` or :meth:`step` is called next.

        The sky sphere will then update each tick with an updated sun angle as it moves about the]
        sky. The length of a day will be roughly equivalent to the number of minutes given.

        If there is no skysphere, skylight, or directional source light in the world, this command
        will fail silently.

        Args:
            day_length (:obj:`int`): The number of minutes each day will be.
        """
        if day_length <= 0:
            raise HolodeckException("The given day length should be between above 0!")

        self.send_world_command("SetDayCycle", num_params=[1, day_length])
Example #22
0
def install(package_name):
    """Installs a holodeck package.

    Args:
        package_name (str): The name of the package to install
    """
    holodeck_path = util.get_holodeck_path()
    binary_website = "https://s3.amazonaws.com/holodeckworlds/"

    if package_name not in packages:
        raise HolodeckException("Unknown package name " + package_name)
    package_url = packages[package_name]

    print("Installing " + package_name + " at " + holodeck_path)
    install_path = os.path.join(holodeck_path, "worlds")
    binary_url = binary_website + util.get_os_key() + "_" + package_url
    _download_binary(binary_url, install_path)
    if os.name == "posix":
        _make_binary_excecutable(package_name, install_path)
Example #23
0
    def __linux_start_process__(self, binary_path, task_key, gl_version, verbose):
        import posix_ipc
        out_stream = sys.stdout if verbose else open(os.devnull, 'w')
        loading_semaphore = posix_ipc.Semaphore('/HOLODECK_LOADING_SEM' + self._uuid, os.O_CREAT | os.O_EXCL,
                                                initial_value=0)
        self._world_process = subprocess.Popen([binary_path, task_key, '-HolodeckOn', '-opengl' + str(gl_version),
                                                '-LOG=HolodeckLog.txt', '-ResX=' + str(self._window_width),
                                                '-ResY=' + str(self._window_height),'-CamResX=' + str(self._camera_width),
                                                '-CamResY=' + str(self._camera_height), '--HolodeckUUID=' + self._uuid],
                                               stdout=out_stream,
                                               stderr=out_stream)

        atexit.register(self.__on_exit__)

        try:
            loading_semaphore.acquire(100)
        except posix_ipc.BusyError:
            raise HolodeckException("Timed out waiting for binary to load. Ensure that holodeck is not being run with root priveleges.")
        loading_semaphore.unlink()
Example #24
0
def get_package_config_for_scenario(scenario):
    """For the given scenario, returns the package config associated with it (config.json)

    Args:
        scenario (:obj:`dict`): scenario dict to look up the package for

    Returns:
        :obj:`dict`: package configuration dictionary

    """

    world_name = scenario["world"]

    for config, path in _iter_packages():
        for world in config["worlds"]:
            if world["name"] == world_name:
                return config

    raise HolodeckException(
        "Could not find a package that contains world {}".format(world_name))
Example #25
0
    def set_weather(self, weather_type):
        """Queue up a set weather command. It will be applied when `tick` or `step` is called next.
        By the next tick, the lighting, skysphere, fog, and relevant particle systems will be updated and/or spawned
        to the given weather. If there is no skysphere or directional light in the world, the command may not function
        properly but will not cause a crash.

        NOTE: Because this command can effect the fog density, any changes made by a change_fog_density command before
        a set_weather command called will be undone. It is recommended to call change_fog_density after calling set
        weather.

        Args:
            weather_type (str): The type of weather, which can be 'Rain' or 'Cloudy'. In all downloadable worlds,
            the weather is clear by default. If the given type string is not available, the command will not be sent.

        """
        if not SetWeatherCommand.has_type(weather_type.lower()):
            raise HolodeckException("Invalid weather type " + weather_type)

        self._should_write_to_command_buffer = True
        command_to_send = SetWeatherCommand(weather_type.lower())
        self._commands.add_command(command_to_send)
Example #26
0
    def __init__(self, uuid=""):
        self._uuid = uuid

        # Important functions
        self._get_semaphore_fn = None
        self._release_semaphore_fn = None
        self._semaphore1 = None
        self._semaphore2 = None
        self.unlink = None

        self._memory = dict()
        self._sensors = dict()
        self._agents = dict()
        self._settings = dict()

        if os.name == "nt":
            self.__windows_init__()
        elif os.name == "posix":
            self.__posix_init__()
        else:
            raise HolodeckException("Currently unsupported os: " + os.name)
Example #27
0
    def __init__(self, name, shape, dtype=np.float32, uuid=""):
        self.shape = shape
        self.dtype = dtype
        size = reduce(lambda x, y: x * y, shape)
        size_bytes = np.dtype(dtype).itemsize * size

        self._mem_path = None
        self._mem_pointer = None
        if os.name == "nt":
            self._mem_path = "/HOLODECK_MEM" + uuid + "_" + name
            self._mem_pointer = mmap.mmap(0, size_bytes, self._mem_path)
        elif os.name == "posix":
            self._mem_path = "/dev/shm/HOLODECK_MEM" + uuid + "_" + name
            f = os.open(self._mem_path, os.O_CREAT | os.O_TRUNC | os.O_RDWR)
            os.ftruncate(f, size_bytes)
            self._mem_pointer = mmap.mmap(f, size_bytes)
        else:
            raise HolodeckException("Currently unsupported os: " + os.name)

        self.np_array = np.ndarray(shape, dtype=dtype)
        self.np_array.data = (Shmem._numpy_to_ctype[dtype] * size).from_buffer(
            self._mem_pointer)
Example #28
0
    def tick(self, num_ticks=1):
        """Ticks the environment once. Normally used for multi-agent environments.
        Args:
            num_ticks (:obj:`int`): Number of ticks to perform. Defaults to 1. 
        Returns:
            :obj:`dict`: A dictionary from agent name to its full state. The full state is another
                dictionary from :obj:`holodeck.sensors.Sensors` enum to np.ndarray, containing the
                sensors information for each sensor. The sensors always include the reward and
                terminal sensors.

                Will return the state from the last tick executed.
        """
        if not self._initial_reset:
            raise HolodeckException("You must call .reset() before .tick()")

        for _ in range(num_ticks):
            self._command_center.handle_buffer()

            self._client.release()
            self._client.acquire()
            state = self._default_state_fn()

        return state
Example #29
0
def make(world_name,
         gl_version=GL_VERSION.OPENGL4,
         window_res=None,
         cam_res=None,
         verbose=False):
    """Creates a holodeck environment using the supplied world name.

    Args:
        world_name (str): The name of the world to load as an environment. Must match the name of a world in an
            installed package.
        gl_version (int, optional): The OpenGL version to use (Linux only). Defaults to GL_VERSION.OPENGL4.
        window_res ((int, int), optional): The resolution to load the game window at. Defaults to (512, 512).
        cam_res ((int, int), optional): The resolution to load the pixel camera sensors at. Defaults to (256, 256).
        verbose (bool): Whether to run in verbose mode. Defaults to False.

    Returns:
        HolodeckEnvironment: A holodeck environment instantiated with all the settings necessary for the specified
            world, and other supplied arguments.
    """
    holodeck_worlds = _get_worlds_map()
    if world_name not in holodeck_worlds:
        raise HolodeckException("Invalid World Name")

    param_dict = copy(holodeck_worlds[world_name])
    param_dict["start_world"] = True
    param_dict["uuid"] = str(uuid.uuid4())
    param_dict["gl_version"] = gl_version
    param_dict["verbose"] = verbose

    if window_res is not None:
        param_dict["window_width"] = window_res[0]
        param_dict["window_height"] = window_res[1]
    if cam_res is not None:
        param_dict["camera_width"] = cam_res[0]
        param_dict["camera_height"] = cam_res[1]

    return HolodeckEnvironment(**param_dict)
Example #30
0
def install(package_name, url=None):
    """Installs a holodeck package.

    Args:
        package_name (:obj:`str`): The name of the package to install
    """

    if package_name is None and url is None:
        raise HolodeckException(
            "You must specify the URL or a valid package name")

    _check_for_old_versions()
    holodeck_path = util.get_holodeck_path()

    if url is None:
        # If the URL is none, we need to derive it
        packages = available_packages()
        if package_name not in packages:
            print("Package not found. Available packages are:",
                  file=sys.stderr)
            pprint.pprint(packages, width=10, indent=4, stream=sys.stderr)
            return

        # example: %backend%/packages/0.1.0/DefaultWorlds/Linux.zip
        url = "{backend_url}packages/{holodeck_version}/{package_name}/{platform}.zip".format(
            backend_url=BACKEND_URL,
            holodeck_version=util.get_holodeck_version(),
            package_name=package_name,
            platform=util.get_os_key())

    install_path = os.path.join(holodeck_path, "worlds", package_name)

    print("Installing {} from {} to {}".format(package_name, url,
                                               install_path))

    _download_binary(url, install_path)