pyicub.rest

Functions

custom_serializer(obj)
rest_service(func)

Classes

FSMsManager()
GenericType(data)
PyiCubApp(*args, **kwargs)
PyiCubRESTfulClient(host, port[, rule_prefix])
PyiCubRESTfulServer(*args, **kwargs)
RESTApp([name, url, json_dict])
RESTJSON([json_dict])
RESTRobot([name, url, json_dict])
RESTService([service, json_dict])
RESTSubscriberFSM(*args, **kwargs)
RESTTopic([name, robot_name, app_name, ...])
iCubFSM([JSON_dict, JSON_file])
iCubRESTApp(*args, **kwargs)
iCubRESTManager(*args, **kwargs)
iCubRESTServer(*args, **kwargs)
iCubRESTService([name, robot_name, ...])
iCubRESTSubscriber(*args, **kwargs)

class pyicub.rest.GenericType(data)

pyicub.rest.custom_serializer(obj: Any) → Any

class pyicub.rest.RESTJSON(json_dict=None)

fromJSON(json_dict: dict)

toJSON()

class pyicub.rest.RESTRobot(name=None, url=None, json_dict=None)

class pyicub.rest.RESTApp(name=None, url=None, json_dict=None)

class pyicub.rest.RESTTopic(name=None, robot_name=None, app_name=None, subscriber_rule=None, json_dict=None)

class pyicub.rest.iCubRESTService(name=None, robot_name=None, app_name=None, url=None, target=None, signature=None, json_dict=None)

class pyicub.rest.RESTService(service: iCubRESTService = None, json_dict=None)

class pyicub.rest.iCubRESTServer(*args, **kwargs)

property logger

header(host, port)

server_rule(host=None, port=None)

robot_rule(robot_name, host=None, port=None)

app_rule(robot_name, app_name, host=None, port=None)

target_rule(robot_name, app_name, target_name, host=None, port=None)

run_forever()

shutdown()

wrapper_target(robot_name, app_name, target_name)

process_target_remote(service)

info()

get_tree()

get_robots()

get_apps(robot_name)

get_services(robot_name, app_name)

is_local_register(host, port)

remote_register()

remote_unregister()

register(robot_name, app_name, target_name, target, target_signature, url)

unregister(robot_name, app_name, target_name, url)

remote_subscribe()

remote_unsubscribe()

remote_notify()

subscribe(topic_uri, on_enter, on_exit)

unsubscribe(topic_uri)

class pyicub.rest.iCubRESTManager(*args, **kwargs)

property request_manager

property proxy_host

proxy_rule()

amiproxy()

requests()

processes()

proc_info(name)

req_info(req_id)

single_req_info(robot_name, app_name, target_name, local_id)

subscribe_topic(robot_name, app_name, target_name, subscriber_rule)

unsubscribe_topic(robot_name, app_name, target_name, subscriber_rule)

target_requests(target)

status_requests(status)

subscribers()

pending_requests()

process_target(service)

notify_subscriber(subscriber_url, target_rule, req, input_json)

register_target(robot_name, app_name, target_name, target, target_signature)

unregister_target(robot_name, app_name, target_name, host, port)

class pyicub.rest.PyiCubApp(*args, **kwargs)

property logger

property request_manager

property rest_manager

pyicub.rest.rest_service(func)

class pyicub.rest.PyiCubRESTfulServer(*args, **kwargs)

custom_rest_services = {}

configure(input_args)

property name

property robot_name

property fsm

getServices()

getArgsTemplate()

initHelper()

getArgs()

setArgs(input_args: dict)

getArg(name: str)

setArg(name: str, value: object)

setFSM(fsm: FSM, session_id=0)

class pyicub.rest.iCubRESTApp(*args, **kwargs)

configure(input_args)

info()

importActionFromJSONFile(JSON_file)

importActions(path)

importActionFromJSONDict(JSON_dict, name_prefix=None)

playAction(action_id: str, wait_for_completed=True)

getActions()

importAction(action: iCubFullbodyAction, name_prefix=None)

property icub

class pyicub.rest.iCubRESTSubscriber(*args, **kwargs)

subscribe_topic(topic_uri, on_enter=None, on_exit=None)

run_forever()

class pyicub.rest.RESTSubscriberFSM(*args, **kwargs)

refresh_targets()

on_enter_state(fsm_name, session_id, session_count, state_name)

on_exit_state(fsm_name, session_id, session_count, state_name)

on_enter_fsm(fsm_name, session_id, session_count)

on_exit_fsm(fsm_name, session_id, session_count)

class pyicub.rest.iCubFSM(JSON_dict=None, JSON_file=None)

property actions

property icub

setApp(app: iCubRESTApp)

addAction(action: iCubFullbodyAction)

addTemplate(template: iCubActionTemplate, template_params: list)

importFromJSONDict(data)

exportJSONFile(filepath)

class pyicub.rest.PyiCubRESTfulClient(host, port, rule_prefix='pyicub')

fsm_runStep(robot_name, app_name, trigger, **kargs)

get_fsm(robot_name, app_name)

get_version()

get_robots()

get_apps(robot_name)

get_services(robot_name, app_name)

get_robot_actions(robot_name)

play_action(robot_name, action_id, sync=True)

run_target(robot_name, app_name, target_name, *args, **kwargs)

run_target_async(robot_name, app_name, target_name, *args, **kwargs)

get_request_info(req_id)

is_request_running(req_id)

wait_until_completed(req_id)

class pyicub.rest.FSMsManager

addFSM(machine: iCubFSM, machine_id=None)

importFSMsFromModule(module)

getFSM(machine_id: str)

getFSMs()

exportFSMs(path)