SYMBOL INDEX (1141 symbols across 97 files)

FILE: example/diagnostic-agent/diagnostic-agent.py
  class NoopSpace (line 21) | class NoopSpace(gym.Space):
    method sample (line 23) | def sample(self, seed=0):
    method contains (line 25) | def contains(self, x):
  class ForwardSpace (line 28) | class ForwardSpace(gym.Space):
    method __init__ (line 30) | def __init__(self, key='w'):
    method sample (line 32) | def sample(self, seed=0):
    method contains (line 34) | def contains(self, x):
  class RandomAgent (line 38) | class RandomAgent(object):
    method __init__ (line 45) | def __init__(self, action_space, n, vectorized):
    method __call__ (line 50) | def __call__(self, observation, reward, done):

FILE: example/random-agent/random-agent.py
  function main (line 13) | def main():

FILE: example/recorders/botaction_recorder.py
  class BotactionRecordingServer (line 24) | class BotactionRecordingServer(websocket.WebSocketServerProtocol, object):
    method next_id (line 28) | def next_id(cls):
    method __init__ (line 35) | def __init__(self):
    method _emit (line 43) | def _emit(self, rec):
    method onConnect (line 48) | def onConnect(self, request):
    method onOpen (line 57) | def onOpen(self):
    method onClose (line 60) | def onClose(self, wasClean, code, reason):
    method onMessage (line 68) | def onMessage(self, msg, binary):
  function main (line 73) | def main():

FILE: example/recorders/reward_recorder.py
  function main (line 13) | def main():

FILE: example/recorders/vnc_recorder.py
  function main (line 14) | def main():

FILE: example/system-diagnostics/system_diagnostics_logger.py
  class DiagnosticsLogger (line 7) | class DiagnosticsLogger(object):
    method __init__ (line 8) | def __init__(self, interval=5):
    method run (line 12) | def run(self):
    method get_chrome_procs (line 24) | def get_chrome_procs(self):
    method cpu_times (line 32) | def cpu_times(self):

FILE: tests/functional/test_core_envs_semantics.py
  function show (line 11) | def show(obs):
  class AtariMatcher (line 14) | class AtariMatcher(object):
    method translator (line 15) | def translator(self, env):
    method crop (line 18) | def crop(self, obs):
    method assert_match (line 21) | def assert_match(self, obs, vnc_obs, extra_info=None, stage=None):
  function atari_vnc_wrapper (line 33) | def atari_vnc_wrapper(env):
  class CartPoleLowDMatcher (line 38) | class CartPoleLowDMatcher(object):
    method translator (line 39) | def translator(self, env):
    method assert_match (line 42) | def assert_match(self, obs, vnc_obs, extra_info=None, stage=None):
  function reset (line 45) | def reset(matcher, env, vnc_env, stage=None):
  function rollout (line 50) | def rollout(matcher, env, vnc_env, timestep_limit=None, stage=None):
  function test_nice_vnc_semantics_match (line 84) | def test_nice_vnc_semantics_match(spec, matcher, wrapper):

FILE: tests/functional/test_envs.py
  function test_smoke (line 23) | def test_smoke(env_id):
  function _rollout (line 40) | def _rollout(env, timestep_limit=None):
  function configure_with_latest_docker_runtime_tag (line 82) | def configure_with_latest_docker_runtime_tag(env):

FILE: universe/__init__.py
  function docker_image (line 33) | def docker_image(runtime_id):
  function enable_logfile (line 45) | def enable_logfile(path=None):
  function configure_logging (line 48) | def configure_logging(path=None):

FILE: universe/envs/diagnostics.py
  function show (line 22) | def show(ob):
  function standard_error (line 26) | def standard_error(ary, axis, scale=1):
  function extract_timestamp (line 33) | def extract_timestamp(observation):
  class MetadataDecoder (line 43) | class MetadataDecoder(object):
    method build (line 45) | def build(cls, metadata_encoding, pool, qr_pool, label):
  class AsyncDecode (line 55) | class AsyncDecode(object):
    method __init__ (line 58) | def __init__(self, pool, qr_pool, method, x, y, width, height):
    method __call__ (line 72) | def __call__(self, img, available_at):
  class QRCodeMetadataDecoder (line 101) | class QRCodeMetadataDecoder(MetadataDecoder):
    method __init__ (line 102) | def __init__(self, pool, qr_pool, x, y, width, height, label):
    method _decode (line 113) | def _decode(self, observation, start, available_at):
  class PixelsMetadataDecoder (line 143) | class PixelsMetadataDecoder(MetadataDecoder):
    method __init__ (line 144) | def __init__(self, label):
    method _check_location (line 156) | def _check_location(self, observation, location):
    method _find_metadata_location (line 160) | def _find_metadata_location(self, observation):
    method _should_search_metadata (line 174) | def _should_search_metadata(self):
    method decode (line 177) | def decode(self, observation, available_at=None):
  class Diagnostics (line 203) | class Diagnostics(object):
    method __init__ (line 204) | def __init__(self, n, probe_key, ignore_clock_skew=False, metadata_enc...
    method update (line 221) | def update(self, probe_key, metadata_encoding):
    method connect (line 229) | def connect(self, i, network=None, label=None):
    method close (line 233) | def close(self, i=None):
    method add_probe (line 243) | def add_probe(self, action_n, mask_n):
    method add_metadata (line 254) | def add_metadata(self, observation_n, info_n, available_at=None):
    method _add_metadata_i (line 265) | def _add_metadata_i(self, args):
    method extract_metadata (line 271) | def extract_metadata(self, observation_n):
    method clear_probes_when_done (line 275) | def clear_probes_when_done(self, done_n):
  class DiagnosticsInstance (line 282) | class DiagnosticsInstance(object):
    method __init__ (line 289) | def __init__(self, i, network, probe_key, ignore_clock_skew, metadata_...
    method update (line 315) | def update(self, probe_key, metadata_encoding):
    method clear_probe (line 326) | def clear_probe(self):
    method add_probe (line 330) | def add_probe(self, action):
    method add_metadata (line 343) | def add_metadata(self, observation, info, available_at=None):
  function extract_n_m (line 453) | def extract_n_m(dict_n_m, key):

FILE: universe/envs/dummy_vnc_env.py
  class DummyVNCEnv (line 11) | class DummyVNCEnv(vectorized.Env):
    method __init__ (line 33) | def __init__(self):
    method configure (line 39) | def configure(self, remotes=None,
    method _reset (line 52) | def _reset(self):
    method _step (line 55) | def _step(self, action_n):
    method __str__ (line 74) | def __str__(self):

FILE: universe/envs/tests/test_semantics.py
  function get_rewarder_session (line 21) | def get_rewarder_session(env):
  function get_vnc_session (line 24) | def get_vnc_session(env):
  function get_rewarder_client (line 27) | def get_rewarder_client(env):
  function get_reward_buffer (line 31) | def get_reward_buffer(env):
  function setup_module (line 35) | def setup_module(module):
  class FakeVNCConnection (line 38) | class FakeVNCConnection(object):
    method __init__ (line 39) | def __init__(self, name, address, password, encoding=None, fine_qualit...
    method step (line 50) | def step(self, action):
    method _to_dict (line 54) | def _to_dict(self):
  class FakeVNCSession (line 65) | class FakeVNCSession(object):
    method __init__ (line 66) | def __init__(self):
    method connect (line 69) | def connect(self, name, **kwargs):
    method close (line 72) | def close(self, name=None):
    method step (line 78) | def step(self, action_d):
    method _to_dict (line 88) | def _to_dict(self):
  class FakeRewarderConnection (line 91) | class FakeRewarderConnection(object):
    method __init__ (line 92) | def __init__(self, name, address, label, password, env_id=None, seed=N...
    method reset (line 114) | def reset(self, seed=None):
    method pop (line 117) | def pop(self, peek=False):
    method _to_dict (line 120) | def _to_dict(self):
  class FakeRewarder (line 134) | class FakeRewarder(object):
    method __init__ (line 135) | def __init__(self):
    method reset (line 138) | def reset(self, seed=None, **kwargs):
    method connect (line 142) | def connect(self, name, **kwargs):
    method close (line 146) | def close(self, name=None):
    method pop (line 152) | def pop(self, peek_d):
    method _to_dict (line 164) | def _to_dict(self):
  function test_connect (line 167) | def test_connect():
  function test_describe_handling (line 176) | def test_describe_handling():
  function test_vnc_env (line 198) | def test_vnc_env():
  function test_boundary_simple (line 229) | def test_boundary_simple():
  function test_boundary_multiple (line 249) | def test_boundary_multiple():
  function test_peek (line 281) | def test_peek():

FILE: universe/envs/vnc_core_env/key.py
  class KeyStateHandler (line 68) | class KeyStateHandler(dict):
    method on_key_press (line 86) | def on_key_press(self, symbol, modifiers):
    method on_key_release (line 88) | def on_key_release(self, symbol, modifiers):
    method __getitem__ (line 90) | def __getitem__(self, key):
  function modifiers_string (line 93) | def modifiers_string(modifiers):
  function symbol_string (line 128) | def symbol_string(symbol):
  function motion_string (line 147) | def motion_string(motion):
  function user_key (line 163) | def user_key(scancode):

FILE: universe/envs/vnc_core_env/translator.py
  class AtariKeyState (line 8) | class AtariKeyState(object):
    method __init__ (line 15) | def __init__(self, env):
    method apply_vnc_actions (line 19) | def apply_vnc_actions(self, vnc_actions):
    method to_keysyms (line 36) | def to_keysyms(self):
    method to_index (line 40) | def to_index(self):
  class AtariTranslator (line 45) | class AtariTranslator(object):
    method __init__ (line 49) | def __init__(self, env):
    method keysyms_to_vnc_actions (line 59) | def keysyms_to_vnc_actions(self, keysyms):
    method keysyms_to_index (line 67) | def keysyms_to_index(self, keysyms):
    method index_to_keysyms (line 71) | def index_to_keysyms(self, i):
    method _name_to_index (line 86) | def _name_to_index(self, name):
    method _index_to_name (line 89) | def _index_to_name(self, i):
    method _keysyms_to_name (line 92) | def _keysyms_to_name(self, keysyms):
  class CartPoleTranslator (line 106) | class CartPoleTranslator(object):
    method __init__ (line 107) | def __init__(self, env):
    method keysyms_to_vnc_actions (line 110) | def keysyms_to_vnc_actions(self, keysyms):
    method keysyms_to_index (line 114) | def keysyms_to_index(self, keys):
    method index_to_keysyms (line 120) | def index_to_keysyms(self, i):

FILE: universe/envs/vnc_core_env/vnc_core_env.py
  class GymCoreEnv (line 10) | class GymCoreEnv(vnc_env.VNCEnv):
    method __init__ (line 11) | def __init__(self, gym_core_id, fps=60):
  class GymCoreSyncEnv (line 22) | class GymCoreSyncEnv(GymCoreEnv):
    method __init__ (line 31) | def __init__(self, gym_core_id, fps=60, vnc_pixels=True):
    method _flip_past (line 44) | def _flip_past(self, when_n):
    method _reset (line 67) | def _reset(self):
    method _observation (line 85) | def _observation(self, observation_n):
    method _step (line 93) | def _step(self, action_n):

FILE: universe/envs/vnc_env.py
  function default_client_id (line 30) | def default_client_id():
  function rewarder_session (line 33) | def rewarder_session(which):
  function go_vncdriver (line 42) | def go_vncdriver():
  function py_vncdriver (line 46) | def py_vncdriver():
  function libvnc_vncdriver (line 49) | def libvnc_vncdriver():
  function vnc_session (line 52) | def vnc_session(which=None):
  function build_observation_n (line 89) | def build_observation_n(visual_observation_n, info_n):
  class VNCEnv (line 102) | class VNCEnv(vectorized.Env):
    method __init__ (line 112) | def __init__(self, fps=None, probe_key=None):
    method _seed (line 134) | def _seed(self, seed):
    method configure (line 138) | def configure(self, remotes=None,
    method connect (line 257) | def connect(self, i, name, vnc_address, rewarder_address, vnc_password...
    method _close (line 313) | def _close(self, i=None):
    method _reset (line 335) | def _reset(self):
    method _reset_mask (line 350) | def _reset_mask(self):
    method _pop_rewarder_session (line 353) | def _pop_rewarder_session(self, peek_d):
    method _step_vnc_session (line 368) | def _step_vnc_session(self, compiled_d):
    method _compile_actions (line 388) | def _compile_actions(self, action_n):
    method _action_d (line 409) | def _action_d(self, action_n):
    method _step (line 415) | def _step(self, action_n):
    method _handle_initial_n (line 468) | def _handle_initial_n(self, observation_n, reward_n):
    method _handle_err_n (line 478) | def _handle_err_n(self, err_n, vnc_err_n, info_n, observation_n=None, ...
    method _handle_connect (line 508) | def _handle_connect(self, n=None):
    method _handle_crashed_n (line 521) | def _handle_crashed_n(self, info_n):
    method _propagate_obs_info (line 539) | def _propagate_obs_info(self, info_n, obs_info_n):
    method _render (line 545) | def _render(self, mode='human', close=False):
    method __str__ (line 554) | def __str__(self):
  class Mask (line 561) | class Mask(object):
    method __init__ (line 581) | def __init__(self, connection_labels, initially_masked=True):
    method close (line 591) | def close(self, i):
    method maintain_mask (line 595) | def maintain_mask(self, done_n, info_n):
    method apply_to_actions (line 629) | def apply_to_actions(self, action_n, info_n, mask):
    method apply_to_return (line 638) | def apply_to_return(self, observation_n, reward_n, done_n, info_n, obs...
  function compile_action (line 655) | def compile_action(event):

FILE: universe/envs/vnc_flashgames.py
  class FlashgamesEnv (line 3) | class FlashgamesEnv(vnc_env.VNCEnv):
    method __init__ (line 4) | def __init__(self):

FILE: universe/envs/vnc_gtav.py
  class GTAVEnv (line 5) | class GTAVEnv(vnc_env.VNCEnv):
    method __init__ (line 6) | def __init__(self):

FILE: universe/envs/vnc_internet.py
  class InternetEnv (line 3) | class InternetEnv(vnc_env.VNCEnv):
    method __init__ (line 4) | def __init__(self):

FILE: universe/envs/vnc_starcraft.py
  class StarCraftEnv (line 14) | class StarCraftEnv(vnc_env.VNCEnv):
    method __init__ (line 15) | def __init__(self):

FILE: universe/envs/vnc_wog.py
  class WorldOfGooEnv (line 5) | class WorldOfGooEnv(vnc_env.VNCEnv):
    method __init__ (line 6) | def __init__(self):

FILE: universe/error.py
  class Error (line 3) | class Error(Exception):
  class RPCError (line 6) | class RPCError(Error):
  class ConnectionError (line 9) | class ConnectionError(Error):
  class TimeoutError (line 12) | class TimeoutError(Error):
  class AuthenticationError (line 15) | class AuthenticationError(Error):

FILE: universe/kube/discovery.py
  class Error (line 6) | class Error(Exception):
  function pretty_command (line 11) | def pretty_command(command):
  function log_command (line 14) | def log_command(command, prefix=''):
  function check_call (line 17) | def check_call(command, *args, **kwargs):
  function popen (line 21) | def popen(command, *args, **kwargs):
  function check_with_output (line 25) | def check_with_output(command, *args, **kwargs):
  function interpret_ready (line 33) | def interpret_ready(pod):
  function interpret_ports (line 51) | def interpret_ports(containers):
  class VNCEnvDiscovery (line 72) | class VNCEnvDiscovery(object):
    method __init__ (line 73) | def __init__(self):
    method discover_batches (line 78) | def discover_batches(self):
    method discover (line 94) | def discover(self, batch, force_ready=False):

FILE: universe/pyprofile/__init__.py
  class Error (line 19) | class Error(Exception):
  class ExponentialAverage (line 22) | class ExponentialAverage(object):
    method __init__ (line 23) | def __init__(self, decay=0.1):
    method add (line 29) | def add(self, data):
    method avg (line 51) | def avg(self):
  class RunningVariance (line 54) | class RunningVariance(object):
    method __init__ (line 79) | def __init__(self):
    method add (line 84) | def add(self,x):
    method mean (line 92) | def mean(self):
    method meanfull (line 94) | def meanfull(self):
    method std (line 96) | def std(self):
    method __repr__ (line 100) | def __repr__(self):
  function pretty (line 103) | def pretty(d, unit):
  function pretty_bytes (line 113) | def pretty_bytes(b):
  function pretty_seconds (line 125) | def pretty_seconds(t):
  function thread_id (line 134) | def thread_id():
  class StackProfile (line 137) | class StackProfile(object):
    method __init__ (line 138) | def __init__(self, profile):
    method __enter__ (line 144) | def __enter__(self):
    method __exit__ (line 147) | def __exit__(self, type, value, tb):
    method push (line 150) | def push(self, event):
    method pop (line 158) | def pop(self):
    method _current_stack (line 171) | def _current_stack(self):
  class Profile (line 183) | class Profile(object):
    method __init__ (line 184) | def __init__(self, print_frequency=None, print_filter=None):
    method reset (line 199) | def reset(self):
    method add_export_hook (line 204) | def add_export_hook(self, hook):
    method __enter__ (line 207) | def __enter__(self):
    method __exit__ (line 212) | def __exit__(self, type, value, tb):
    method timing (line 217) | def timing(self, event, time):
    method incr (line 233) | def incr(self, event, amount=1, unit=None):
    method gauge (line 252) | def gauge(self, event, value, delta=False, unit=None):
    method _print_if_needed (line 271) | def _print_if_needed(self):
    method export (line 281) | def export(self, log=True, reset=True):
    method _print_export (line 333) | def _print_export(self, export):

FILE: universe/remotes/allocator_remote.py
  class Stop (line 31) | class Stop(Exception):
  class RequestError (line 34) | class RequestError(Exception):
    method __init__ (line 35) | def __init__(self, message, status_code=None):
  class FatalError (line 41) | class FatalError(RequestError):
  class AllocatorManager (line 44) | class AllocatorManager(threading.Thread):
    method __init__ (line 47) | def __init__(self, client_id, base_url=allocator_base,
    method from_remotes (line 105) | def from_remotes(cls, client_id, remotes, runtime_id, runtime_tag, sta...
    method pop (line 136) | def pop(self, n=None):
    method allocate (line 166) | def allocate(self, handles, initial=False, params={}):
    method close (line 171) | def close(self):
    method run (line 174) | def run(self):
    method _run (line 182) | def _run(self):
    method _process_requests (line 187) | def _process_requests(self):
    method _allocate (line 200) | def _allocate(self, handles, initial, params):
    method _poll (line 237) | def _poll(self):
    method _handle_allocation (line 267) | def _handle_allocation(self, allocation, pop=False):
    method with_retries (line 294) | def with_retries(self, method, *args, **kwargs):
  class AllocatorClient (line 316) | class AllocatorClient(object):
    method __init__ (line 317) | def __init__(self, label, api_key, base_url):
    method _handle_resp (line 325) | def _handle_resp(self, resp):
    method _post_request (line 345) | def _post_request(self, route, data, description):
    method _delete_request (line 354) | def _delete_request(self, route):
    method _get_request (line 360) | def _get_request(self, route):
    method allocation_create (line 366) | def allocation_create(self, client_id, runtime_id, handles, params={},...
    method allocation_refresh (line 373) | def allocation_refresh(self, id, names):
    method allocation_delete (line 378) | def allocation_delete(self, id, names):

FILE: universe/remotes/build.py
  function build (line 7) | def build(client_id, remotes, runtime=None, start_timeout=None, **kwargs):

FILE: universe/remotes/compose/colors.py
  function get_pairs (line 15) | def get_pairs():
  function ansi (line 21) | def ansi(code):
  function ansi_color (line 25) | def ansi_color(code, s):
  function make_color_fn (line 29) | def make_color_fn(code):
  function rainbow (line 37) | def rainbow():

FILE: universe/remotes/compose/container.py
  class Container (line 15) | class Container(object):
    method __init__ (line 20) | def __init__(self, client, dictionary, has_been_inspected=False):
    method from_ps (line 27) | def from_ps(cls, client, dictionary, **kwargs):
    method from_id (line 43) | def from_id(cls, client, id):
    method create (line 47) | def create(cls, client, **options):
    method id (line 52) | def id(self):
    method image (line 56) | def image(self):
    method image_config (line 60) | def image_config(self):
    method short_id (line 64) | def short_id(self):
    method name (line 68) | def name(self):
    method service (line 72) | def service(self):
    method name_without_project (line 76) | def name_without_project(self):
    method number (line 85) | def number(self):
    method ports (line 93) | def ports(self):
    method human_readable_ports (line 98) | def human_readable_ports(self):
    method labels (line 109) | def labels(self):
    method stop_signal (line 113) | def stop_signal(self):
    method log_config (line 117) | def log_config(self):
    method human_readable_state (line 121) | def human_readable_state(self):
    method human_readable_command (line 132) | def human_readable_command(self):
    method environment (line 138) | def environment(self):
    method exit_code (line 146) | def exit_code(self):
    method is_running (line 150) | def is_running(self):
    method is_restarting (line 154) | def is_restarting(self):
    method is_paused (line 158) | def is_paused(self):
    method log_driver (line 162) | def log_driver(self):
    method has_api_logs (line 166) | def has_api_logs(self):
    method attach_log_stream (line 170) | def attach_log_stream(self):
    method get (line 177) | def get(self, key):
    method get_local_port (line 190) | def get_local_port(self, port, protocol='tcp'):
    method get_mount (line 194) | def get_mount(self, mount_dest):
    method start (line 200) | def start(self, **options):
    method stop (line 203) | def stop(self, **options):
    method pause (line 206) | def pause(self, **options):
    method unpause (line 209) | def unpause(self, **options):
    method kill (line 212) | def kill(self, **options):
    method restart (line 215) | def restart(self, **options):
    method remove (line 218) | def remove(self, **options):
    method create_exec (line 221) | def create_exec(self, command, **options):
    method start_exec (line 224) | def start_exec(self, exec_id, **options):
    method rename_to_tmp_name (line 227) | def rename_to_tmp_name(self):
    method inspect_if_not_inspected (line 236) | def inspect_if_not_inspected(self):
    method wait (line 240) | def wait(self):
    method logs (line 243) | def logs(self, *args, **kwargs):
    method inspect (line 246) | def inspect(self):
    method attach (line 251) | def attach(self, *args, **kwargs):
    method __repr__ (line 254) | def __repr__(self):
    method __eq__ (line 257) | def __eq__(self, other):
    method __hash__ (line 262) | def __hash__(self):
  function get_container_name (line 266) | def get_container_name(container):

FILE: universe/remotes/compose/log_printer.py
  function build (line 21) | def build(containers, service_names, **kwargs):
  class LogPresenter (line 27) | class LogPresenter(object):
    method __init__ (line 29) | def __init__(self, prefix_width, color_func):
    method present (line 33) | def present(self, container, line):
  function build_log_presenters (line 40) | def build_log_presenters(service_names, monochrome):
  function max_name_width (line 54) | def max_name_width(service_names, max_index_width=3):
  class LogPrinter (line 64) | class LogPrinter(threading.Thread):
    method __init__ (line 69) | def __init__(self,
    method run (line 82) | def run(self):
  function remove_stopped_threads (line 109) | def remove_stopped_threads(thread_map):
  function build_thread (line 115) | def build_thread(container, presenter, queue, log_args):
  function build_thread_map (line 124) | def build_thread_map(initial_containers, presenters, thread_args):
  class QueueItem (line 131) | class QueueItem(namedtuple('_QueueItem', 'item is_stop exc')):
    method new (line 134) | def new(cls, item):
    method exception (line 138) | def exception(cls, exc):
    method stop (line 142) | def stop(cls):
  function tail_container_logs (line 146) | def tail_container_logs(container, presenter, queue, log_args):
  function get_log_generator (line 161) | def get_log_generator(container):
  function build_no_log_generator (line 167) | def build_no_log_generator(container, log_args):
  function build_log_generator (line 175) | def build_log_generator(container, log_args):
  function wait_on_exit (line 186) | def wait_on_exit(container):
  function start_producer_thread (line 191) | def start_producer_thread(thread_args):
  function watch_events (line 197) | def watch_events(thread_map, event_stream, presenters, thread_args):
  function consume_queue (line 217) | def consume_queue(queue, cascade_stop):

FILE: universe/remotes/compose/progress_stream.py
  class StreamOutputError (line 7) | class StreamOutputError(Exception):
  function stream_output (line 11) | def stream_output(output, stream):
  function print_output_event (line 56) | def print_output_event(event, stream, is_terminal):
  function get_digest_from_pull (line 96) | def get_digest_from_pull(events):
  function get_digest_from_push (line 107) | def get_digest_from_push(events):

FILE: universe/remotes/compose/signals.py
  class ShutdownException (line 7) | class ShutdownException(Exception):
  function shutdown (line 11) | def shutdown(signal, frame):
  function set_signal_handler (line 15) | def set_signal_handler(handler):
  function set_signal_handler_to_shutdown (line 20) | def set_signal_handler_to_shutdown():

FILE: universe/remotes/compose/utils.py
  function get_output_stream (line 15) | def get_output_stream(stream):
  function stream_as_text (line 21) | def stream_as_text(stream):
  function line_splitter (line 34) | def line_splitter(buffer, separator=u'\n'):
  function split_buffer (line 41) | def split_buffer(stream, splitter=None, decoder=lambda a: a):
  function json_splitter (line 66) | def json_splitter(buffer):
  function json_stream (line 78) | def json_stream(stream):
  function json_hash (line 86) | def json_hash(obj):
  function microseconds_from_time_nano (line 93) | def microseconds_from_time_nano(time_nano):
  function build_string_dict (line 97) | def build_string_dict(source_dict):

FILE: universe/remotes/docker_remote.py
  function random_alphanumeric (line 24) | def random_alphanumeric(length=14):
  function pretty_command (line 32) | def pretty_command(command):
  class DockerManager (line 35) | class DockerManager(object):
    method __init__ (line 36) | def __init__(self, runtime, n, reuse=False, start_timeout=None):
    method allocate (line 57) | def allocate(self, handles, initial=False, params={}):
    method pop (line 60) | def pop(self, n=None):
    method _start (line 79) | def _start(self):
    method close (line 87) | def close(self):
    method start_logging (line 91) | def start_logging(self, instances):
    method healthcheck (line 105) | def healthcheck(self, instances):
  function get_client (line 113) | def get_client():
  class PortAssigner (line 159) | class PortAssigner(object):
    method __init__ (line 160) | def __init__(self, reuse=False):
    method _refresh_ports (line 167) | def _refresh_ports(self):
    method allocate_ports (line 177) | def allocate_ports(self, num):
  class DockerInstance (line 205) | class DockerInstance(object):
    method __init__ (line 206) | def __init__(self, assigner, runtime, label='main'):
    method start (line 226) | def start(self, attempts=None):
    method _spawn (line 246) | def _spawn(self):
    method _pull_image (line 287) | def _pull_image(self):
    method _spawn_container (line 300) | def _spawn_container(self):
    method _start (line 319) | def _start(self):
    method _remove (line 338) | def _remove(self):
    method __del__ (line 360) | def __del__(self):
    method close (line 363) | def close(self):
    method client (line 377) | def client(self):

FILE: universe/remotes/hardcoded_addresses.py
  class HardcodedAddresses (line 11) | class HardcodedAddresses(object):
    method build (line 13) | def build(cls, remotes, **kwargs):
    method __init__ (line 27) | def __init__(self, vnc_addresses, rewarder_addresses, vnc_password, re...
    method pop (line 51) | def pop(self, n=None):
    method allocate (line 80) | def allocate(self, handles, initial=False, params={}):
    method close (line 86) | def close(self):
  function parse_remotes (line 89) | def parse_remotes(remotes):

FILE: universe/remotes/healthcheck.py
  function run (line 12) | def run(vnc_addresses, rewarder_addresses, timeout=None, start_timeout=N...
  function host_port (line 16) | def host_port(address, default_port=None):
  class Healthcheck (line 26) | class Healthcheck(object):
    method __init__ (line 27) | def __init__(self, vnc_addresses, rewarder_addresses, timeout=None, st...
    method _register_vnc (line 39) | def _register_vnc(self, address, start_time=None):
    method _register_rewarder (line 67) | def _register_rewarder(self, address, start_time=None):
    method run (line 101) | def run(self):

FILE: universe/remotes/remote.py
  class Remote (line 1) | class Remote(object):
    method __init__ (line 2) | def __init__(self, handle, vnc_address, vnc_password, rewarder_address...
    method __str__ (line 10) | def __str__(self):
    method __repr__ (line 13) | def __repr__(self):

FILE: universe/rewarder/connection_timer.py
  class ConnectionTimer (line 15) | class ConnectionTimer(protocol.Protocol):
    method connectionMade (line 16) | def connectionMade(self):
  function start (line 19) | def start(endpoint):
  function measure_clock_skew (line 25) | def measure_clock_skew(label, host):
  class Clockskew (line 43) | class Clockskew(protocol.ProcessProtocol):
    method __init__ (line 44) | def __init__(self, label, cmd):
    method outReceived (line 52) | def outReceived(self, data):
    method errReceived (line 55) | def errReceived(self, data):
    method processExited (line 58) | def processExited(self, reason):
  class ConnectionTimerException (line 71) | class ConnectionTimerException(Exception):

FILE: universe/rewarder/env_status.py
  function parse_episode_id (line 6) | def parse_episode_id(episode_id):
  function generate_episode_id (line 11) | def generate_episode_id(parsed):
  function compare_ids (line 16) | def compare_ids(a, b):
  class EnvStatus (line 28) | class EnvStatus(object):
    method __init__ (line 29) | def __init__(self, label=None, primary=True):
    method env_info (line 38) | def env_info(self):
    method set_env_info (line 47) | def set_env_info(self, env_state=None, env_id=None, episode_id=None, b...
    method episode_id (line 86) | def episode_id(self):
    method env_state (line 91) | def env_state(self):
    method env_state (line 96) | def env_state(self, value):
    method env_id (line 101) | def env_id(self):
    method env_id (line 106) | def env_id(self, value):
    method fps (line 110) | def fps(self):
    method wait_for_env_state_change (line 114) | def wait_for_env_state_change(self, start_state):

FILE: universe/rewarder/merge.py
  function merge_infos (line 4) | def merge_infos(info1, info2):
  function merge_reward_n (line 30) | def merge_reward_n(accum_reward_n, reward_n):
  function merge_done_n (line 36) | def merge_done_n(accum_done_n, done_n):
  function _merge_observation (line 42) | def _merge_observation(accum_observation, observation):
  function merge_observation_n (line 60) | def merge_observation_n(accum_observation_n, observation_n):
  function merge_n (line 65) | def merge_n(

FILE: universe/rewarder/remote.py
  class Exit (line 24) | class Exit(Exception):
  class RewarderProtocol (line 27) | class RewarderProtocol(websocket.WebSocketServerProtocol):
    method onConnect (line 30) | def onConnect(self, request):
    method authenticate (line 43) | def authenticate(self, request):
    method onOpen (line 61) | def onOpen(self):
    method onMessage (line 75) | def onMessage(self, payload, isBinary):
    method onClose (line 105) | def onClose(self, wasClean, code, reason):
    method send_message (line 109) | def send_message(self, method, body, headers):
    method reject (line 135) | def reject(self, message):
  class ControlBuffer (line 140) | class ControlBuffer(object):
    method __init__ (line 141) | def __init__(self, cv):
    method recv_rpc (line 145) | def recv_rpc(self, context, payload):
    method client_disconnect (line 152) | def client_disconnect(self, conn, stats):
    method get (line 155) | def get(self, *args, **kwargs):
  class AgentConn (line 161) | class AgentConn(object):
    method __init__ (line 162) | def __init__(self, env_status, cv, control_buffer, error_buffer, idle_...
    method active_clients (line 175) | def active_clients(self):
    method listen (line 178) | def listen(self, port=15900):
    method check_message (line 186) | def check_message(self, conn):
    method _register (line 220) | def _register(self, conn, observer=False):
    method _unregister (line 225) | def _unregister(self, conn):
    method _broadcast (line 243) | def _broadcast(self, method, body, headers=None, conn=None):
    method send_env_text (line 252) | def send_env_text(self, text, episode_id):
    method _send_env_text (line 256) | def _send_env_text(self, text, episode_id):
    method send_env_observation (line 261) | def send_env_observation(self, observation, episode_id):
    method _send_env_observation (line 264) | def _send_env_observation(self, observation, episode_id, conn=None):
    method send_env_reward (line 269) | def send_env_reward(self, reward, done, info, episode_id):
    method _send_env_reward (line 276) | def _send_env_reward(self, reward, done, info, episode_id):
    method send_env_describe_from_env_info (line 283) | def send_env_describe_from_env_info(self, env_info):
    method send_env_describe (line 287) | def send_env_describe(self, env_id, env_state, episode_id, fps, header...
    method _send_env_describe (line 290) | def _send_env_describe(self, env_id, env_state, episode_id, fps, heade...
    method send_reply_error (line 310) | def send_reply_error(self, *args, **kwargs):
    method _send_reply_error (line 313) | def _send_reply_error(self, message, parent_message_id, parent_context):
    method send_reply_env_reset (line 324) | def send_reply_env_reset(self, *args, **kwargs):
    method _send_reply_env_reset (line 327) | def _send_reply_env_reset(self, parent_message_id, parent_context, epi...
    method check_status (line 337) | def check_status(self):
  class RewardLogger (line 361) | class RewardLogger(object):
    method __init__ (line 362) | def __init__(self):
    method reset (line 365) | def reset(self, log=True, episode_stats=True):
    method record (line 385) | def record(self, reward, done, info):
    method _log_reset (line 398) | def _log_reset(self):
    method _log (line 401) | def _log(self):

FILE: universe/rewarder/reward_buffer.py
  class RewardState (line 11) | class RewardState(object):
    method __init__ (line 12) | def __init__(self, label, episode_id):
    method push_time (line 25) | def push_time(self, remote_time, local_time):
    method set_env_info (line 30) | def set_env_info(self, env_state):
    method push_text (line 33) | def push_text(self, text):
    method push_done (line 36) | def push_done(self, done, info):
    method push_info (line 44) | def push_info(self, info):
    method push (line 47) | def push(self, reward, done, info):
    method pop_text (line 56) | def pop_text(self):
    method pop_info (line 61) | def pop_info(self):
    method pop (line 73) | def pop(self):
    method set_observation (line 88) | def set_observation(self, observation):
  class RewardBuffer (line 92) | class RewardBuffer(object):
    method __init__ (line 93) | def __init__(self, label):
    method reward_state (line 107) | def reward_state(self, episode_id):
    method set_env_info (line 131) | def set_env_info(self, env_state, env_id, episode_id, fps):
    method set_observation (line 145) | def set_observation(self, episode_id, observation):
    method push_time (line 149) | def push_time(self, episode_id, remote_time, local_time):
    method push_text (line 153) | def push_text(self, episode_id, text):
    method push_info (line 158) | def push_info(self, episode_id, info):
    method push (line 163) | def push(self, episode_id, reward, done, info):
    method pop (line 168) | def pop(self, peek=False):
    method mask (line 219) | def mask(self):
    method reset (line 225) | def reset(self, episode_id):
    method _max_id (line 233) | def _max_id(self):
    method _valid_ids (line 241) | def _valid_ids(self):
    method _advance (line 244) | def _advance(self):
    method _drop_below (line 264) | def _drop_below(self, episode_id, quiet=False):
    method wait_for_step (line 279) | def wait_for_step(self, error_buffer=None, timeout=None):

FILE: universe/rewarder/reward_proxy_server.py
  class RewardServerClient (line 12) | class RewardServerClient(websocket.WebSocketClientProtocol, object):
    method __init__ (line 13) | def __init__(self):
    method onConnect (line 20) | def onConnect(self, request):
    method onOpen (line 31) | def onOpen(self):
    method onMessage (line 34) | def onMessage(self, msg, isBinary):
    method onClose (line 49) | def onClose(self, wasClean, code, reason):
    method close (line 52) | def close(self):
  class RewardProxyServer (line 57) | class RewardProxyServer(websocket.WebSocketServerProtocol, object):
    method next_id (line 62) | def next_id(cls):
    method __init__ (line 67) | def __init__(self):
    method pop_buffer (line 76) | def pop_buffer(self):
    method begin_recording (line 83) | def begin_recording(self):
    method onConnect (line 119) | def onConnect(self, request):
    method onOpen (line 123) | def onOpen(self):
    method connect_upstream (line 127) | def connect_upstream(self, tries=1, max_attempts=7):
    method close (line 168) | def close(self):
    method onClose (line 172) | def onClose(self, wasClean, code, reason):
    method onMessage (line 181) | def onMessage(self, msg, binary):
    method record_message (line 192) | def record_message(self, msg, from_rewarder):

FILE: universe/rewarder/rewarder_client.py
  class RemoteError (line 14) | class RemoteError(error.Error):
  class RewarderClient (line 17) | class RewarderClient(websocket.WebSocketClientProtocol):
    method __init__ (line 18) | def __init__(self):
    method send_reset (line 31) | def send_reset(self, env_id, seed, fps, episode_id):
    method _finish_reset (line 45) | def _finish_reset(self, episode_id):
    method onConnect (line 49) | def onConnect(self, request):
    method waitForWebsocketConnection (line 59) | def waitForWebsocketConnection(self):
    method send (line 62) | def send(self, method, body, headers=None, expect_reply=False):
    method _manual_recv (line 100) | def _manual_recv(self, method, body, headers={}):
    method recv (line 105) | def recv(self, context, response):
    method _make_context (line 176) | def _make_context(self):
    method onMessage (line 179) | def onMessage(self, payload, isBinary):
    method onClose (line 196) | def onClose(self, wasClean, code, reason):
    method close (line 216) | def close(self, code=1000, reason=None):

FILE: universe/rewarder/rewarder_session.py
  function _ping (line 19) | def _ping(client):
  class RewarderSession (line 22) | class RewarderSession(object):
    method __init__ (line 23) | def __init__(self):
    method close (line 37) | def close(self, name=None, reason=u'closed by RewarderSession.close'):
    method connect (line 64) | def connect(self, name, address, label, password, env_id=None, seed=No...
    method _already_closed (line 94) | def _already_closed(self, i):
    method _connect (line 102) | def _connect(self, name, address, env_id, seed, fps, i, network, env_s...
    method pop_errors (line 221) | def pop_errors(self):
    method reset (line 231) | def reset(self, seed=None, env_id=None):
    method _reset (line 237) | def _reset(self, seed=None, env_id=None):
    method _send_env_reset (line 250) | def _send_env_reset(self, client, seed=None, episode_id=None, env_id=N...
    method pop (line 260) | def pop(self, warn=True, peek_d=None):
    method wait (line 281) | def wait(self, timeout=None):
    method send_action (line 292) | def send_action(self, action_n, env_id):
    method _send_action (line 296) | def _send_action(self, env_id, action_n):
    method _send_env_action (line 301) | def _send_env_action(self, client, env_id, action_n):
    method rewards_count (line 311) | def rewards_count(self):
    method pop_observation (line 315) | def pop_observation(self):
  class Network (line 329) | class Network(object):
    method __init__ (line 330) | def __init__(self):
    method active (line 343) | def active(self):
    method reversed_clock_skew (line 348) | def reversed_clock_skew(self):
    method _report (line 355) | def _report(self):
    method _start (line 370) | def _start(self):
    method close (line 380) | def close(self):
    method calibrate (line 388) | def calibrate(self, client):
    method _start_measure_connection_time (line 420) | def _start_measure_connection_time(self, d):
    method _measure_connection_time (line 424) | def _measure_connection_time(self, d, connection_time_m, i):
    method _start_measure_application_ping (line 441) | def _start_measure_application_ping(self, d=None):
    method _measure_application_ping (line 449) | def _measure_application_ping(self, d, clock_skew_m, request_overhead_...
    method _update_exposed_metrics (line 507) | def _update_exposed_metrics(self):
    method _start_measure_clock_skew (line 513) | def _start_measure_clock_skew(self):

FILE: universe/rewarder/tests/test_reward_buffer.py
  function test_prereset (line 3) | def test_prereset():
  function test_mask_peek (line 11) | def test_mask_peek():
  function test_single (line 21) | def test_single():
  function test_multiple (line 33) | def test_multiple():
  function test_double_reset (line 59) | def test_double_reset():

FILE: universe/runtimes/registration.py
  class UnregisteredRuntime (line 8) | class UnregisteredRuntime(error.Unregistered):
  class DockerRuntime (line 14) | class DockerRuntime(object):
    method __init__ (line 16) | def __init__(self, id=id, image=None, command=None, host_config=None, ...
    method server_registry (line 36) | def server_registry(self):
    method _cli_flags (line 43) | def _cli_flags(self):
    method cli_command (line 68) | def cli_command(self, vnc_port, rewarder_port, extra_flags=[]):
  class WindowsRuntime (line 77) | class WindowsRuntime(object):
    method __init__ (line 79) | def __init__(self, id=id, default_params=None):
  class Registry (line 88) | class Registry(object):
    method __init__ (line 89) | def __init__(self):
    method register_runtime (line 92) | def register_runtime(self, id, kind, **kwargs):
    method runtime_spec (line 100) | def runtime_spec(self, id):

FILE: universe/spaces/diagnostics.py
  class DiagnosticEvent (line 1) | class DiagnosticEvent(object):

FILE: universe/spaces/hardcoded.py
  class Hardcoded (line 3) | class Hardcoded(object):
    method __init__ (line 4) | def __init__(self, actions):
    method contains (line 7) | def contains(self, action):
    method sample (line 10) | def sample(self):
    method __getitem__ (line 14) | def __getitem__(self, i):

FILE: universe/spaces/joystick_action_space.py
  class JoystickActionSpace (line 8) | class JoystickActionSpace(gym.Space):
    method __init__ (line 12) | def __init__(self, axis_x=False, axis_y=False, axis_z=False, axis_rx=F...
    method contains (line 43) | def contains(self, action):
    method sample (line 53) | def sample(self):
  class JoystickActionSpaceException (line 63) | class JoystickActionSpaceException(Exception):
  function box_axis (line 67) | def box_axis():

FILE: universe/spaces/joystick_event.py
  class JoystickEvent (line 1) | class JoystickEvent(object):
  class JoystickAxisEvent (line 5) | class JoystickAxisEvent(JoystickEvent):
    method __init__ (line 6) | def __init__(self, amount):
    method __repr__ (line 9) | def __repr__(self):
    method __str__ (line 12) | def __str__(self):
    method __hash__ (line 15) | def __hash__(self):
    method __eq__ (line 18) | def __eq__(self, other):
    method compile (line 22) | def compile(self):
  class JoystickAxisXEvent (line 26) | class JoystickAxisXEvent(JoystickAxisEvent):
  class JoystickAxisYEvent (line 30) | class JoystickAxisYEvent(JoystickAxisEvent):
  class JoystickAxisZEvent (line 34) | class JoystickAxisZEvent(JoystickAxisEvent):
  class JoystickAxisRxEvent (line 38) | class JoystickAxisRxEvent(JoystickAxisEvent):
  class JoystickAxisRyEvent (line 42) | class JoystickAxisRyEvent(JoystickAxisEvent):
  class JoystickAxisRzEvent (line 46) | class JoystickAxisRzEvent(JoystickAxisEvent):
  class JoystickSlider0Event (line 50) | class JoystickSlider0Event(JoystickAxisEvent):
  class JoystickSlider1Event (line 54) | class JoystickSlider1Event(JoystickAxisEvent):

FILE: universe/spaces/vnc_action_space.py
  class VNCActionSpace (line 9) | class VNCActionSpace(gym.Space):
    method __init__ (line 28) | def __init__(self, keys=None, buttonmasks=None, screen_shape=(1024, 72...
    method contains (line 48) | def contains(self, action):
    method sample (line 69) | def sample(self):

FILE: universe/spaces/vnc_event.py
  class VNCEvent (line 5) | class VNCEvent(object):
  function keycode (line 8) | def keycode(key):
  class KeyEvent (line 16) | class KeyEvent(VNCEvent):
    method build (line 24) | def build(cls, keys, down=None):
    method by_name (line 45) | def by_name(cls, key, down=None):
    method __init__ (line 48) | def __init__(self, key, down=True):
    method compile (line 53) | def compile(self):
    method __repr__ (line 56) | def __repr__(self):
    method __str__ (line 68) | def __str__(self):
    method __hash__ (line 71) | def __hash__(self):
    method __eq__ (line 74) | def __eq__(self, other):
    method key_name (line 80) | def key_name(self):
  class PointerEvent (line 84) | class PointerEvent(VNCEvent):
    method __init__ (line 85) | def __init__(self, x, y, buttonmask=0):
    method compile (line 90) | def compile(self):
    method __repr__ (line 93) | def __repr__(self):
    method __str__ (line 96) | def __str__(self):

FILE: universe/spaces/vnc_observation_space.py
  class VNCObservationSpace (line 3) | class VNCObservationSpace(gym.Space):
    method contains (line 6) | def contains(self, x):

FILE: universe/twisty.py
  function _get_reactor (line 9) | def _get_reactor(platform):
  class TwistedThread (line 32) | class TwistedThread(threading.Thread):
    method start_once (line 37) | def start_once(cls):
    method run (line 45) | def run(self):

FILE: universe/utils/__init__.py
  class ErrorBuffer (line 16) | class ErrorBuffer(object):
    method __init__ (line 17) | def __init__(self):
    method __enter__ (line 20) | def __enter__(self):
    method __exit__ (line 23) | def __exit__(self, type, value, traceback):
    method __call__ (line 27) | def __call__(self, error, wrap=True):
    method record (line 30) | def record(self, error, wrap=True):
    method check (line 40) | def check(self, timeout=None):
    method blocking_check (line 51) | def blocking_check(self, timeout=None):
  function format_error (line 64) | def format_error(e):
  function queue_get (line 84) | def queue_get(local_queue):
  function blockingCallFromThread (line 93) | def blockingCallFromThread(f, *a, **kw):
  function repeat_space (line 109) | def repeat_space(space, n):
  function random_alphanumeric (line 114) | def random_alphanumeric(length=14):
  function best_effort (line 123) | def best_effort(function, *args, **kwargs):
  function basic_auth_encode (line 136) | def basic_auth_encode(username, password=''):
  function basic_auth_decode (line 140) | def basic_auth_decode(header):
  function default_password (line 150) | def default_password():
  class PeriodicLog (line 159) | class PeriodicLog(object):
    method log (line 160) | def log(self, obj, name, msg, *args, **kwargs):
    method log_debug (line 176) | def log_debug(self, obj, name, msg, *args, **kwargs):
  function thread_name (line 195) | def thread_name():
  function exit_on_signal (line 198) | def exit_on_signal():

FILE: universe/utils/display.py
  function fmt_plusminus (line 10) | def fmt_plusminus(mean, dev):
  function compute_timestamps_pair_max (line 17) | def compute_timestamps_pair_max(time_m_2, flat=True):
  function display_timestamps_pair_compact (line 41) | def display_timestamps_pair_compact(time_m_2):
  function display_timestamps_pair (line 61) | def display_timestamps_pair(time_m_2):
  function compute_timestamps_sigma_n (line 74) | def compute_timestamps_sigma_n(time_m):
  function compute_timestamps_sigma (line 85) | def compute_timestamps_sigma(time_m):
  function display_timestamps (line 94) | def display_timestamps(time_m):
  function compute_timestamps (line 101) | def compute_timestamps(time_m):
  function display_timestamps_n (line 109) | def display_timestamps_n(time_m):
  function standard_error (line 113) | def standard_error(ary, axis=0):
  function display_timestamp (line 119) | def display_timestamp(time):
  function pick_time_units (line 124) | def pick_time_units(time):

FILE: universe/vectorized/core.py
  class Env (line 5) | class Env(gym.Env):
  class Wrapper (line 19) | class Wrapper(Env, gym.Wrapper):
    method __init__ (line 27) | def __init__(self, env):
    method n (line 40) | def n(self):
    method configure (line 43) | def configure(self, **kwargs):
  class ObservationWrapper (line 46) | class ObservationWrapper(Wrapper, gym.ObservationWrapper):
  class RewardWrapper (line 49) | class RewardWrapper(Wrapper, gym.RewardWrapper):
  class ActionWrapper (line 52) | class ActionWrapper(Wrapper, gym.ActionWrapper):

FILE: universe/vectorized/multiprocessing_env.py
  class Error (line 13) | class Error(Exception):
  function display_name (line 16) | def display_name(exception):
  function render_dict (line 24) | def render_dict(error):
  class Worker (line 31) | class Worker(object):
    method __init__ (line 32) | def __init__(self, env_m, worker_idx):
    method _clear_state (line 49) | def _clear_state(self):
    method start (line 54) | def start(self):
    method _parent_recv (line 57) | def _parent_recv(self):
    method _child_send (line 63) | def _child_send(self, msg):
    method _parent_send (line 66) | def _parent_send(self, msg):
    method close_start (line 77) | def close_start(self):
    method close_finish (line 80) | def close_finish(self):
    method reset_start (line 83) | def reset_start(self):
    method reset_finish (line 86) | def reset_finish(self):
    method step_start (line 89) | def step_start(self, action_m):
    method step_finish (line 93) | def step_finish(self):
    method mask_start (line 96) | def mask_start(self, i):
    method seed_start (line 99) | def seed_start(self, seed_m):
    method render_start (line 102) | def render_start(self, mode, close):
    method render_finish (line 105) | def render_finish(self):
    method run (line 108) | def run(self):
    method do_run (line 116) | def do_run(self):
    method step_m (line 155) | def step_m(self, action_m):
  function step_n (line 178) | def step_n(worker_n, action_n):
  function reset_n (line 199) | def reset_n(worker_n):
  function seed_n (line 210) | def seed_n(worker_n, seed_n):
  function mask (line 218) | def mask(worker_n, i):
  function render_n (line 227) | def render_n(worker_n, mode, close):
  function close_n (line 242) | def close_n(worker_n):
  class MultiprocessingEnv (line 261) | class MultiprocessingEnv(core.Env):
    method __init__ (line 267) | def __init__(self, env_id):
    method configure (line 282) | def configure(self, n=1, pool_size=None, episode_limit=None):
    method _seed (line 299) | def _seed(self, seed):
    method _reset (line 303) | def _reset(self):
    method _step (line 306) | def _step(self, action_n):
    method _render (line 309) | def _render(self, mode='human', close=False):
    method mask (line 312) | def mask(self, i):
    method _close (line 315) | def _close(self):

FILE: universe/vectorized/tests/test_monitoring.py
  function test_multiprocessing_env_monitoring (line 8) | def test_multiprocessing_env_monitoring():
  function test_vnc_monitoring (line 23) | def test_vnc_monitoring():

FILE: universe/vectorized/vectorize_filter.py
  class Filter (line 3) | class Filter(object):
    method _after_reset (line 4) | def _after_reset(self, observation):
    method _after_step (line 7) | def _after_step(self, observation, reward, done, info):
  class VectorizeFilter (line 10) | class VectorizeFilter(core.Wrapper):
    method __init__ (line 18) | def __init__(self, env, filter_factory, *args, **kwargs):
    method _reset (line 25) | def _reset(self):
    method _step (line 32) | def _step(self, action_n):
    method __str__ (line 48) | def __str__(self):

FILE: universe/vncdriver/auth.py
  class RFBDes (line 7) | class RFBDes(pydes.des):
    method setKey (line 8) | def setKey(self, key):
  function challenge (line 31) | def challenge():
  function challenge_response (line 39) | def challenge_response(challenge, password=None):

FILE: universe/vncdriver/dual_proxy_server.py
  class DualProxyServer (line 18) | class DualProxyServer(VNCProxyServer):
    method __init__ (line 19) | def __init__(self, action_queue=None, error_buffer=None, enable_loggin...
    method _log_info (line 25) | def _log_info(self, msg, *args, **kwargs):
    method recv_ClientInit (line 28) | def recv_ClientInit(self, block):
    method close (line 47) | def close(self):

FILE: universe/vncdriver/error.py
  class Error (line 1) | class Error(Exception):

FILE: universe/vncdriver/fbs_reader.py
  class InvalidFBSFileError (line 7) | class InvalidFBSFileError(error.Error):
  class FBSReader (line 10) | class FBSReader(object):
    method __init__ (line 11) | def __init__(self, path):
    method __iter__ (line 24) | def __iter__(self):
    method read_safe (line 27) | def read_safe(self, size=None):
    method next (line 45) | def next(self):
    method __next__ (line 48) | def __next__(self):
    method close (line 67) | def close(self):

FILE: universe/vncdriver/fbs_writer.py
  class FBSWriter (line 9) | class FBSWriter(object):
    method __init__ (line 10) | def __init__(self, path):
    method write (line 27) | def write(self, data):
    method _write_metadata (line 54) | def _write_metadata(self):
    method close (line 61) | def close(self):
    method __del__ (line 71) | def __del__(self):

FILE: universe/vncdriver/libvnc_session.py
  function load_pygame (line 11) | def load_pygame():
  class LibVNCSession (line 25) | class LibVNCSession(object):
    method __init__ (line 26) | def __init__(self, remotes, error_buffer, encoding=None, compress_leve...
    method flip (line 71) | def flip(self):
    method step (line 74) | def step(self, action):
    method render (line 77) | def render(self):
    method _guard (line 80) | def _guard(self, fn):
    method _render (line 86) | def _render(self):
    method before_render (line 103) | def before_render(self):
    method close (line 116) | def close(self):

FILE: universe/vncdriver/screen/base.py
  class Screen (line 6) | class Screen(object):

FILE: universe/vncdriver/screen/numpy_screen.py
  class NumpyScreen (line 14) | class NumpyScreen(object):
    method __init__ (line 15) | def __init__(self, width, height):
    method set_paint_cursor (line 49) | def set_paint_cursor(self, paint_cursor):
    method peek (line 52) | def peek(self):
    method flip (line 56) | def flip(self):
    method apply_action (line 80) | def apply_action(self, action):
    method apply (line 92) | def apply(self, framebuffer_update):
    method _apply (line 102) | def _apply(self, framebuffer_update):
    method update_back (line 116) | def update_back(self):
    method _update_back (line 120) | def _update_back(self):
    method _update_rectangle (line 134) | def _update_rectangle(self, x, y, width, height, data):
    method _update_cursor_shape (line 138) | def _update_cursor_shape(self, hotx, hoty, width, height, image, mask):
    method _paint_cursor (line 142) | def _paint_cursor(self):
    method _unpaint_cursor (line 178) | def _unpaint_cursor(self):

FILE: universe/vncdriver/screen/pyglet_screen.py
  class PygletScreen (line 12) | class PygletScreen(object):
    method __init__ (line 13) | def __init__(self, bitmap=None):
    method flip (line 20) | def flip(self):
    method _initialize (line 31) | def _initialize(self):
    method update_rectangle (line 40) | def update_rectangle(self, x, y, width, height, data):
    method apply (line 49) | def apply(self, framebuffer_update):

FILE: universe/vncdriver/screen/screen_buffer.py
  class ScreenBuffer (line 9) | class ScreenBuffer(object):
    method __init__ (line 10) | def __init__(self):
    method apply_format (line 15) | def apply_format(self, attrs):
    method update_rectangle (line 21) | def update_rectangle(self, x, y, width, height, data):
    method copy_rectangle (line 31) | def copy_rectangle(self, src_x, src_y, x, y, width, height):
    method fill_rectangle (line 42) | def fill_rectangle(self, x, y, width, height, color):
    method framebuffer_update_finish (line 52) | def framebuffer_update_finish(self):
    method _push (line 57) | def _push(self, update):
    method pop (line 61) | def pop(self):
    method peek (line 70) | def peek(self):

FILE: universe/vncdriver/server_messages.py
  class FramebufferUpdate (line 16) | class FramebufferUpdate(object):
    method __init__ (line 17) | def __init__(self, rectangles):
  class Rectangle (line 20) | class Rectangle(object):
    method __init__ (line 21) | def __init__(self, x, y, width, height, encoding):
  class PseudoCursorEncoding (line 28) | class PseudoCursorEncoding(object):
    method __init__ (line 29) | def __init__(self, image, mask):
    method parse_rectangle (line 34) | def parse_rectangle(cls, client, x, y, width, height, data):
  class RAWEncoding (line 46) | class RAWEncoding(object):
    method __init__ (line 47) | def __init__(self, data):
    method parse_rectangle (line 51) | def parse_rectangle(cls, client, x, y, width, height, data):
  class ZlibEncoding (line 57) | class ZlibEncoding(object):
    method __init__ (line 58) | def __init__(self, data):
    method parse_rectangle (line 62) | def parse_rectangle(cls, client, x, y, width, height, data):
  class ZRLEEncoding (line 70) | class ZRLEEncoding(object):
    method __init__ (line 71) | def __init__(self, data):
    method parse_rectangle (line 75) | def parse_rectangle(cls, client, x, y, width, height, data):
    method _read (line 91) | def _read(cls, x, y, width, height, buf, bytes_per_pixel):
    method _read_tile (line 105) | def _read_tile(cls, tile, buf, tile_width, tile_height, bytes_per_pixel):

FILE: universe/vncdriver/vendor/pydes.py
  class _baseDes (line 107) | class _baseDes(object):
    method __init__ (line 108) | def __init__(self, mode=ECB, IV=None, pad=None, padmode=PAD_NORMAL):
    method getKey (line 126) | def getKey(self):
    method setKey (line 130) | def setKey(self, key):
    method getMode (line 135) | def getMode(self):
    method setMode (line 139) | def setMode(self, mode):
    method getPadding (line 143) | def getPadding(self):
    method setPadding (line 147) | def setPadding(self, pad):
    method getPadMode (line 153) | def getPadMode(self):
    method setPadMode (line 157) | def setPadMode(self, mode):
    method getIV (line 161) | def getIV(self):
    method setIV (line 165) | def setIV(self, IV):
    method _padData (line 172) | def _padData(self, data, pad, padmode):
    method _unpadData (line 201) | def _unpadData(self, data, pad, padmode):
    method _guardAgainstUnicode (line 228) | def _guardAgainstUnicode(self, data):
  class des (line 247) | class des(_baseDes):
    method __init__ (line 397) | def __init__(self, key, mode=ECB, IV=None, pad=None, padmode=PAD_NORMAL):
    method setKey (line 411) | def setKey(self, key):
    method __String_to_BitList (line 416) | def __String_to_BitList(self, data):
    method __BitList_to_String (line 437) | def __BitList_to_String(self, data):
    method __permutate (line 454) | def __permutate(self, table, block):
    method __create_sub_keys (line 460) | def __create_sub_keys(self):
    method __des_crypt (line 485) | def __des_crypt(self, block, crypt_type):
    method crypt (line 564) | def crypt(self, data, crypt_type):
    method encrypt (line 642) | def encrypt(self, data, pad=None, padmode=None):
    method decrypt (line 661) | def decrypt(self, data, pad=None, padmode=None):
  class triple_des (line 687) | class triple_des(_baseDes):
    method __init__ (line 708) | def __init__(self, key, mode=ECB, IV=None, pad=None, padmode=PAD_NORMAL):
    method setKey (line 712) | def setKey(self, key):
    method setMode (line 739) | def setMode(self, mode):
    method setPadding (line 745) | def setPadding(self, pad):
    method setPadMode (line 751) | def setPadMode(self, mode):
    method setIV (line 757) | def setIV(self, IV):
    method encrypt (line 763) | def encrypt(self, data, pad=None, padmode=None):
    method decrypt (line 807) | def decrypt(self, data, pad=None, padmode=None):

FILE: universe/vncdriver/vnc_client.py
  class UnknownEncoding (line 26) | class UnknownEncoding(Exception):
  function peer_address (line 29) | def peer_address(peer):
  class Framebuffer (line 32) | class Framebuffer(object):
    method __init__ (line 33) | def __init__(self, width, height, server_pixel_format, name):
    method apply_format (line 43) | def apply_format(self, server_pixel_format):
  class VNCClient (line 68) | class VNCClient(protocol.Protocol, object):
    method __init__ (line 69) | def __init__(self):
    method connectionLost (line 93) | def connectionLost(self, reason):
    method sendMessage (line 98) | def sendMessage(self, data):
    method dataReceived (line 104) | def dataReceived(self, data):
    method flush (line 114) | def flush(self):
    method handle (line 139) | def handle(self, type, block):
    method recv_ProtocolVersion_Handshake (line 148) | def recv_ProtocolVersion_Handshake(self, block):
    method recv_Security_Handshake (line 157) | def recv_Security_Handshake(self, block):
    method recv_SecurityResult_Handshake (line 168) | def recv_SecurityResult_Handshake(self, block):
    method recv_SecurityResult_Handshake_failed_length (line 180) | def recv_SecurityResult_Handshake_failed_length(self, block):
    method recv_SecurityResult_Handshake_failed_reason (line 184) | def recv_SecurityResult_Handshake_failed_reason(self, block):
    method recv_VNC_Authentication (line 187) | def recv_VNC_Authentication(self, block):
    method send_ClientInit (line 192) | def send_ClientInit(self):
    method recv_ServerInit (line 197) | def recv_ServerInit(self, block):
    method recv_ServerInit_name (line 202) | def recv_ServerInit_name(self, block, width, height, server_pixel_form...
    method recv_ServerToClient (line 221) | def recv_ServerToClient(self, block):
    method recv_FramebufferUpdate (line 239) | def recv_FramebufferUpdate(self, block):
    method _process_rectangles (line 249) | def _process_rectangles(self):
    method recv_Rectangle (line 266) | def recv_Rectangle(self, block):
    method recv_DecodePseudoCursor (line 286) | def recv_DecodePseudoCursor(self, block, x, y, width, height):
    method recv_DecodeRAW (line 292) | def recv_DecodeRAW(self, block, x, y, width, height):
    method recv_DecodeZRLE (line 299) | def recv_DecodeZRLE(self, block, x, y, width, height):
    method recv_DecodeZRLE_value (line 306) | def recv_DecodeZRLE_value(self, block, x, y, width, height):
    method recv_DecodeZlib (line 312) | def recv_DecodeZlib(self, block, x, y, width, height):
    method recv_DecodeZlib_value (line 319) | def recv_DecodeZlib_value(self, block, x, y, width, height):
    method recv_SetColorMapEntries (line 325) | def recv_SetColorMapEntries(self, block):
    method _handle_SetColorMapEntries (line 331) | def _handle_SetColorMapEntries(self, first_color, number_of_colors, co...
    method recv_SetColorMapEntries_color (line 338) | def recv_SetColorMapEntries_color(self, block, first_color, number_of_...
    method recv_ServerCutText (line 345) | def recv_ServerCutText(self, block):
    method recv_ServerCutText_value (line 350) | def recv_ServerCutText_value(self, block):
    method send_SetEncodings (line 355) | def send_SetEncodings(self, encodings):
    method send_PixelFormat (line 360) | def send_PixelFormat(self, bpp=32, depth=24, bigendian=0, truecolor=1,...
    method send_FramebufferUpdateRequest (line 370) | def send_FramebufferUpdateRequest(self, x=0, y=0, width=None, height=N...
    method send_KeyEvent (line 382) | def send_KeyEvent(self, key, down):
    method send_PointerEvent (line 389) | def send_PointerEvent(self, x, y, buttonmask=0):
    method send_ClientCutText (line 398) | def send_ClientCutText(self, message):
    method expect (line 404) | def expect(self, type, length, *args, **kwargs):
    method close (line 413) | def close(self):
    method _error (line 418) | def _error(self, e):
  function client_factory (line 427) | def client_factory(deferred, error_buffer):

FILE: universe/vncdriver/vnc_proxy_server.py
  class LogManager (line 15) | class LogManager(object):
    method __init__ (line 16) | def __init__(self, base_logfile_dir, recorder_id, id):
    method global_rewards_logfile (line 30) | def global_rewards_logfile(self):
    method global_botaction_logfile (line 38) | def global_botaction_logfile(self):
    method global_env_id_file (line 47) | def global_env_id_file(self):
    method server_logfile (line 55) | def server_logfile(self):
    method client_logfile (line 59) | def client_logfile(self):
    method close (line 62) | def close(self):
  class VNCProxyServer (line 92) | class VNCProxyServer(protocol.Protocol, object):
    method next_id (line 122) | def next_id(cls):
    method __init__ (line 127) | def __init__(self, action_queue=None, error_buffer=None, enable_loggin...
    method start_logging (line 150) | def start_logging(self):
    method connectionMade (line 160) | def connectionMade(self):
    method connectionLost (line 185) | def connectionLost(self, reason):
    method dataReceived (line 190) | def dataReceived(self, data):
    method sendData (line 198) | def sendData(self, data):
    method flush (line 205) | def flush(self):
    method handle (line 219) | def handle(self, type, block):
    method send_ProtocolVersion_Handshake (line 226) | def send_ProtocolVersion_Handshake(self):
    method recv_ProtocolVersion_Handshake (line 229) | def recv_ProtocolVersion_Handshake(self, block):
    method send_SecurityTypes (line 243) | def send_SecurityTypes(self):
    method recv_SecurityTypesResponse (line 247) | def recv_SecurityTypesResponse(self, block):
    method send_VNC_Authentication (line 252) | def send_VNC_Authentication(self):
    method recv_VNC_Authentication_response (line 260) | def recv_VNC_Authentication_response(self, block):
    method send_SecurityResult_Handshake_success (line 269) | def send_SecurityResult_Handshake_success(self):
    method send_SecurityResult_Handshake_failed (line 274) | def send_SecurityResult_Handshake_failed(self, reason):
    method recv_ClientInit (line 280) | def recv_ClientInit(self, block):
    method recv_ClientToServer (line 302) | def recv_ClientToServer(self, block):
    method recv_SetPixelFormat (line 325) | def recv_SetPixelFormat(self, block):
    method recv_SetEncodings (line 336) | def recv_SetEncodings(self, block):
    method _handle_SetEncodings (line 343) | def _handle_SetEncodings(self, number_of_encodings, encodings):
    method recv_SetEncodings_encoding_type (line 367) | def recv_SetEncodings_encoding_type(self, block, number_of_encodings, ...
    method recv_FramebufferUpdateRequest (line 375) | def recv_FramebufferUpdateRequest(self, block):
    method recv_KeyEvent (line 381) | def recv_KeyEvent(self, block):
    method recv_PointerEvent (line 389) | def recv_PointerEvent(self, block):
    method recv_ClientCutText (line 397) | def recv_ClientCutText(self, block):
    method recv_ClientCutText_value (line 403) | def recv_ClientCutText_value(self, block):
    method expect (line 408) | def expect(self, type, length, *args, **kwargs):
    method proxyData (line 414) | def proxyData(self, data):
    method recvProxyData (line 418) | def recvProxyData(self, data):
    method close (line 425) | def close(self):
    method _error (line 435) | def _error(self, e):
  class VNCProxyClient (line 442) | class VNCProxyClient(protocol.Protocol, object):
    method __init__ (line 443) | def __init__(self):
    method start_logging (line 459) | def start_logging(self):
    method connectionMade (line 466) | def connectionMade(self):
    method connectionLost (line 471) | def connectionLost(self, reason):
    method proxyData (line 476) | def proxyData(self, data):
    method recvProxyData (line 481) | def recvProxyData(self, data):
    method sendData (line 485) | def sendData(self, data):
    method dataReceived (line 494) | def dataReceived(self, data):
    method flush (line 507) | def flush(self):
    method handle (line 525) | def handle(self, type, block):
    method recv_ProtocolVersion_Handshake (line 532) | def recv_ProtocolVersion_Handshake(self, block):
    method recv_Security_Handshake (line 541) | def recv_Security_Handshake(self, block):
    method recv_VNC_Authentication (line 552) | def recv_VNC_Authentication(self, block):
    method recv_SecurityResult_Handshake (line 557) | def recv_SecurityResult_Handshake(self, block):
    method recv_SecurityResult_Handshake_failed_length (line 569) | def recv_SecurityResult_Handshake_failed_length(self, block):
    method recv_SecurityResult_Handshake_failed_reason (line 573) | def recv_SecurityResult_Handshake_failed_reason(self, block):
    method send_ClientInit (line 576) | def send_ClientInit(self):
    method expect (line 596) | def expect(self, type, length, *args, **kwargs):
    method close (line 606) | def close(self):
    method _error (line 614) | def _error(self, e):
    method send_SetEncodings (line 619) | def send_SetEncodings(self, encodings):

FILE: universe/vncdriver/vnc_session.py
  class VNCSession (line 11) | class VNCSession(object):
    method __init__ (line 12) | def __init__(self, remotes, error_buffer):
    method connect (line 18) | def connect(self):
    method _connect (line 21) | def _connect(self):
    method flip (line 52) | def flip(self):
    method peek (line 69) | def peek(self):
    method step (line 73) | def step(self, action):
    method _step (line 77) | def _step(self, action):
    method render (line 92) | def render(self):
    method close (line 98) | def close(self):
    method _close (line 101) | def _close(self):

FILE: universe/wrappers/__init__.py
  function wrap (line 21) | def wrap(env):
  function WrappedVNCEnv (line 24) | def WrappedVNCEnv():
  function WrappedGymCoreEnv (line 27) | def WrappedGymCoreEnv(gym_core_id, fps=None, rewarder_observation=False):
  function WrappedGymCoreSyncEnv (line 35) | def WrappedGymCoreSyncEnv(gym_core_id, fps=60, rewarder_observation=False):
  function WrappedFlashgamesEnv (line 45) | def WrappedFlashgamesEnv():
  function WrappedInternetEnv (line 49) | def WrappedInternetEnv(*args, **kwargs):
  function WrappedStarCraftEnv (line 52) | def WrappedStarCraftEnv(*args, **kwargs):
  function WrappedGTAVEnv (line 55) | def WrappedGTAVEnv(*args, **kwargs):
  function WrappedWorldOfGooEnv (line 58) | def WrappedWorldOfGooEnv(*args, **kwargs):

FILE: universe/wrappers/action_space.py
  class SoftmaxClickMouse (line 1) | class SoftmaxClickMouse():
    method init (line 2) | def init(self):
  class SafeActionSpace (line 6) | class SafeActionSpace():
    method init (line 7) | def init(self):

FILE: universe/wrappers/blocking_reset.py
  class BlockingReset (line 3) | class BlockingReset(vectorized.Wrapper):
    method __init__ (line 9) | def __init__(self, *args, **kwargs):
    method _reset (line 15) | def _reset(self):
    method _step (line 36) | def _step(self, action_n):

FILE: universe/wrappers/diagnostics.py
  class Diagnostics (line 8) | class Diagnostics(vectorized.Wrapper):
    method _step (line 10) | def _step(self, action_n):

FILE: universe/wrappers/experimental/action_space.py
  function slither_vnc (line 11) | def slither_vnc(space=False, left=False, right=False):
  function racing_vnc (line 16) | def racing_vnc(up=False, left=False, right=False):
  function platform_vnc (line 21) | def platform_vnc(up=False, left=False, right=False, space=False):
  class SafeActionSpace (line 28) | class SafeActionSpace(vectorized.Wrapper):
    method __init__ (line 38) | def __init__(self, env):
  class SoftmaxClickMouse (line 65) | class SoftmaxClickMouse(vectorized.ActionWrapper):
    method __init__ (line 72) | def __init__(self, env, active_region=(10, 75 + 50, 10 + 160, 75 + 210...
    method _action (line 94) | def _action(self, action_n):
    method _discrete_to_action (line 97) | def _discrete_to_action(self, i):
    method _reverse_action (line 105) | def _reverse_action(self, action):
    method _action_to_discrete (line 121) | def _action_to_discrete(self, event):
    method is_contained (line 135) | def is_contained(cls, point, coords):

FILE: universe/wrappers/experimental/observation.py
  function CropObservations (line 9) | def CropObservations(env):
  class _CropObservations (line 23) | class _CropObservations(vectorized.ObservationWrapper):
    method __init__ (line 24) | def __init__(self, env, height, width, x=0, y=0):
    method _observation (line 34) | def _observation(self, observation_n):
    method _crop_frame (line 37) | def _crop_frame(self, frame):

FILE: universe/wrappers/experimental/random_env.py
  class RandomEnv (line 6) | class RandomEnv(vectorized.Wrapper):
    method __init__ (line 13) | def __init__(self, env, env_ids):
    method configure (line 17) | def configure(self, **kwargs):
    method _reset (line 20) | def _reset(self):
    method _step (line 24) | def _step(self, action_n):

FILE: universe/wrappers/gym_core.py
  function atari_vnc (line 16) | def atari_vnc(up=False, down=False, left=False, right=False, z=False):
  function gym_core_action_space (line 23) | def gym_core_action_space(gym_core_id):
  class CropAtari (line 45) | class CropAtari(vectorized.ObservationWrapper):
    method __init__ (line 50) | def __init__(self, env):
    method _observation (line 54) | def _observation(self, observation_n):
  function one_hot (line 57) | def one_hot(indices, depth):
  class GymCoreAction (line 60) | class GymCoreAction(vectorized.ActionWrapper):
    method __init__ (line 61) | def __init__(self, env, gym_core_id=None):
    method _action (line 81) | def _action(self, action_n):
    method _reverse_action (line 86) | def _reverse_action(self, action_n):
  class GymCoreObservation (line 91) | class GymCoreObservation(vectorized.Wrapper):
    method __init__ (line 92) | def __init__(self, env, gym_core_id=None):
    method _reset (line 107) | def _reset(self):
    method _step (line 119) | def _step(self, action_n):
    method _observation (line 129) | def _observation(self, done_n, info):

FILE: universe/wrappers/gym_core_sync.py
  class GymCoreSync (line 7) | class GymCoreSync(vectorized.Wrapper):
    method __init__ (line 16) | def __init__(self, env):
    method _reset (line 25) | def _reset(self):
    method _step (line 36) | def _step(self, action_n):
    method _flip_past (line 71) | def _flip_past(self, observation_n, reward_n, done_n, info):

FILE: universe/wrappers/joint.py
  class Joint (line 4) | class Joint(vectorized.Wrapper):
    method __init__ (line 5) | def __init__(self, env_m):
    method n (line 20) | def n(self):
    method _close (line 23) | def _close(self):
    method _render (line 27) | def _render(self, mode='human', close=False):
    method _reset (line 30) | def _reset(self):
    method _step (line 43) | def _step(self, action_n):

FILE: universe/wrappers/logger.py
  function stats (line 14) | def stats(count):
  class Logger (line 25) | class Logger(vectorized.Wrapper):
    method __init__ (line 29) | def __init__(self, env, print_frequency=5):
    method configure (line 37) | def configure(self, **kwargs):
    method _clear_step_state (line 41) | def _clear_step_state(self):
    method _step (line 61) | def _step(self, action_n):

FILE: universe/wrappers/monitoring.py
  class _UniverseMonitor (line 9) | class _UniverseMonitor(core.Wrapper):
    method __init__ (line 10) | def __init__(self, env, directory, video_callable=None, force=False,
    method _start_monitor (line 24) | def _start_monitor(self):
    method _step (line 60) | def _step(self, action_n):
    method _reset (line 66) | def _reset(self):
    method _close (line 72) | def _close(self):
    method set_monitor_mode (line 76) | def set_monitor_mode(self, mode):
  function Monitor (line 80) | def Monitor(env, directory, video_callable=None, force=False, resume=False,

FILE: universe/wrappers/multiprocessing_env.py
  function WrappedMultiprocessingEnv (line 8) | def WrappedMultiprocessingEnv(env_id):
  class RemoveNones (line 11) | class RemoveNones(vectorized.Wrapper):
    method __init__ (line 18) | def __init__(self, env):
    method _reset (line 22) | def _reset(self):
    method _step (line 27) | def _step(self, action_n):
  class EpisodeID (line 32) | class EpisodeID(vectorized.Wrapper):
    method configure (line 40) | def configure(self, episode_limit=None, **kwargs):
    method _clear_state (line 45) | def _clear_state(self):
    method _set_done_to (line 50) | def _set_done_to(self):
    method _reset (line 59) | def _reset(self):
    method _step (line 63) | def _step(self, action_n):

FILE: universe/wrappers/recording.py
  class Recording (line 15) | class Recording(vectorized.Wrapper):
    method __init__ (line 33) | def __init__(self, env, recording_dir=None, recording_policy=None, rec...
    method _get_episode_id (line 72) | def _get_episode_id(self):
    method _get_writer (line 77) | def _get_writer(self, i):
    method _reset (line 90) | def _reset(self):
    method _step (line 108) | def _step(self, action_n):
    method _close (line 134) | def _close(self):
  class RecordingWriter (line 142) | class RecordingWriter(object):
    method __init__ (line 146) | def __init__(self, recording_dir, instance_id, channel_id, async_write...
    method close (line 159) | def close(self):
    method close_files (line 162) | def close_files(self):
    method json_encode (line 170) | def json_encode(self, obj):
    method writer_main (line 192) | def writer_main(self):
    method __call__ (line 200) | def __call__(self, **kwargs):
    method write_item (line 204) | def write_item(self, item):
  class RecordingAnnotator (line 210) | class RecordingAnnotator(object):
    method __init__ (line 211) | def __init__(self, writer, episode_id, step_id):
    method __call__ (line 215) | def __call__(self, **kwargs):

FILE: universe/wrappers/render.py
  class Render (line 8) | class Render(vectorized.Wrapper):
    method __init__ (line 12) | def __init__(self, *args, **kwargs):
    method configure (line 20) | def configure(self, **kwargs):
    method _reset (line 27) | def _reset(self):
    method _step (line 32) | def _step(self, action_n):
    method _render (line 37) | def _render(self, mode='human', *args, **kwargs):

FILE: universe/wrappers/tests/test_joint.py
  function test_joint (line 5) | def test_joint():

FILE: universe/wrappers/tests/test_time_limit.py
  function test_steps_limit_restart (line 26) | def test_steps_limit_restart():
  function test_steps_limit_restart_unused_when_not_wrapped (line 45) | def test_steps_limit_restart_unused_when_not_wrapped():
  function test_seconds_limit_restart (line 55) | def test_seconds_limit_restart():
  function test_default_time_limit (line 79) | def test_default_time_limit():

FILE: universe/wrappers/throttle.py
  class Throttle (line 7) | class Throttle(vectorized.Wrapper):
    method __init__ (line 21) | def __init__(self, env):
    method configure (line 26) | def configure(self, skip_metadata=False, fps='default', **kwargs):
    method _reset (line 35) | def _reset(self):
    method _step (line 46) | def _step(self, action_n):
    method _substep (line 128) | def _substep(self, action_n):
    method _start_timer (line 142) | def _start_timer(self):

FILE: universe/wrappers/time_limit.py
  class UniverseTimeLimit (line 11) | class UniverseTimeLimit(core.Wrapper):
    method __init__ (line 12) | def __init__(self, env):
    method _elapsed_seconds (line 24) | def _elapsed_seconds(self):
    method _past_limit (line 27) | def _past_limit(self):
    method _step (line 39) | def _step(self, action_n):
    method _reset (line 50) | def _reset(self):

FILE: universe/wrappers/timer.py
  class Timer (line 7) | class Timer(vectorized.Wrapper):
    method configure (line 13) | def configure(self, **kwargs):
    method _reset (line 16) | def _reset(self):
    method _step (line 20) | def _step(self, action_n):

FILE: universe/wrappers/vectorize.py
  class Vectorize (line 7) | class Vectorize(gym.Wrapper):
    method __init__ (line 16) | def __init__(self, env):
    method _reset (line 22) | def _reset(self):
    method _step (line 26) | def _step(self, action):
    method _seed (line 30) | def _seed(self, seed):
  class Unvectorize (line 33) | class Unvectorize(core.Wrapper):
    method _reset (line 40) | def _reset(self):
    method _step (line 45) | def _step(self, action):
    method _seed (line 50) | def _seed(self, seed):
  class WeakUnvectorize (line 53) | class WeakUnvectorize(Unvectorize):
    method __init__ (line 54) | def __init__(self, env, i):
    method _check_for_duplicate_wrappers (line 60) | def _check_for_duplicate_wrappers(self):
    method env (line 64) | def env(self):
    method env (line 75) | def env(self, value):
    method _seed (line 79) | def _seed(self, seed):
    method close (line 83) | def close(self):

FILE: universe/wrappers/vision.py
  class Vision (line 6) | class Vision(vectorized.Wrapper):
    method _reset (line 16) | def _reset(self):
    method _step (line 20) | def _step(self, action_n):