pistarlab package

Submodules

pistarlab.agent module

class pistarlab.agent.Agent(_calling_directly=True, spec_id=None, _id=None, config={}, meta={}, custom_seed=None)

Bases: pistarlab.entity.Entity

add_component(component: pistarlab.component.Component)
cleanup()
close()
static create(spec_id, config={}, custom_seed=None)
create_components()
create_from_snapshot()
flush_stats()
get_component_by_name(name)pistarlab.component.Component
get_components()List[pistarlab.component.Component]
get_config(run_config={})
get_config_key(key, default=None)
get_dbmodel()pistarlab.dbmodels.AgentModel
static get_dbmodel_by_id(id)pistarlab.dbmodels.AgentModel
get_default_config()
get_id()
get_last_checkpoint()
get_seed_as_int()
get_sessions()
static get_spec_dbmodel_by_id(id)pistarlab.dbmodels.AgentSpecModel
get_state()
get_task_runner_cls()
init_stat_logger(cols)
initialize()
list_checkpoints()
static load(id)
load_stats()
log_stat_dict(task_id, data)
save_state(state, meta)
save_stats()
update_config(config)
update_config_key(key, value)

pistarlab.api_schema module

class pistarlab.api_schema.Agent(*args, **kwargs)

Bases: graphene_sqlalchemy.types.SQLAlchemyObjectType

connection

alias of graphene.types.base.AgentConnection

ident = <graphene.types.scalars.String object>
recent_sessions = <graphene.types.structures.List object>
resolve_recent_sessions(info, limit=3)
status = <graphene.types.scalars.String object>
class pistarlab.api_schema.AgentFilter(*args, **kwargs)

Bases: graphene_sqlalchemy_filter.filters.FilterSet

archived = <graphene.types.scalars.Boolean object>
model

alias of pistarlab.dbmodels.AgentModel

class pistarlab.api_schema.AgentSetArchive(*args, **kwargs)

Bases: graphene.types.mutation.Mutation

class Arguments

Bases: object

archive = <graphene.types.scalars.Boolean object>
id = <graphene.types.scalars.String object>
static mutate(root, info, id, archive)
success = <graphene.types.scalars.Boolean object>
class pistarlab.api_schema.AgentSetConfig(*args, **kwargs)

Bases: graphene.types.mutation.Mutation

class Arguments

Bases: object

config = <graphene.types.scalars.String object>
id = <graphene.types.scalars.String object>
static mutate(root, info, id, config)
success = <graphene.types.scalars.Boolean object>
class pistarlab.api_schema.AgentSetNotes(*args, **kwargs)

Bases: graphene.types.mutation.Mutation

class Arguments

Bases: object

id = <graphene.types.scalars.String object>
notes = <graphene.types.scalars.String object>
static mutate(root, info, id, notes)
success = <graphene.types.scalars.Boolean object>
class pistarlab.api_schema.AgentSpec(*args, **kwargs)

Bases: graphene_sqlalchemy.types.SQLAlchemyObjectType

connection

alias of graphene.types.base.AgentSpecConnection

ident = <graphene.types.scalars.String object>
class pistarlab.api_schema.AgentTag(*args, **kwargs)

Bases: graphene_sqlalchemy.types.SQLAlchemyObjectType

connection

alias of graphene.types.base.AgentTagConnection

ident = <graphene.types.scalars.String object>
class pistarlab.api_schema.Component(*args, **kwargs)

Bases: graphene_sqlalchemy.types.SQLAlchemyObjectType

connection

alias of graphene.types.base.ComponentConnection

ident = <graphene.types.scalars.String object>
class pistarlab.api_schema.ComponentSpec(*args, **kwargs)

Bases: graphene_sqlalchemy.types.SQLAlchemyObjectType

connection

alias of graphene.types.base.ComponentSpecConnection

ident = <graphene.types.scalars.String object>
class pistarlab.api_schema.EnvSpec(*args, **kwargs)

Bases: graphene_sqlalchemy.types.SQLAlchemyObjectType

connection

alias of graphene.types.base.EnvSpecConnection

ident = <graphene.types.scalars.String object>
class pistarlab.api_schema.EnvWrapper(*args, **kwargs)

Bases: graphene.types.objecttype.ObjectType

entry_point = <graphene.types.scalars.String object>
kwargs = <graphene.types.json.JSONString object>
class pistarlab.api_schema.Environment(*args, **kwargs)

Bases: graphene_sqlalchemy.types.SQLAlchemyObjectType

connection

alias of graphene.types.base.EnvironmentConnection

ident = <graphene.types.scalars.String object>
resolve_specs(info)
specs = <graphene.types.structures.List object>
class pistarlab.api_schema.Mutations(*args, **kwargs)

Bases: graphene.types.objecttype.ObjectType

agent_set_archive = <graphene.types.field.Field object>
agent_set_config = <graphene.types.field.Field object>
agent_set_notes = <graphene.types.field.Field object>
session_set_archive = <graphene.types.field.Field object>
class pistarlab.api_schema.Query(*args, **kwargs)

Bases: graphene.types.objecttype.ObjectType

agent = <graphene.types.field.Field object>
agent_spec = <graphene.types.field.Field object>
agent_specs = <graphene.types.structures.List object>
agent_tags = <graphene.types.structures.List object>
agents = <graphene.types.structures.List object>
all_agent_tags = <graphene_sqlalchemy.fields.SQLAlchemyConnectionField object>
all_agents = <graphene_sqlalchemy_filter.connection_field.FilterableConnectionField object>
all_component_specs = <graphene_sqlalchemy.fields.SQLAlchemyConnectionField object>
all_environments = <graphene_sqlalchemy.fields.SQLAlchemyConnectionField object>
all_sessions = <graphene_sqlalchemy_filter.connection_field.FilterableConnectionField object>
all_task = <graphene_sqlalchemy.fields.SQLAlchemyConnectionField object>
best_sessions_for_env_spec = <graphene.types.structures.List object>
component_spec = <graphene.types.field.Field object>
env_spec = <graphene.types.field.Field object>
env_specs = <graphene.types.structures.List object>
env_wrappers = <graphene.types.structures.List object>
node = <graphene.relay.node.NodeField object>
recent_agents = <graphene.types.structures.List object>
static resolve_agent(parent, info, ident)
static resolve_agent_spec(parent, info, ident)
static resolve_agent_specs(parent, info, disabled=None)
static resolve_agent_tags(parent, info)
static resolve_agents(parent, info)
static resolve_best_sessions_for_env_spec(parent, info, env_spec_id, stat_name)
static resolve_component_spec(parent, info, ident)
static resolve_env_spec(parent, info, ident)
static resolve_env_specs(parent, info, disabled=None)
static resolve_env_wrappers(parent, info, **kwargs)
static resolve_recent_agents(parent, info, limit=8)
static resolve_session(parent, info, ident)
static resolve_session_list(parent, info, idents)
static resolve_sessions(parent, info)
static resolve_task(parent, info, ident)
static resolve_task_spec(parent, info, ident)
static resolve_task_specs(parent, info, disabled=None)
static resolve_tasks(parent, info)
session = <graphene.types.field.Field object>
session_list = <graphene.types.structures.List object>
sessions = <graphene.types.structures.List object>
task = <graphene.types.field.Field object>
task_spec = <graphene.types.field.Field object>
task_specs = <graphene.types.structures.List object>
tasks = <graphene.types.structures.List object>
class pistarlab.api_schema.Session(*args, **kwargs)

Bases: graphene_sqlalchemy.types.SQLAlchemyObjectType

connection

alias of graphene.types.base.SessionConnection

created_timestamp = <graphene.types.scalars.Float object>
ident = <graphene.types.scalars.String object>
resolve_created_timestamp(info)
resolve_summary(info, **args)
summary = <graphene.types.generic.GenericScalar object>
summary_raw = <graphene.types.json.JSONString object>
class pistarlab.api_schema.SessionFilter(*args, **kwargs)

Bases: graphene_sqlalchemy_filter.filters.FilterSet

archived = <graphene.types.scalars.Boolean object>
model

alias of pistarlab.dbmodels.SessionModel

class pistarlab.api_schema.SessionSetArchive(*args, **kwargs)

Bases: graphene.types.mutation.Mutation

class Arguments

Bases: object

archive = <graphene.types.scalars.Boolean object>
id = <graphene.types.scalars.String object>
static mutate(root, info, id, archive)
success = <graphene.types.scalars.Boolean object>
class pistarlab.api_schema.Task(*args, **kwargs)

Bases: graphene_sqlalchemy.types.SQLAlchemyObjectType

connection

alias of graphene.types.base.TaskConnection

ident = <graphene.types.scalars.String object>
parent_task = <graphene.types.field.Field object>
resolve_parent_task(info)
class pistarlab.api_schema.TaskSpec(*args, **kwargs)

Bases: graphene_sqlalchemy.types.SQLAlchemyObjectType

connection

alias of graphene.types.base.TaskSpecConnection

ident = <graphene.types.scalars.String object>
pistarlab.api_schema.updateRLSummaryWithDetails(summary)

pistarlab.app_backend module

class pistarlab.app_backend.CustomGraphQLView(**kwargs)

Bases: flask_graphql.graphqlview.GraphQLView

get_context()
pistarlab.app_backend.after_request(response)
pistarlab.app_backend.api_admin_data()
pistarlab.app_backend.api_agent_modify_tag(action, agent_id, tag)
pistarlab.app_backend.api_agent_plots_json(uid)
pistarlab.app_backend.api_browser(urlFilePath='')
pistarlab.app_backend.api_config()
pistarlab.app_backend.api_download(urlFilePath='')
pistarlab.app_backend.api_env_preview_image(image_name)
pistarlab.app_backend.api_new_agent_submit()
pistarlab.app_backend.api_new_task_submit()
pistarlab.app_backend.api_plugin_action(action_name, plugin_id, plugin_version)
pistarlab.app_backend.api_plugin_create()
pistarlab.app_backend.api_plugins_list()
pistarlab.app_backend.api_prep_notebook()

Create a notebook for a given task

pistarlab.app_backend.api_reload_default_data()
pistarlab.app_backend.api_session_episode_by_id(sid, episode_id)
pistarlab.app_backend.api_session_episodes(sid)
pistarlab.app_backend.api_session_max_episode_recorded(sid)
pistarlab.app_backend.api_session_plotly_json(sid, data_group, data_name, step_field)
pistarlab.app_backend.api_session_plots_json(sid, data_group, data_name, step_field)
pistarlab.app_backend.api_snapshot_publish()
pistarlab.app_backend.api_snapshots_list(spec_id=None)
pistarlab.app_backend.api_snapshots_list_for_agent_id(seed)
pistarlab.app_backend.api_submit_agent_task()
pistarlab.app_backend.api_task_admin(command, uid)
pistarlab.app_backend.api_workspace_info()
pistarlab.app_backend.bin_data(data, bins=[(50, 10), (200, 20), (500, 50), (1000, 100), (10000, 1000), (50000, 2000), (100000, 10000), (1000000, 50000), (2000000, 100000)])
pistarlab.app_backend.chunk_list_simple(data, chunk_max=10)

if more than one value in range for a given chunk, returns both max and min TODO: consider making other options available, eg: mean, mean + range, mean + variance

pistarlab.app_backend.get_chunk(full_path, byte1=None, byte2=None)
pistarlab.app_backend.index()
pistarlab.app_backend.main()
pistarlab.app_backend.not_in_readonly_mode(fn)
pistarlab.app_backend.request_teardown(exception=None)
pistarlab.app_backend.servce_static(path)
pistarlab.app_backend.session_episode_mp4(sid, eid)
pistarlab.app_backend.set_log_level(level)
pistarlab.app_backend.sizeof_fmt(num, suffix='B')
pistarlab.app_backend.stream_entity_logs(entity, id)
pistarlab.app_backend.stream_events()
pistarlab.app_backend.stream_scoped_logs(scope_name)
pistarlab.app_backend.tryparse(x, type_, default)

pistarlab.common module

class pistarlab.common.MAEnv

Bases: object

abstract render(mode, player_id=None, *args, **kwargs)
abstract reset()
abstract stats(player_id=None, *args, **kwargs)
abstract step(action)

pistarlab.component module

class pistarlab.component.Component(name=None, spec_id=None, _id=None, config={}, agent_id=None)

Bases: pistarlab.entity.Entity

get_agent_id()
get_child_component_ids()
get_component_class()
get_config()
get_dbmodel()pistarlab.dbmodels.ComponentModel
static get_dbmodel_by_id(id)pistarlab.dbmodels.ComponentModel
get_id()
get_last_checkpoint()
get_name()
get_spec()
static get_spec_dbmodel_by_id(id)pistarlab.dbmodels.ComponentSpecModel
get_spec_id()
get_state()
get_type()
save_state(state, meta)
set_agent(agent_id)

pistarlab.config module

class pistarlab.config.SysConfig(root_path, data_path, workspace_path, log_root, log_level, db_type, db_config, redis_hostname, redis_port, redis_password, execution_context_config, enable_cluster, streamer_uri=None, read_only_mode=False)

Bases: object

pistarlab.config.get_ip()
pistarlab.config.get_root_path()
pistarlab.config.get_sys_config(root_path=None)

pistarlab.core module

class pistarlab.core.SysContext

Bases: object

add_agent_tag(agent_id, tag_id)
static check_tensorflow_status()
static check_torch_status()
close()
connect(force=False, execution_context_config=None)
create_agent_snapshot(entity_id, submitter_id='default', snapshot_description='', snapshot_version='0')
create_new_plugin(plugin_id, plugin_name, description='')
disable_plugin_by_id(plugin_id)
execute_graphql(query, variables={})
get_agent_dbmodel(id)pistarlab.dbmodels.AgentModel
get_agent_spec(id)pistarlab.dbmodels.AgentSpecModel
get_best_sessions_in_for_env_spec(env_spec_id, summary_stat_name)
get_component_spec(id)pistarlab.dbmodels.ComponentSpecModel
get_data_context()pistarlab.data_context.DataContext
get_dbsession()sqlalchemy.orm.session.Session
get_entity_logger(entity_type, uid, level=20, sub_id='default')
get_entity_status(model_class, id)
get_env_spec(id)pistarlab.dbmodels.EnvSpecModel
get_execution_context()pistarlab.execution_context.ExecutionContext
static get_gpu_info()
get_logger()
get_next_id(entity_type)
get_next_seed()
get_plugin(id, version)
get_redis_client()redis.client.Redis
get_scopped_logger(scope_name, level=20)
get_session(id)pistarlab.dbmodels.SessionModel
get_snapshot_index()
get_store()pistarlab.storage.Storage
get_task_spec(id)pistarlab.dbmodels.EnvSpecModel
get_user_id(token)
initialize(force=False, execution_context_config=None)

Initializes pistarlab. Should only be on run by primary instance to avoid race

install_plugin(id, plugin_version)
install_plugin_from_manifest(plugin_id, plugin_version)
list_agent_specs()List[str]
list_agents()List[str]
list_component_specs()List[str]
list_env_specs()List[str]
list_plugins(status_filter=None)
list_sessions()List[str]
list_task_specs()List[str]
list_tasks()List[Any]
list_tasks_detailed()List[str]
make_env(spec_id)
modify_entity_status(model_class, id, state, msg='')
register_agent_spec(spec_id, runner_entry_point, entry_point=None, config={}, params={}, disabled=False, displayed_name=None, plugin_id=None, plugin_version='0.0.1-dev', version='0.0.1-dev', description=None)
register_agent_spec_from_classes(runner_cls, cls=None, *args, **kwargs)
register_component_spec(spec_id, entry_point, parent_class_entry_point, config={}, params={}, displayed_name=None, plugin_id=None, plugin_version='0.0.1-dev', version='0.0.1-dev', category=None, disabled=False, description=None, metadata={})
register_env_spec(spec_id, entry_point=None, env_type='RL_SINGLEPLAYER_ENV', tags=[], categories=[], displayed_name=None, environment_displayed_name=None, plugin_id=None, plugin_version='0.0.1-dev', version='0.0.1-dev', environment_id=None, description=None, config=None, params={}, metadata=None, disabled=False)
register_env_spec_from_class(spec_id, env_class, *args, **kwargs)
register_environment(environment_id, default_entry_point=None, default_config=None, default_metadata=None, displayed_name=None, categories=[], plugin_id=None, plugin_version='0.0.1-dev', version='0.0.1-dev', description=None, disabled=False)
register_task_spec(spec_id, entry_point, runner_entry_point, config={}, params={}, displayed_name=None, plugin_id=None, plugin_version='0.0.1-dev', version='0.0.1-dev', type_name=None, disabled=False, description=None, metadata={})
register_task_spec_from_class(klass)
remove_agent_tag(agent_id, tag_id)
set_default_logger(logger)
static tf_reset_graph()
uninstall_plugin(id)
update_snapshot_index(force=False)
pistarlab.core.get_entry_point_from_class(cls)
pistarlab.core.get_task_spec_from_class(cls)

pistarlab.data_context module

class pistarlab.data_context.DataContext(config: pistarlab.config.SysConfig)

Bases: object

cleanup()
close()
get_dbengine(reset=False)
get_dbsession()sqlalchemy.orm.session.Session
get_redis_client()
get_store()pistarlab.storage.Storage
get_user_id(token)
init_db(force=False)
reset_all_data()
pistarlab.data_context.json_data_serializer(d)

pistarlab.databuffer module

class pistarlab.databuffer.DataBuffer(cols, size)

Bases: object

Databuffer with rollover

add(values: Tuple)
add_dict(dict_data)
clear()
get(key, limit=None, limit_from_tail=False)
get_dict(cols=None, limit=None, limit_from_tail=False)
is_full()
mean(key, limit=None, limit_from_tail=False)
sum(key, limit=None, limit_from_tail=False)

pistarlab.dbinit module

pistarlab.dbinit.add_wrapper_components(sess: sqlalchemy.orm.session.Session)
pistarlab.dbinit.load_default_data()

pistarlab.dbmodels module

class pistarlab.dbmodels.AgentModel(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

archived
components
config
created
displayed_name
id
last_checkpoint
meta
name
notes
seed
sessions
spec: pistarlab.dbmodels.AgentSpecModel
spec_id
stats
tags
pistarlab.dbmodels.AgentSpec

alias of pistarlab.dbmodels.AgentSpecModel

class pistarlab.dbmodels.AgentSpecModel(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

agents
config
created
description
disabled
displayed_name
entry_point
id
meta
params
plugin_id
plugin_version
runner_entry_point
version
class pistarlab.dbmodels.AgentTagModel(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

agent
agent_id
tag_id
class pistarlab.dbmodels.AlchemyEncoder(*, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)

Bases: json.encoder.JSONEncoder

default(obj)

Implement this method in a subclass such that it returns a serializable object for o, or calls the base implementation (to raise a TypeError).

For example, to support arbitrary iterators, you could implement default like this:

def default(self, o):
    try:
        iterable = iter(o)
    except TypeError:
        pass
    else:
        return list(iterable)
    # Let the base class default method raise the TypeError
    return JSONEncoder.default(self, o)
class pistarlab.dbmodels.ComponentModel(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

agent
agent_id
archived
child_components
config
created
id
meta
name
parent_component
parent_component_id
spec
spec_id
version
class pistarlab.dbmodels.ComponentSpecModel(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

category
components
config
created
description
disabled
displayed_name
entry_point
id
meta
params
parent_class_entry_point
plugin_id
plugin_version
version
pistarlab.dbmodels.EnvSpec

alias of pistarlab.dbmodels.EnvSpecModel

class pistarlab.dbmodels.EnvSpecModel(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

config
created
description
displayed_name
entry_point
env_type
environment
environment_id
id
meta
params
sessions
tags
user_defined
class pistarlab.dbmodels.EnvironmentModel(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

categories
created
default_config
default_entry_point
default_meta
description
disabled
displayed_name
env_specs
id
plugin_id
plugin_version
version
class pistarlab.dbmodels.SessionModel(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

agent
agent_id
agent_run_config
archived
child_sessions
comments
config
created
env_spec
env_spec_config
env_spec_id
env_spec_version
id
label
linked_tasks
parent_session
parent_session_id
run_info
session_type
status
status_msg
status_timestamp
summary
task
task_id
class pistarlab.dbmodels.SystemCounter(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

id
value
class pistarlab.dbmodels.TaskModel(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

actor_uid
archived
child_tasks
config
created
displayed_name
id
meta
name
notes
parent_task
parent_task_id
primary_session
primary_session_id
sessions
spec
spec_id
status
status_msg
status_timestamp
summary
type_code
pistarlab.dbmodels.TaskSpec

alias of pistarlab.dbmodels.TaskSpecModel

class pistarlab.dbmodels.TaskSpecModel(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

config
created
description
disabled
displayed_name
entry_point
id
meta
params
plugin_id
plugin_version
runner_entry_point
tasks
type_name
version

pistarlab.entity module

class pistarlab.entity.Entity(_id: Optional[str] = None, entity_type=None)

Bases: object

get_config()
abstract get_dbmodel()Any
get_entity_type()
get_id()str
store_data(name, data)

pistarlab.env_base module

class pistarlab.env_base.DataEnvironment

Bases: object

close()
evaluate(expected, predicted)
get_data_filepath()str
get_data_loader()collections.abc.Iterable
get_eval_filepath()str
get_eval_loader()collections.abc.Iterable
render_inputs(inputs)
render_outputs(output)
submit_predictions(outputs, predictions)

pistarlab.execution_context module

class pistarlab.execution_context.ExecutionContext(kwargs, auto_start=False)

Bases: object

as_actor(clss)
get(task)
get_actor_by_uid(uid)
get_actor_state(actor)int
get_actor_state_by_uid(uid)
stop_actor(actor)
stop_actor_by_uid(uid)
class pistarlab.execution_context.RunFuture(task, callback)

Bases: object

get()

pistarlab.filestore module

class pistarlab.filestore.FileStore(root_path, overwrite=False, json_encoder=<class 'pistarlab.filestore.JSONEncoderDefault'>, json_decoder=<class 'pistarlab.filestore.JSONDecoderDefault'>, read_only=False, use_write_thread=True, use_pool_executor=False, check_file_last_updated=True)

Bases: object

Threaded filestorage class

append_to_list(key, value, name='data', stype='json', clear_cache=False, flush=True)
append_to_multipart_dict(key, value: Any, name='data', stype='json', chunksize=500, col_names=None)
append_to_multipart_list(key, value: Any, name='data', stype='json', chunksize=5000)
check_path(path)
clean_futures()
close()
delayed_write(key, name, value, stype)
delayed_write_by_path(value, path)
delete(key, name='data', stype=None)
exists(key, name='data', stype=None)
extend_multipart_dict(key, value: Any, name='data', stype='json', chunksize=500, col_names=None)
flush_all()
get(key, name='data', stype=None, refresh=False)
get_multipart_dict(key, name='data', start_idx=0, end_idx=None)
get_multipart_list(key, name='data', start_idx=0, end_idx=None)
get_path_from_key(key)
list(key, use_cache=False)
list_keys_stream(key, use_cache=False)
list_objects(key)
list_objects_with_name(key, name)
list_objects_with_name_stream(key, name)
prepvalue(value)
remove_items_from_dict(key, items, name='data', stype='json', clear_cache=False)
save(key, value, name='data', stype='json', clear_cache=False, last_updated=None, flush=True)
update_dict(key, value, name='data', stype='json', clear_cache=False)
class pistarlab.filestore.JSONDecoderDefault(*args, **kwargs)

Bases: simplejson.decoder.JSONDecoder

object_hook(obj)
class pistarlab.filestore.JSONEncoderDefault(skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, encoding='utf-8', default=None, use_decimal=True, namedtuple_as_object=True, tuple_as_array=True, bigint_as_string=False, item_sort_key=None, for_json=False, ignore_nan=False, int_as_string_bitcount=None, iterable_as_array=False)

Bases: simplejson.encoder.JSONEncoder

default(obj)

Implement this method in a subclass such that it returns a serializable object for o, or calls the base implementation (to raise a TypeError).

For example, to support arbitrary iterators, you could implement default like this:

def default(self, o):
    try:
        iterable = iter(o)
    except TypeError:
        pass
    else:
        return list(iterable)
    return JSONEncoder.default(self, o)
pistarlab.filestore.format_key(key)
pistarlab.filestore.get_filetype(filepath_prefix)
pistarlab.filestore.path_to_key_name_stype(root_path, full_file_path, sep='/')

pistarlab.launcher module

pistarlab.launcher.api_admin(cmd, name)
pistarlab.launcher.api_status()
pistarlab.launcher.get_page(service_info, auto_restart_info)
pistarlab.launcher.get_status_page()
pistarlab.launcher.index()
pistarlab.launcher.main()
pistarlab.launcher.reset_all_data()
pistarlab.launcher.service_logs(name)
pistarlab.launcher.service_restart(name)
pistarlab.launcher.service_retart_all()
pistarlab.launcher.service_start(name)
pistarlab.launcher.service_stop(name)
pistarlab.launcher.service_stop_all()
pistarlab.launcher.service_toggle_auto_restart()

pistarlab.meta module

pistarlab.plugin_manager module

class pistarlab.plugin_manager.PluginManager(proj_module_name, workspace_path, data_path, logger=None)

Bases: object

Naming Requirements:
  • plugin package name = plugin_id

  • plugin plugin name = plugin_id with hyphans replaced with underscores

  • builtin plugin repo is under pistarlab/plugins

cleanup()
finish_installing_new_plugins()
get_all_plugins()
get_builtin_plugin_src_path()
get_installed_plugins()
get_plugin(plugin_id, plugin_version)
get_plugins_by_id(plugin_id)
get_plugins_from_sources()
get_sources()
install_plugin(plugin_id, plugin_version)
load_plugins()
plugin_id_to_module_name(plugin_id)
reload_plugin_by_id(plugin_id)
remove_plugin_by_id(plugin_id)
uninstall_plugin(plugin_id)
update_plugin_status(plugin, state, msg='')
pistarlab.plugin_manager.add_workspace_pkgs_to_path(path)
pistarlab.plugin_manager.create_file_from_template(template_path, target_path, var_dict)
pistarlab.plugin_manager.create_new_plugin(workspace_path, author, plugin_id, plugin_name, description='', author_email='', version='0.0.1-dev')
pistarlab.plugin_manager.get_default_config_dir(proj_module_name)
pistarlab.plugin_manager.get_home()
pistarlab.plugin_manager.get_plugin_key(plugin_id, plugin_version)
pistarlab.plugin_manager.get_plugin_key_from_plugin(plugin)
pistarlab.plugin_manager.load_plugins_from_path(path)
pistarlab.plugin_manager.open_json_file(path)
pistarlab.plugin_manager.save_to_json_file(data, path)

pistarlab.plugin_tools module

pistarlab.plugin_tools.create_manifest_files(path)
pistarlab.plugin_tools.get_plugin_package_name_from_path(path)
pistarlab.plugin_tools.main()

pistarlab.remote_conn module

exception pistarlab.remote_conn.AbortRequestedException

Bases: Exception

class pistarlab.remote_conn.ClientConn(task_id, client_id, timeout=5000, timeout_abort_check_callback=<function ClientConn.<lambda>>)

Bases: object

close()
get()
get_conn_info()
put(value)
class pistarlab.remote_conn.ServerConn(task_id, client_ids, timeout=5000, timeout_abort_check_callback=<function ServerConn.<lambda>>)

Bases: object

close()
get()
get_all()
publish_conn()
put(key, value)

pistarlab.remote_env module

class pistarlab.remote_env.RemoteMultiAgentEnvClient(task_id, session_id, agent_id, observation_spaces, action_spaces, timeout_abort_check_callback)

Bases: object

close()
render(*args, **kwargs)
reset()
stats(*args, **kwargs)
step(action_dict)
step_action(action_dict)
step_get_observation()
class pistarlab.remote_env.RemoteMultiAgentEnvServer(session: pistarlab.session.RLSession, player_to_agent_map={}, timeout_abort_check_callback=<function RemoteMultiAgentEnvServer.<lambda>>, env=None, *args, **kwargs)

Bases: object

close()
get_actions()

sends observations and waits for actions

get_spec_env_dbmodel()pistarlab.dbmodels.EnvSpecModel
get_summary()
process_message_from_client(result, actions, incoming_agent_msgs)
reset()
run_step()
class pistarlab.remote_env.RemoteSingleAgentEnvClient(*args, **kwargs)

Bases: pistarlab.remote_env.RemoteMultiAgentEnvClient, gym.core.Env

reset()

Resets the environment to an initial state and returns an initial observation.

Note that this function should not reset the environment’s random number generator(s); random variables in the environment’s state should be sampled independently between multiple calls to reset(). In other words, each call of reset() should yield an environment suitable for a new episode, independent of previous episodes.

Returns

the initial observation.

Return type

observation (object)

step(action)

Run one timestep of the environment’s dynamics. When end of episode is reached, you are responsible for calling reset() to reset this environment’s state.

Accepts an action and returns a tuple (observation, reward, done, info).

Parameters

action (object) – an action provided by the agent

Returns

agent’s observation of the current environment reward (float) : amount of reward returned after previous action done (bool): whether the episode has ended, in which case further step() calls will return undefined results info (dict): contains auxiliary diagnostic information (helpful for debugging, and sometimes learning)

Return type

observation (object)

pistarlab.services module

class pistarlab.services.ForegroundService(name, launch_args, log_root, ready_string='is READY', pkill_string=None, stdin_pipe=None, links={}, env={}, log_stdout=True)

Bases: pistarlab.services.SystemServiceBase

close()
get_info()
get_log()
get_pid()
get_state()
is_running()
kill_all()
restart(block=True)
start(block=True)
stop(block=True)
class pistarlab.services.RayService(log_root, address, redis_port=6379, redis_password='5241590000000000', additional_args={}, dashboard_port=8265, links={})

Bases: pistarlab.services.SystemServiceBase

close()
get_info()
get_log()
get_state()
is_running()
kill_all()
restart(block=True)
start(block=True)
stop(block=True)
class pistarlab.services.ReaderThread(proc, msg_queue, ready_string, log_path, log_stdout=True)

Bases: threading.Thread

run()

Method representing the thread’s activity.

You may override this method in a subclass. The standard run() method invokes the callable object passed to the object’s constructor as the target argument, if any, with sequential and keyword arguments taken from the args and kwargs arguments, respectively.

class pistarlab.services.ServiceContext

Bases: object

clean_up()
disable_auto_restart()
get_auto_restart_info()
get_service(name)
get_service_info()
get_service_instance(name)
prep_services(service_list)
restart_all()
set_commandline_args(args)
start_all()
start_service_monitor_thread()
toggle_auto_restart()
class pistarlab.services.SystemServiceBase(name, log_root)

Bases: object

close()
get_info()
get_log()
get_state()
restart(block=True)
start(block=True)
stop(block=True)
class pistarlab.services.XVFB(log_root)

Bases: pistarlab.services.SystemServiceBase

close()
get_info()
get_log()
get_state()
kill_all()
restart(block=True)
start(block=True)
stop(block=True)
pistarlab.services.get_home()

pistarlab.session module

class pistarlab.session.DataSession(config: Optional[pistarlab.session_config.DataSessionConfig] = None, *args, **kwargs)

Bases: pistarlab.session.Session

close(state=None)
get_run_info()
get_summary()
is_complete()
log_data_metrics(metrics)
log_evaluation_metrics(metrics)
log_predictions(name, inputs, outputs, predictions, metrics)
class pistarlab.session.RLSession(session_type, config: Optional[pistarlab.session_config.RLSessionConfig] = None, run_meta={}, env_run_meta={}, render_fn=None, persists_at_creation=False, *args, **kwargs)

Bases: pistarlab.session.Session

after_reset(observation)
after_step(observation, reward, done, info, action)
before_reset()
before_step(action)
close(state=None)
get_run_info()
get_summary()
is_complete()
is_episode_recorded()
render_frame()
render_stats()
run_command_check()
set_render_fn(render_fn)
class pistarlab.session.Session(env_spec_id, env_kwargs={}, config: Optional[pistarlab.session_config.SessionConfig] = None, agent_id=None, agent_run_config={}, task_id=None, session_type=None, parent_session_id=None)

Bases: pistarlab.entity.Entity

add_child_session_by_id(session_id)
change_status(state, msg='')
static change_status_by_id(id, state, msg='')
close(state)
get_dbmodel()pistarlab.dbmodels.SessionModel
static get_dbmodel_by_id(id)pistarlab.dbmodels.SessionModel
get_logger()
static get_logs_by_id(session_id, name)
abstract get_run_info()
get_spec_dbmodel()pistarlab.dbmodels.EnvSpecModel
get_status()
abstract get_summary()
static get_summary_by_id(session_id)
abstract is_complete()
save_run_info()
save_summary()
set_as_primary_session_for_task_by_id(task_id)
set_parent_session_by_id(session_id)

pistarlab.session_config module

class pistarlab.session_config.DataSessionConfig(batch_size=50, batch_log_freq=100, max_epochs=None, max_batches=None, wrappers=[], tmp_session=False)

Bases: pistarlab.session_config.SessionConfig

class pistarlab.session_config.RLSessionConfig(max_episodes=None, max_steps=None, max_steps_in_episode=None, episode_record_freq=1000, episode_record_preview_interval=1, step_log_freq=100, episode_log_freq=1, preview_rendering=True, frame_stream_enabled=False, wrappers=[], meta={}, tmp_session=False)

Bases: pistarlab.session_config.SessionConfig

class pistarlab.session_config.SessionConfig(tmp_session=False)

Bases: object

get_dict()Dict[str, Any]

pistarlab.session_env module

class pistarlab.session_env.BatchedEnv(env_entry_point, env_kwargs, batch_size=1, wrappers=[])

Bases: object

auto_reset()
close()
render(player_id, *args, **kwargs)
reset()
step(action_dict)
class pistarlab.session_env.DataSessionEnv(task_id=None, agent_id=None, agent_run_config=None, env_spec_id=None, env_kwargs={}, run_meta={}, config: Optional[pistarlab.session_config.DataSessionConfig] = None)

Bases: object

close()
evaluate(expected, predictions)
get_data_loader()
get_eval_loader()
get_logger()
get_sess_config()pistarlab.session_config.DataSessionConfig
get_spec_env_dbmodel()pistarlab.dbmodels.EnvSpecModel
get_task()pistarlab.task.Task
is_complete()
log_evaluation_metrics(**metrics)
log_metrics(**metrics)
submit_predictions(name, outputs, predictions, **metrics)
class pistarlab.session_env.IterableMonitor(name, iterable: collections.abc.Iterable)

Bases: object

class pistarlab.session_env.RLMultiSessionEnv(agent_id=None, agent_run_config={}, use_remote_client=False, auto_reset=False, batch_size=1, run_meta={}, child_session_configs={}, timeout_abort_check_callback=<function RLMultiSessionEnv.<lambda>>, *args, **kwargs)

Bases: pistarlab.session_env.RLSessionEnvBase

TODO: This class serves too many purposes and the logic gets complicated. Consider switching to Factory for building objects that share an interface TODO: Consider adding Non-Logging Remote Session for consistancy TODO: FIX limitation by introducing batched multiplayer interface

Options: NonBatched/Batched, Single/Multiplayer

close()
get_child_session_player_ids()
get_child_summary_list()
is_complete()
new_child_session(player_id)
render(*args, **kwargs)
reset()
step(action_dict)Tuple[Dict[str, Any], Dict[str, Any], Dict[str, Any], Dict[str, Any]]
class pistarlab.session_env.RLSessionEnvBase(task_id=None, agent_id=None, env_spec_id=None, env_kwargs={}, config: Optional[pistarlab.session_config.RLSessionConfig] = None)

Bases: object

get_logger()
get_sess_config()pistarlab.session_config.RLSessionConfig
get_spec_env_dbmodel()pistarlab.dbmodels.EnvSpecModel
get_task()pistarlab.task.Task
class pistarlab.session_env.RLSingleSessionEnv(agent_id=None, agent_run_config={}, use_remote_client=False, run_meta={}, timeout_abort_check_callback=<function RLSingleSessionEnv.<lambda>>, *args, **kwargs)

Bases: pistarlab.session_env.RLSessionEnvBase

TODO: NOT CURRENTLY WORKING

close()
is_complete()
reset()
step(action)

pistarlab.storage module

class pistarlab.storage.JSONEncoderCustom(skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, encoding='utf-8', default=None, use_decimal=True, namedtuple_as_object=True, tuple_as_array=True, bigint_as_string=False, item_sort_key=None, for_json=False, ignore_nan=False, int_as_string_bitcount=None, iterable_as_array=False)

Bases: simplejson.encoder.JSONEncoder

default(obj)

Implement this method in a subclass such that it returns a serializable object for o, or calls the base implementation (to raise a TypeError).

For example, to support arbitrary iterators, you could implement default like this:

def default(self, o):
    try:
        iterable = iter(o)
    except TypeError:
        pass
    else:
        return list(iterable)
    return JSONEncoder.default(self, o)
class pistarlab.storage.Storage(root_path, overwrite=False, check_file_last_updated=True, read_only=False, use_write_thread=True)

Bases: pistarlab.filestore.FileStore

TODO: Move FileStore to component (instead of inheritance)

get_session_data(session_id: str, name, start_idx=0, end_idx=None)
get_session_logs(session_id, name)
save_episode_recording(session_id: str, episode_id: str, values)
save_episode_stats(session_id: str, episode_id: str, values)
save_frame(session_id: str, episode_id: str, step_id: int, frame: Any)
save_image(name, image)
save_session_data(session_id, name, data)
save_session_logs(session_id, name, logs)

pistarlab.streamer module

exception pistarlab.streamer.MediaStreamError

Bases: Exception

class pistarlab.streamer.RedisVideoStreamTrack(stream_id)

Bases: aiortc.mediastreams.MediaStreamTrack

kind = 'video'
async next_timestamp()Tuple[int, fractions.Fraction]
async recv()av.frame.Frame

Receive the next VideoFrame.

The base implementation just reads a 640x480 green frame at 30fps, subclass VideoStreamTrack to provide a useful implementation.

stop()
async pistarlab.streamer.offer(request)
async pistarlab.streamer.on_shutdown(app)

pistarlab.task module

class pistarlab.task.AgentTask(_id=None, spec_id=None, config={}, parent_task_id=None, archive=False)

Bases: pistarlab.task.Task

static create(env_spec_id=None, env_kwargs={}, parent_task_id=None, session_config={}, agent: Optional[pistarlab.agent.Agent] = None, agent_run_config={}, batch_size=1, status_check_freq_secs=2, checkpoint_freq=10, archive=False, interface_id='run', **kwargs)
get_agent()pistarlab.agent.Agent
get_agent_dbmodel()
get_agent_run_config()
get_session_summaries()
get_session_summary_stats()
get_sessions()
shutdown(exit_state='TERMINATED', exit_msg='')

TODO: What is the difference between this and _shutdown?

update_summary(summary)
class pistarlab.task.Task(_id=None, spec_id=None, config={}, parent_task_id=None, archive=False)

Bases: pistarlab.entity.Entity

change_status(state, msg='')
static create(spec_id, config, parent_task_id=None)
get_actor_uid()str
get_child_task_summaries()
get_child_tasks()List[Any]
get_dbmodel()pistarlab.dbmodels.TaskModel
static get_dbmodel_by_id(id)pistarlab.dbmodels.TaskModel
get_logger()
static get_spec_dbmodel_by_id(id)pistarlab.dbmodels.TaskSpecModel
get_status()
get_summary()
static load(id)
run()pistarlab.execution_context.RunFuture
set_actor_uid(actor_uid)
set_primary_session_by_id(session_id)
shutdown(shutdown_state='TERMINATED', msg='')

TODO: What is the difference between this and _shutdown?

update_config(config)
update_summary(summary)
wait_for_next_summary_update()

pistarlab.task_runner module

class pistarlab.task_runner.AgentTaskRunner(task_id)

Bases: pistarlab.task_runner.TaskRunner

get_task()pistarlab.task.AgentTask
class pistarlab.task_runner.TaskRunner(task_id)

Bases: object

close()
config = {}
description = None
displayed_name = None
entry_point = 'pistarlab.task:Task'
get_logger()
get_task()pistarlab.task.Task
initialize()
is_running()
plugin_id = 'WORKSPACE'
plugin_version = '0.0.1-dev'
run()Tuple[Any, Any]
spec_id = None
version = '0.0.1-dev'

pistarlab.util_funcs module

pistarlab.util_funcs.clean_collection(d, clean_f=<function value_cleaner>, inplace=False)
pistarlab.util_funcs.cls_as_entry_point(cls)
pistarlab.util_funcs.flatten_graphql(data)
pistarlab.util_funcs.flatten_lists(lists)
pistarlab.util_funcs.get_class_from_entry_point(entry_point)
pistarlab.util_funcs.get_stats(collected_data)
pistarlab.util_funcs.get_stats_flat(collected_data, suffix='group')
pistarlab.util_funcs.merged_dict(d1, d2, depth=0)
pistarlab.util_funcs.sort_entity_by_id(data)
pistarlab.util_funcs.transpose_dict_list(lst)
pistarlab.util_funcs.value_cleaner(v)

Module contents