corelink.resources.control

Control requests that can be made from the server.

  1"""
  2Control requests that can be made from the server.
  3"""
  4
  5from . import variables
  6from .reqs import retrieve, request_func
  7
  8
  9async def auth() -> int:
 10    """Authenticates user with values in the object
 11    :return: token
 12    """
 13    request = {
 14        "function": "auth",
 15        "username": variables.user,
 16        "password": variables.password
 17    }
 18    response = retrieve(await request_func(request), ret=True)
 19
 20    variables.token = response['token']
 21    variables.user_ip = response['IP']
 22
 23async def list_functions() -> list:
 24    """return: List of functions available to the user
 25    """
 26    request = {
 27        "function": "listFunctions",
 28        "token": variables.token
 29    }
 30    return retrieve(await request_func(request), "functionList")
 31
 32async def list_server_functions() -> list:
 33    request = {
 34        "function": "listServerFunctions",
 35        "token": variables.token
 36    }
 37    return retrieve(await request_func(request), "functionList")
 38
 39async def describe_function(func: str) -> dict:
 40    request = {"function": "describeFunction",
 41                "functionName": func,
 42                "token": variables.token}
 43    return retrieve(await request_func(request), "description")
 44
 45async def describe_server_function() -> dict:
 46    request = {
 47        "function": "listServerFunctions",
 48        "token": variables.token
 49    }
 50    return retrieve(await request_func(request), "description")
 51
 52async def list_workspaces() -> list:
 53    request = {
 54        "function": "listWorkspaces",
 55        "token": variables.token
 56    }
 57    return retrieve(await request_func(request), "workspaceList")
 58
 59async def add_workspace(space: str):
 60    """Adds a workspace.
 61    :param space: Space to add
 62    :return: Workspace
 63    """
 64    request = {
 65        "function": "addWorkspace",
 66        "workspace": space,
 67        "token": variables.token
 68    }
 69    return retrieve(await request_func(request))
 70
 71async def set_default_workspace(space):
 72    """Sets default workspace.
 73    :param space: space to set
 74    :return: Workspace
 75    """
 76    request = {
 77        "function": "setDefaultWorkspace",
 78        "workspace": space,
 79        "token": variables.token
 80    }
 81    return retrieve(await request_func(request))
 82
 83async def get_default_workspace() -> str:
 84    """return: Default workspace
 85    """
 86    request = {
 87        "function": "getDefaultWorkspace",
 88        "token": variables.token
 89    }
 90    return retrieve(await request_func(request), "workspace")
 91
 92async def remove_workspace(space: str):
 93    request = {
 94        "function": "rmWorkspace",
 95        "workspace": space,
 96        "token": variables.token
 97    }
 98    return retrieve(await request_func(request))
 99
100async def add_user(new_username, new_password, admin_bool, first_name,
101                    last_name, email):
102    request = {
103        "function": "addUser",
104        "username": new_username,
105        "password": new_password,
106        "admin": admin_bool,
107        "first": first_name,
108        "last": last_name,
109        "email": email,
110        "token": variables.token
111    }
112    return retrieve(await request_func(request))
113
114async def change_password(new_password):
115    request = {
116        "function": "password",
117        "password": new_password,
118        "token": variables.token
119    }
120    return retrieve(await request_func(request))
121
122async def remove_user(rm_username):
123    request = {
124        "function": "rmUser",
125        "password": rm_username,
126        "token": variables.token
127    }
128    return retrieve(await request_func(request))
129
130async def list_users():
131    request = {
132        "function": "listUsers",
133        "token": variables.token
134    }
135    return retrieve(await request_func(request), "userList")
136
137async def add_group(group):
138    request = {
139        "function": "addGroup",
140        "group": group,
141        "token": variables.token
142    }
143    return retrieve(await request_func(request))
144
145async def add_user_group(group, user):
146    request = {
147        "function": "addUserGroup",
148        "group": group,
149        "user": user,
150        "token": variables.token
151    }
152    return retrieve(await request_func(request))
153
154async def remove_user_group(group, user):
155    request = {
156        "function": "rmUserGroup",
157        "group": group,
158        "user": user,
159        "token": variables.token
160    }
161    return retrieve(await request_func(request))
162
163async def change_owner(group, user):
164    request = {
165        "function": "changeOwner",
166        "group": group,
167        "user": user,
168        "token": variables.token
169    }
170    return retrieve(await request_func(request))
171
172async def remove_group(group, user):
173    request = {
174        "function": "rmGroup",
175        "group": group,
176        "token": variables.token
177    }
178    return retrieve(await request_func(request))
179
180async def list_groups(group, user):
181    request = {
182        "function": "listGroups",
183        "token": variables.token
184    }
185    return retrieve(await request_func(request))
186
187
188async def list_streams(workspaces=[], types=[]):
189    request = {
190        "function": "listStreams",
191        "workspaces": workspaces,
192        "types": types,
193        "token": variables.token
194    }
195    return retrieve(await request_func(request), "senderList")
196
197async def stream_info(stream_id):
198    request = {
199        "function": "streamInfo",
200        "streamID": stream_id,
201        "token": variables.token
202    }
203    return retrieve(await request_func(request), "info")
204
205async def subscribe_to_stream(receiver_id, stream_id):
206    if not receiver_id in variables.receiver:
207        raise Exception("Receiver not yet created.")
208    request = {
209        "function": "subscribe",
210        "receiverID": receiver_id,
211        "streamID": stream_id,
212        "token": variables.token
213    }
214    return retrieve(await request_func(request), "streamList")
215
216async def unsubscribe_from_stream(stream_id):
217    if not stream_id in variables.receiver:
218        raise Exception("Receiver not yet created.")
219    request = {
220        "function": "unsubscribe",
221        "receiverID": variables.receiver['streamID'],
222        "streamID": stream_id,
223        "token": variables.token
224    }
225    return retrieve(await request_func(request), "streamList")
226
227async def set_config(config, context, app, username, value):
228    request = {
229        "function": "setConfig",
230        "config": config,
231        "context": context,
232        "app": app,
233        "user": username,
234        "value": value,
235        "token": variables.token
236    }
237    return retrieve(await request_func(request))
238
239async def disconnect_streams(workspaces=None, types=None, stream_ids=None):
240    """Disconnects streams of given workspaces and types, or by streamIDs
241    Note: if streamIDs are passed, then other params will be ignored
242    return: list of disconnected streams
243    """
244    if not (workspaces or types or stream_ids):
245        raise ValueError
246    request = {
247        "function": "disconnect",
248        "token": variables.token
249    }
250    if workspaces:
251        request["workspaces"] = workspaces
252    if types:
253        request["types"] = types
254    if stream_ids:
255        request["streamIDs"] = stream_ids
256    return retrieve(await request_func(request), "streamList")  
257
258# async def expire():
259#     """Expires session and invalidates user token"""
260#     request = {
261#         "function": "expire",
262#         "token": token
263#     }
264#     return retrieve(await request_func(request))
265# Sarthak said this doesn't yet work
async def auth() -> int: 
10async def auth() -> int:
11    """Authenticates user with values in the object
12    :return: token
13    """
14    request = {
15        "function": "auth",
16        "username": variables.user,
17        "password": variables.password
18    }
19    response = retrieve(await request_func(request), ret=True)
20
21    variables.token = response['token']
22    variables.user_ip = response['IP']

Authenticates user with values in the object

Returns

token

async def list_functions() -> list: 
24async def list_functions() -> list:
25    """return: List of functions available to the user
26    """
27    request = {
28        "function": "listFunctions",
29        "token": variables.token
30    }
31    return retrieve(await request_func(request), "functionList")

return: List of functions available to the user

async def list_server_functions() -> list: 
33async def list_server_functions() -> list:
34    request = {
35        "function": "listServerFunctions",
36        "token": variables.token
37    }
38    return retrieve(await request_func(request), "functionList")
async def describe_function(func: str) -> dict: 
40async def describe_function(func: str) -> dict:
41    request = {"function": "describeFunction",
42                "functionName": func,
43                "token": variables.token}
44    return retrieve(await request_func(request), "description")
async def describe_server_function() -> dict: 
46async def describe_server_function() -> dict:
47    request = {
48        "function": "listServerFunctions",
49        "token": variables.token
50    }
51    return retrieve(await request_func(request), "description")
async def list_workspaces() -> list: 
53async def list_workspaces() -> list:
54    request = {
55        "function": "listWorkspaces",
56        "token": variables.token
57    }
58    return retrieve(await request_func(request), "workspaceList")
async def add_workspace(space: str): 
60async def add_workspace(space: str):
61    """Adds a workspace.
62    :param space: Space to add
63    :return: Workspace
64    """
65    request = {
66        "function": "addWorkspace",
67        "workspace": space,
68        "token": variables.token
69    }
70    return retrieve(await request_func(request))

Adds a workspace.

Parameters
  • space: Space to add
Returns

Workspace

async def set_default_workspace(space): 
72async def set_default_workspace(space):
73    """Sets default workspace.
74    :param space: space to set
75    :return: Workspace
76    """
77    request = {
78        "function": "setDefaultWorkspace",
79        "workspace": space,
80        "token": variables.token
81    }
82    return retrieve(await request_func(request))

Sets default workspace.

Parameters
  • space: space to set
Returns

Workspace

async def get_default_workspace() -> str: 
84async def get_default_workspace() -> str:
85    """return: Default workspace
86    """
87    request = {
88        "function": "getDefaultWorkspace",
89        "token": variables.token
90    }
91    return retrieve(await request_func(request), "workspace")

return: Default workspace

async def remove_workspace(space: str): 
93async def remove_workspace(space: str):
94    request = {
95        "function": "rmWorkspace",
96        "workspace": space,
97        "token": variables.token
98    }
99    return retrieve(await request_func(request))
async def add_user(new_username, new_password, admin_bool, first_name, last_name, email): 
101async def add_user(new_username, new_password, admin_bool, first_name,
102                    last_name, email):
103    request = {
104        "function": "addUser",
105        "username": new_username,
106        "password": new_password,
107        "admin": admin_bool,
108        "first": first_name,
109        "last": last_name,
110        "email": email,
111        "token": variables.token
112    }
113    return retrieve(await request_func(request))
async def change_password(new_password): 
115async def change_password(new_password):
116    request = {
117        "function": "password",
118        "password": new_password,
119        "token": variables.token
120    }
121    return retrieve(await request_func(request))
async def remove_user(rm_username): 
123async def remove_user(rm_username):
124    request = {
125        "function": "rmUser",
126        "password": rm_username,
127        "token": variables.token
128    }
129    return retrieve(await request_func(request))
async def list_users(): 
131async def list_users():
132    request = {
133        "function": "listUsers",
134        "token": variables.token
135    }
136    return retrieve(await request_func(request), "userList")
async def add_group(group): 
138async def add_group(group):
139    request = {
140        "function": "addGroup",
141        "group": group,
142        "token": variables.token
143    }
144    return retrieve(await request_func(request))
async def add_user_group(group, user): 
146async def add_user_group(group, user):
147    request = {
148        "function": "addUserGroup",
149        "group": group,
150        "user": user,
151        "token": variables.token
152    }
153    return retrieve(await request_func(request))
async def remove_user_group(group, user): 
155async def remove_user_group(group, user):
156    request = {
157        "function": "rmUserGroup",
158        "group": group,
159        "user": user,
160        "token": variables.token
161    }
162    return retrieve(await request_func(request))
async def change_owner(group, user): 
164async def change_owner(group, user):
165    request = {
166        "function": "changeOwner",
167        "group": group,
168        "user": user,
169        "token": variables.token
170    }
171    return retrieve(await request_func(request))
async def remove_group(group, user): 
173async def remove_group(group, user):
174    request = {
175        "function": "rmGroup",
176        "group": group,
177        "token": variables.token
178    }
179    return retrieve(await request_func(request))
async def list_groups(group, user): 
181async def list_groups(group, user):
182    request = {
183        "function": "listGroups",
184        "token": variables.token
185    }
186    return retrieve(await request_func(request))
async def list_streams(workspaces=[], types=[]): 
189async def list_streams(workspaces=[], types=[]):
190    request = {
191        "function": "listStreams",
192        "workspaces": workspaces,
193        "types": types,
194        "token": variables.token
195    }
196    return retrieve(await request_func(request), "senderList")
async def stream_info(stream_id): 
198async def stream_info(stream_id):
199    request = {
200        "function": "streamInfo",
201        "streamID": stream_id,
202        "token": variables.token
203    }
204    return retrieve(await request_func(request), "info")
async def subscribe_to_stream(receiver_id, stream_id): 
206async def subscribe_to_stream(receiver_id, stream_id):
207    if not receiver_id in variables.receiver:
208        raise Exception("Receiver not yet created.")
209    request = {
210        "function": "subscribe",
211        "receiverID": receiver_id,
212        "streamID": stream_id,
213        "token": variables.token
214    }
215    return retrieve(await request_func(request), "streamList")
async def unsubscribe_from_stream(stream_id): 
217async def unsubscribe_from_stream(stream_id):
218    if not stream_id in variables.receiver:
219        raise Exception("Receiver not yet created.")
220    request = {
221        "function": "unsubscribe",
222        "receiverID": variables.receiver['streamID'],
223        "streamID": stream_id,
224        "token": variables.token
225    }
226    return retrieve(await request_func(request), "streamList")
async def set_config(config, context, app, username, value): 
228async def set_config(config, context, app, username, value):
229    request = {
230        "function": "setConfig",
231        "config": config,
232        "context": context,
233        "app": app,
234        "user": username,
235        "value": value,
236        "token": variables.token
237    }
238    return retrieve(await request_func(request))
async def disconnect_streams(workspaces=None, types=None, stream_ids=None): 
240async def disconnect_streams(workspaces=None, types=None, stream_ids=None):
241    """Disconnects streams of given workspaces and types, or by streamIDs
242    Note: if streamIDs are passed, then other params will be ignored
243    return: list of disconnected streams
244    """
245    if not (workspaces or types or stream_ids):
246        raise ValueError
247    request = {
248        "function": "disconnect",
249        "token": variables.token
250    }
251    if workspaces:
252        request["workspaces"] = workspaces
253    if types:
254        request["types"] = types
255    if stream_ids:
256        request["streamIDs"] = stream_ids
257    return retrieve(await request_func(request), "streamList")

Disconnects streams of given workspaces and types, or by streamIDs Note: if streamIDs are passed, then other params will be ignored return: list of disconnected streams