text stringlengths 81 112k |
|---|
Sleep if rate limiting is required based on current time and last
query.
def rate_limit_wait(self):
"""
Sleep if rate limiting is required based on current time and last
query.
"""
if self._rate_limit_dt and self._last_query is not None:
dt = time.time() - self._last_query
wait = self._rate_limit_dt - dt
if wait > 0:
time.sleep(wait) |
Query a route.
route(locations): points can be
- a sequence of locations
- a Shapely LineString
route(origin, destination, waypoints=None)
- origin and destination are a single destination
- waypoints are the points to be inserted between the
origin and destination
If waypoints is specified, destination must also be specified
Each location can be:
- string (will be geocoded by the routing provider. Not all
providers accept this as input)
- (longitude, latitude) sequence (tuple, list, numpy array, etc.)
- Shapely Point with x as longitude, y as latitude
Additional parameters
---------------------
raw : bool, default False
Return the raw json dict response from the service
Returns
-------
list of Route objects
If raw is True, returns the json dict instead of converting to Route
objects
Examples
--------
mq = directions.Mapquest(key)
routes = mq.route('1 magazine st. cambridge, ma',
'south station boston, ma')
routes = mq.route('1 magazine st. cambridge, ma',
'south station boston, ma',
waypoints=['700 commonwealth ave. boston, ma'])
# Uses each point in the line as a waypoint. There is a limit to the
# number of waypoints for each service. Consult the docs.
line = LineString(...)
routes = mq.route(line)
# Feel free to mix different location types
routes = mq.route(line.coords[0], 'south station boston, ma',
waypoints=[(-71.103972, 42.349324)])
def route(self, arg, destination=None, waypoints=None, raw=False, **kwargs):
"""
Query a route.
route(locations): points can be
- a sequence of locations
- a Shapely LineString
route(origin, destination, waypoints=None)
- origin and destination are a single destination
- waypoints are the points to be inserted between the
origin and destination
If waypoints is specified, destination must also be specified
Each location can be:
- string (will be geocoded by the routing provider. Not all
providers accept this as input)
- (longitude, latitude) sequence (tuple, list, numpy array, etc.)
- Shapely Point with x as longitude, y as latitude
Additional parameters
---------------------
raw : bool, default False
Return the raw json dict response from the service
Returns
-------
list of Route objects
If raw is True, returns the json dict instead of converting to Route
objects
Examples
--------
mq = directions.Mapquest(key)
routes = mq.route('1 magazine st. cambridge, ma',
'south station boston, ma')
routes = mq.route('1 magazine st. cambridge, ma',
'south station boston, ma',
waypoints=['700 commonwealth ave. boston, ma'])
# Uses each point in the line as a waypoint. There is a limit to the
# number of waypoints for each service. Consult the docs.
line = LineString(...)
routes = mq.route(line)
# Feel free to mix different location types
routes = mq.route(line.coords[0], 'south station boston, ma',
waypoints=[(-71.103972, 42.349324)])
"""
points = _parse_points(arg, destination, waypoints)
if len(points) < 2:
raise ValueError('You must specify at least 2 points')
self.rate_limit_wait()
data = self.raw_query(points, **kwargs)
self._last_query = time.time()
if raw:
return data
return self.format_output(data) |
Return a Route from a GeoJSON dictionary, as returned by Route.geojson()
def from_geojson(cls, data):
"""
Return a Route from a GeoJSON dictionary, as returned by Route.geojson()
"""
properties = data['properties']
distance = properties.pop('distance')
duration = properties.pop('duration')
maneuvers = []
for feature in data['features']:
geom = feature['geometry']
if geom['type'] == 'LineString':
coords = geom['coordinates']
else:
maneuvers.append(Maneuver.from_geojson(feature))
return Route(coords, distance, duration, maneuvers, **properties) |
Scan all paths for external modules and form key-value dict.
:param module_paths: list of external modules (either python packages or third-party scripts)
:param available: dict of all registered python modules (can contain python modules from module_paths)
:return: dict of external modules, where keys are filenames (same as stepnames) and values are the paths
def prepare_modules(module_paths: list, available: dict) -> dict:
"""
Scan all paths for external modules and form key-value dict.
:param module_paths: list of external modules (either python packages or third-party scripts)
:param available: dict of all registered python modules (can contain python modules from module_paths)
:return: dict of external modules, where keys are filenames (same as stepnames) and values are the paths
"""
indexed = {}
for path in module_paths:
if not os.path.exists(path) and path not in available:
err = 'No such path: ' + path
error(err)
else:
for f in os.listdir(path):
mod_path = join(path, f)
if f in indexed:
warning('Override ' + indexed[f] + ' with ' + mod_path)
indexed[f] = mod_path
return indexed |
sends an SSDP discovery packet to the network and collects
the devices that replies to it. A dictionary is returned
using the devices unique usn as key
def discover_upnp_devices(
self, st="upnp:rootdevice", timeout=2, mx=1, retries=1
):
"""
sends an SSDP discovery packet to the network and collects
the devices that replies to it. A dictionary is returned
using the devices unique usn as key
"""
# prepare UDP socket to transfer the SSDP packets
s = socket.socket(
socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP
)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
s.settimeout(timeout)
# prepare SSDP discover message
msg = SSDPDiscoveryMessage(mx=mx, st=st)
# try to get devices with multiple retries in case of failure
devices = {}
for _ in range(retries):
# send SSDP discovery message
s.sendto(msg.bytes, SSDP_MULTICAST_ADDR)
devices = {}
try:
while True:
# parse response and store it in dict
r = SSDPResponse(s.recvfrom(65507))
devices[r.usn] = r
except socket.timeout:
break
return devices |
returns a dict of devices that contain the given model name
def get_filtered_devices(
self, model_name, device_types="upnp:rootdevice", timeout=2
):
"""
returns a dict of devices that contain the given model name
"""
# get list of all UPNP devices in the network
upnp_devices = self.discover_upnp_devices(st=device_types)
# go through all UPNP devices and filter wanted devices
filtered_devices = collections.defaultdict(dict)
for dev in upnp_devices.values():
try:
# download XML file with information about the device
# from the device's location
r = requests.get(dev.location, timeout=timeout)
if r.status_code == requests.codes.ok:
# parse returned XML
root = ET.fromstring(r.text)
# add shortcut for XML namespace to access sub nodes
ns = {"upnp": "urn:schemas-upnp-org:device-1-0"}
# get device element
device = root.find("upnp:device", ns)
if model_name in device.find(
"upnp:modelName", ns
).text:
# model name is wanted => add to list
# get unique UDN of the device that is used as key
udn = device.find("upnp:UDN", ns).text
# add url base
url_base = root.find("upnp:URLBase", ns)
if url_base is not None:
filtered_devices[udn][
"URLBase"
] = url_base.text
# add interesting device attributes and
# use unique UDN as key
for attr in (
"deviceType", "friendlyName", "manufacturer",
"manufacturerURL", "modelDescription",
"modelName", "modelNumber"
):
el = device.find("upnp:%s" % attr, ns)
if el is not None:
filtered_devices[udn][
attr
] = el.text.strip()
except ET.ParseError:
# just skip devices that are invalid xml
pass
except requests.exceptions.ConnectTimeout:
# just skip devices that are not replying in time
print("Timeout for '%s'. Skipping." % dev.location)
return filtered_devices |
A variant of multiprocessing.Pool.map that supports lazy evaluation
As with the regular multiprocessing.Pool.map, the processes are spawned off
asynchronously while the results are returned in order. In contrast to
multiprocessing.Pool.map, the iterator (here: data_generator) is not
consumed at once but evaluated lazily which is useful if the iterator
(for example, a generator) contains objects with a large memory footprint.
Parameters
==========
data_processor : func
A processing function that is applied to objects in `data_generator`
data_generator : iterator or generator
A python iterator or generator that yields objects to be fed into the
`data_processor` function for processing.
n_cpus=1 : int (default: 1)
Number of processes to run in parallel.
- If `n_cpus` > 0, the specified number of CPUs will be used.
- If `n_cpus=0`, all available CPUs will be used.
- If `n_cpus` < 0, all available CPUs - `n_cpus` will be used.
stepsize : int or None (default: None)
The number of items to fetch from the iterator to pass on to the
workers at a time.
If `stepsize=None` (default), the stepsize size will
be set equal to `n_cpus`.
Returns
=========
list : A Python list containing the results returned
by the `data_processor` function when called on
all elements in yielded by the `data_generator` in
sorted order. Note that the last list may contain
fewer items if the number of elements in `data_generator`
is not evenly divisible by `stepsize`.
def lazy_map(data_processor, data_generator, n_cpus=1, stepsize=None):
"""A variant of multiprocessing.Pool.map that supports lazy evaluation
As with the regular multiprocessing.Pool.map, the processes are spawned off
asynchronously while the results are returned in order. In contrast to
multiprocessing.Pool.map, the iterator (here: data_generator) is not
consumed at once but evaluated lazily which is useful if the iterator
(for example, a generator) contains objects with a large memory footprint.
Parameters
==========
data_processor : func
A processing function that is applied to objects in `data_generator`
data_generator : iterator or generator
A python iterator or generator that yields objects to be fed into the
`data_processor` function for processing.
n_cpus=1 : int (default: 1)
Number of processes to run in parallel.
- If `n_cpus` > 0, the specified number of CPUs will be used.
- If `n_cpus=0`, all available CPUs will be used.
- If `n_cpus` < 0, all available CPUs - `n_cpus` will be used.
stepsize : int or None (default: None)
The number of items to fetch from the iterator to pass on to the
workers at a time.
If `stepsize=None` (default), the stepsize size will
be set equal to `n_cpus`.
Returns
=========
list : A Python list containing the results returned
by the `data_processor` function when called on
all elements in yielded by the `data_generator` in
sorted order. Note that the last list may contain
fewer items if the number of elements in `data_generator`
is not evenly divisible by `stepsize`.
"""
if not n_cpus:
n_cpus = mp.cpu_count()
elif n_cpus < 0:
n_cpus = mp.cpu_count() - n_cpus
if stepsize is None:
stepsize = n_cpus
results = []
with mp.Pool(processes=n_cpus) as p:
while True:
r = p.map(data_processor, islice(data_generator, stepsize))
if r:
results.extend(r)
else:
break
return results |
A variant of multiprocessing.Pool.imap that supports lazy evaluation
As with the regular multiprocessing.Pool.imap, the processes are spawned
off asynchronously while the results are returned in order. In contrast to
multiprocessing.Pool.imap, the iterator (here: data_generator) is not
consumed at once but evaluated lazily which is useful if the iterator
(for example, a generator) contains objects with a large memory footprint.
Parameters
==========
data_processor : func
A processing function that is applied to objects in `data_generator`
data_generator : iterator or generator
A python iterator or generator that yields objects to be fed into the
`data_processor` function for processing.
n_cpus=1 : int (default: 1)
Number of processes to run in parallel.
- If `n_cpus` > 0, the specified number of CPUs will be used.
- If `n_cpus=0`, all available CPUs will be used.
- If `n_cpus` < 0, all available CPUs - `n_cpus` will be used.
stepsize : int or None (default: None)
The number of items to fetch from the iterator to pass on to the
workers at a time.
If `stepsize=None` (default), the stepsize size will
be set equal to `n_cpus`.
Returns
=========
list : A Python list containing the *n* results returned
by the `data_processor` function when called on
elements by the `data_generator` in
sorted order; *n* is equal to the size of `stepsize`. If `stepsize`
is None, *n* is equal to `n_cpus`.
def lazy_imap(data_processor, data_generator, n_cpus=1, stepsize=None):
"""A variant of multiprocessing.Pool.imap that supports lazy evaluation
As with the regular multiprocessing.Pool.imap, the processes are spawned
off asynchronously while the results are returned in order. In contrast to
multiprocessing.Pool.imap, the iterator (here: data_generator) is not
consumed at once but evaluated lazily which is useful if the iterator
(for example, a generator) contains objects with a large memory footprint.
Parameters
==========
data_processor : func
A processing function that is applied to objects in `data_generator`
data_generator : iterator or generator
A python iterator or generator that yields objects to be fed into the
`data_processor` function for processing.
n_cpus=1 : int (default: 1)
Number of processes to run in parallel.
- If `n_cpus` > 0, the specified number of CPUs will be used.
- If `n_cpus=0`, all available CPUs will be used.
- If `n_cpus` < 0, all available CPUs - `n_cpus` will be used.
stepsize : int or None (default: None)
The number of items to fetch from the iterator to pass on to the
workers at a time.
If `stepsize=None` (default), the stepsize size will
be set equal to `n_cpus`.
Returns
=========
list : A Python list containing the *n* results returned
by the `data_processor` function when called on
elements by the `data_generator` in
sorted order; *n* is equal to the size of `stepsize`. If `stepsize`
is None, *n* is equal to `n_cpus`.
"""
if not n_cpus:
n_cpus = mp.cpu_count()
elif n_cpus < 0:
n_cpus = mp.cpu_count() - n_cpus
if stepsize is None:
stepsize = n_cpus
with mp.Pool(processes=n_cpus) as p:
while True:
r = p.map(data_processor, islice(data_generator, stepsize))
if r:
yield r
else:
break |
Use this decorator on Step.action implementation.
Your action method should always return variables, or
both variables and output.
This decorator will update variables with output.
def update_variables(func):
"""
Use this decorator on Step.action implementation.
Your action method should always return variables, or
both variables and output.
This decorator will update variables with output.
"""
@wraps(func)
def wrapper(self, *args, **kwargs):
result = func(self, *args, **kwargs)
if isinstance(result, tuple):
return self.process_register(result[0], result[1])
else:
return self.process_register(result)
return wrapper |
set the properties of the app model by the given data dict
def _set_properties(self, data):
"""
set the properties of the app model by the given data dict
"""
for property in data.keys():
if property in vars(self):
setattr(self, property, data[property]) |
get long description from README.rst file
def get_long_description():
"""
get long description from README.rst file
"""
with codecs.open(os.path.join(here, "README.rst"), "r", "utf-8") as f:
return f.read() |
This action handler responds to the "roll call" emitted by the api
gateway when it is brought up with the normal summary produced by
the service.
async def roll_call_handler(service, action_type, payload, props, **kwds):
"""
This action handler responds to the "roll call" emitted by the api
gateway when it is brought up with the normal summary produced by
the service.
"""
# if the action type corresponds to a roll call
if action_type == roll_call_type():
# then announce the service
await service.announce() |
This query handler builds the dynamic picture of availible services.
async def flexible_api_handler(service, action_type, payload, props, **kwds):
"""
This query handler builds the dynamic picture of availible services.
"""
# if the action represents a new service
if action_type == intialize_service_action():
# the treat the payload like json if its a string
model = json.loads(payload) if isinstance(payload, str) else payload
# the list of known models
models = service._external_service_data['models']
# the list of known connections
connections = service._external_service_data['connections']
# the list of known mutations
mutations = service._external_service_data['mutations']
# if the model is a connection
if 'connection' in model:
# if we haven't seen the connection before
if not [conn for conn in connections if conn['name'] == model['name']]:
# add it to the list
connections.append(model)
# or if there are registered fields
elif 'fields' in model and not [mod for mod in models if mod['name'] == model['name']]:
# add it to the model list
models.append(model)
# the service could provide mutations as well as affect the topology
if 'mutations' in model:
# go over each mutation announce
for mutation in model['mutations']:
# if there isn't a mutation by the same name in the local cache
if not [mut for mut in mutations if mut['name'] == mutation['name']]:
# add it to the local cache
mutations.append(mutation)
# if there are models
if models:
# create a new schema corresponding to the models and connections
service.schema = generate_api_schema(
models=models,
connections=connections,
mutations=mutations,
) |
This function figures out the list of orderings for the given model and
argument.
Args:
model (nautilus.BaseModel): The model to compute ordering against
order_by (list of str): the list of fields to order_by. If the field
starts with a `+` then the order is acending, if `-` descending,
if no character proceeds the field, the ordering is assumed to be
ascending.
Returns:
(list of filters): the model filters to apply to the query
def _parse_order_by(model, order_by):
"""
This function figures out the list of orderings for the given model and
argument.
Args:
model (nautilus.BaseModel): The model to compute ordering against
order_by (list of str): the list of fields to order_by. If the field
starts with a `+` then the order is acending, if `-` descending,
if no character proceeds the field, the ordering is assumed to be
ascending.
Returns:
(list of filters): the model filters to apply to the query
"""
# the list of filters for the models
out = []
# for each attribute we have to order by
for key in order_by:
# remove any whitespace
key = key.strip()
# if the key starts with a plus
if key.startswith("+"):
# add the ascending filter to the list
out.append(getattr(model, key[1:]))
# otherwise if the key starts with a minus
elif key.startswith("-"):
# add the descending filter to the list
out.append(getattr(model, key[1:]).desc())
# otherwise the key needs the default filter
else:
# add the default filter to the list
out.append(getattr(model, key))
# returnt the list of filters
return out |
Creates the example directory structure necessary for a model service.
def model(model_names):
"""
Creates the example directory structure necessary for a model service.
"""
# for each model name we need to create
for model_name in model_names:
# the template context
context = {
'name': model_name,
}
# render the model template
render_template(template='common', context=context)
render_template(template='model', context=context) |
Create the folder/directories for an ApiGateway service.
def api():
"""
Create the folder/directories for an ApiGateway service.
"""
# the template context
context = {
'name': 'api',
'secret_key': random_string(32)
}
render_template(template='common', context=context)
render_template(template='api', context=context) |
Create the folder/directories for an Auth service.
def auth():
"""
Create the folder/directories for an Auth service.
"""
# the template context
context = {
'name': 'auth',
}
render_template(template='common', context=context)
render_template(template='auth', context=context) |
Creates the example directory structure necessary for a connection
service.
def connection(model_connections):
"""
Creates the example directory structure necessary for a connection
service.
"""
# for each connection group
for connection_str in model_connections:
# the services to connect
services = connection_str.split(':')
services.sort()
service_name = ''.join([service.title() for service in services])
# the template context
context = {
# make sure the first letter is lowercase
'name': service_name[0].lower() + service_name[1:],
'services': services,
}
render_template(template='common', context=context)
render_template(template='connection', context=context) |
This function returns the conventional action designator for a given model.
def get_model_string(model):
"""
This function returns the conventional action designator for a given model.
"""
name = model if isinstance(model, str) else model.__name__
return normalize_string(name) |
This function takes a list of type summaries and builds a dictionary
with native representations of each entry. Useful for dynamically
building native class records from summaries.
def build_native_type_dictionary(fields, respect_required=False, wrap_field=True, name=''):
"""
This function takes a list of type summaries and builds a dictionary
with native representations of each entry. Useful for dynamically
building native class records from summaries.
"""
# a place to start when building the input field attributes
input_fields = {}
# go over every input in the summary
for field in fields:
field_name = name + field['name']
field_type = field['type']
# if the type field is a string
if isinstance(field_type, str):
# compute the native api type for the field
field_type = convert_typestring_to_api_native(field_type)(
# required=respect_required and field['required']
)
# add an entry in the attributes
input_fields[field['name']] = field_type
# we could also be looking at a dictionary
elif isinstance(field_type, dict):
object_fields = field_type['fields']
# add the dictionary to the parent as a graphql object type
input_fields[field['name']] = graphql_type_from_summary(
summary={
'name': field_name+"ArgType",
'fields': object_fields
}
)
# if we are supposed to wrap the object in a field
if wrap_field:
# then wrap the value we just added
input_fields[field['name']] = graphene.Field(input_fields[field['name']])
# we're done
return input_fields |
This function provides the standard form for crud mutations.
def summarize_crud_mutation(method, model, isAsync=False):
"""
This function provides the standard form for crud mutations.
"""
# create the approrpriate action type
action_type = get_crud_action(method=method, model=model)
# the name of the mutation
name = crud_mutation_name(model=model, action=method)
# a mapping of methods to input factories
input_map = {
'create': create_mutation_inputs,
'update': update_mutation_inputs,
'delete': delete_mutation_inputs,
}
# a mappting of methods to output factories
output_map = {
'create': create_mutation_outputs,
'update': update_mutation_outputs,
'delete': delete_mutation_outputs,
}
# the inputs for the mutation
inputs = input_map[method](model)
# the mutation outputs
outputs = output_map[method](model)
# return the appropriate summary
return summarize_mutation(
mutation_name=name,
event=action_type,
isAsync=isAsync,
inputs=inputs,
outputs=outputs
) |
This function starts the brokers interaction with the kafka stream
def start(self):
"""
This function starts the brokers interaction with the kafka stream
"""
self.loop.run_until_complete(self._consumer.start())
self.loop.run_until_complete(self._producer.start())
self._consumer_task = self.loop.create_task(self._consume_event_callback()) |
This method stops the brokers interaction with the kafka stream
def stop(self):
"""
This method stops the brokers interaction with the kafka stream
"""
self.loop.run_until_complete(self._consumer.stop())
self.loop.run_until_complete(self._producer.stop())
# attempt
try:
# to cancel the service
self._consumer_task.cancel()
# if there was no service
except AttributeError:
# keep going
pass |
This method sends a message over the kafka stream.
async def send(self, payload='', action_type='', channel=None, **kwds):
"""
This method sends a message over the kafka stream.
"""
# use a custom channel if one was provided
channel = channel or self.producer_channel
# serialize the action type for the
message = serialize_action(action_type=action_type, payload=payload, **kwds)
# send the message
return await self._producer.send(channel, message.encode()) |
This function returns the conventional form of the actions.
def serialize_action(action_type, payload, **extra_fields):
"""
This function returns the conventional form of the actions.
"""
action_dict = dict(
action_type=action_type,
payload=payload,
**extra_fields
)
# return a serializable version
return json.dumps(action_dict) |
This function returns the fields for a schema that matches the provided
nautilus model.
Args:
model (nautilus.model.BaseModel): The model to base the field list on
Returns:
(dict<field_name: str, graphqlType>): A mapping of field names to
graphql types
def fields_for_model(model):
"""
This function returns the fields for a schema that matches the provided
nautilus model.
Args:
model (nautilus.model.BaseModel): The model to base the field list on
Returns:
(dict<field_name: str, graphqlType>): A mapping of field names to
graphql types
"""
# the attribute arguments (no filters)
args = {field.name.lower() : convert_peewee_field(field) \
for field in model.fields()}
# use the field arguments, without the segments
return args |
Create an SQL Alchemy table that connects the provides services
def create_connection_model(service):
""" Create an SQL Alchemy table that connects the provides services """
# the services connected
services = service._services
# the mixins / base for the model
bases = (BaseModel,)
# the fields of the derived
attributes = {model_service_name(service): fields.CharField() for service in services}
# create an instance of base model with the right attributes
return type(BaseModel)(connection_service_name(service), bases, attributes) |
This factory returns an action handler that creates a new instance of
the specified model when a create action is recieved, assuming the
action follows nautilus convetions.
Args:
Model (nautilus.BaseModel): The model to create when the action
received.
Returns:
function(action_type, payload): The action handler for this model
def create_handler(Model, name=None, **kwds):
"""
This factory returns an action handler that creates a new instance of
the specified model when a create action is recieved, assuming the
action follows nautilus convetions.
Args:
Model (nautilus.BaseModel): The model to create when the action
received.
Returns:
function(action_type, payload): The action handler for this model
"""
async def action_handler(service, action_type, payload, props, notify=True, **kwds):
# if the payload represents a new instance of `Model`
if action_type == get_crud_action('create', name or Model):
# print('handling create for ' + name or Model)
try:
# the props of the message
message_props = {}
# if there was a correlation id in the request
if 'correlation_id' in props:
# make sure it ends up in the reply
message_props['correlation_id'] = props['correlation_id']
# for each required field
for requirement in Model.required_fields():
# save the name of the field
field_name = requirement.name
# ensure the value is in the payload
# TODO: check all required fields rather than failing on the first
if not field_name in payload and field_name != 'id':
# yell loudly
raise ValueError(
"Required field not found in payload: %s" %field_name
)
# create a new model
new_model = Model(**payload)
# save the new model instance
new_model.save()
# if we need to tell someone about what happened
if notify:
# publish the scucess event
await service.event_broker.send(
payload=ModelSerializer().serialize(new_model),
action_type=change_action_status(action_type, success_status()),
**message_props
)
# if something goes wrong
except Exception as err:
# if we need to tell someone about what happened
if notify:
# publish the error as an event
await service.event_broker.send(
payload=str(err),
action_type=change_action_status(action_type, error_status()),
**message_props
)
# otherwise we aren't supposed to notify
else:
# raise the exception normally
raise err
# return the handler
return action_handler |
Equality checks are overwitten to perform the actual check in a
semantic way.
async def _has_id(self, *args, **kwds):
"""
Equality checks are overwitten to perform the actual check in a
semantic way.
"""
# if there is only one positional argument
if len(args) == 1:
# parse the appropriate query
result = await parse_string(
self._query,
self.service.object_resolver,
self.service.connection_resolver,
self.service.mutation_resolver,
obey_auth=False
)
# go to the bottom of the result for the list of matching ids
return self._find_id(result['data'], args[0])
# otherwise
else:
# treat the attribute like a normal filter
return self._has_id(**kwds) |
This method performs a depth-first search for the given uid in the dictionary of results.
def _find_id(self, result, uid):
"""
This method performs a depth-first search for the given uid in the dictionary of results.
"""
# if the result is a list
if isinstance(result, list):
# if the list has a valid entry
if any([self._find_id(value, uid) for value in result]):
# then we're done
return True
# otherwise results could be dictionaries
if isinstance(result, dict):
# the children of the result that are lists
list_children = [value for value in result.values() if isinstance(value, list)]
# go to every value that is a list
for value in list_children:
# if the value is a match
if self._find_id(value, uid):
# we're done
return True
# the children of the result that are dicts
dict_children = [value for value in result.values() if isinstance(value, dict)]
# perform the check on every child that is a dict
for value in dict_children:
# if the child is a match
if self._find_id(value, uid):
# we're done
return True
# if there are no values that are lists and there is an id key
if not list_children and not dict_children and 'id' in result:
# the value of the remote id field
result_id = result['id']
# we've found a match if the id field matches (cast to match type)
return result_id == type(result_id)(uid)
# we didn't find the result
return False |
Returns a builder inserting a new block before the current block
def add_before(self):
"""Returns a builder inserting a new block before the current block"""
idx = self._container.structure.index(self)
return BlockBuilder(self._container, idx) |
Returns a builder inserting a new block after the current block
def add_after(self):
"""Returns a builder inserting a new block after the current block"""
idx = self._container.structure.index(self)
return BlockBuilder(self._container, idx+1) |
Creates a comment block
Args:
text (str): content of comment without #
comment_prefix (str): character indicating start of comment
Returns:
self for chaining
def comment(self, text, comment_prefix='#'):
"""Creates a comment block
Args:
text (str): content of comment without #
comment_prefix (str): character indicating start of comment
Returns:
self for chaining
"""
comment = Comment(self._container)
if not text.startswith(comment_prefix):
text = "{} {}".format(comment_prefix, text)
if not text.endswith('\n'):
text = "{}{}".format(text, '\n')
comment.add_line(text)
self._container.structure.insert(self._idx, comment)
self._idx += 1
return self |
Creates a section block
Args:
section (str or :class:`Section`): name of section or object
Returns:
self for chaining
def section(self, section):
"""Creates a section block
Args:
section (str or :class:`Section`): name of section or object
Returns:
self for chaining
"""
if not isinstance(self._container, ConfigUpdater):
raise ValueError("Sections can only be added at section level!")
if isinstance(section, str):
# create a new section
section = Section(section, container=self._container)
elif not isinstance(section, Section):
raise ValueError("Parameter must be a string or Section type!")
if section.name in [block.name for block in self._container
if isinstance(block, Section)]:
raise DuplicateSectionError(section.name)
self._container.structure.insert(self._idx, section)
self._idx += 1
return self |
Creates a vertical space of newlines
Args:
newlines (int): number of empty lines
Returns:
self for chaining
def space(self, newlines=1):
"""Creates a vertical space of newlines
Args:
newlines (int): number of empty lines
Returns:
self for chaining
"""
space = Space()
for line in range(newlines):
space.add_line('\n')
self._container.structure.insert(self._idx, space)
self._idx += 1
return self |
Creates a new option inside a section
Args:
key (str): key of the option
value (str or None): value of the option
**kwargs: are passed to the constructor of :class:`Option`
Returns:
self for chaining
def option(self, key, value=None, **kwargs):
"""Creates a new option inside a section
Args:
key (str): key of the option
value (str or None): value of the option
**kwargs: are passed to the constructor of :class:`Option`
Returns:
self for chaining
"""
if not isinstance(self._container, Section):
raise ValueError("Options can only be added inside a section!")
option = Option(key, value, container=self._container, **kwargs)
option.value = value
self._container.structure.insert(self._idx, option)
self._idx += 1
return self |
Add a Comment object to the section
Used during initial parsing mainly
Args:
line (str): one line in the comment
def add_comment(self, line):
"""Add a Comment object to the section
Used during initial parsing mainly
Args:
line (str): one line in the comment
"""
if not isinstance(self.last_item, Comment):
comment = Comment(self._structure)
self._structure.append(comment)
self.last_item.add_line(line)
return self |
Add a Space object to the section
Used during initial parsing mainly
Args:
line (str): one line that defines the space, maybe whitespaces
def add_space(self, line):
"""Add a Space object to the section
Used during initial parsing mainly
Args:
line (str): one line that defines the space, maybe whitespaces
"""
if not isinstance(self.last_item, Space):
space = Space(self._structure)
self._structure.append(space)
self.last_item.add_line(line)
return self |
Transform to dictionary
Returns:
dict: dictionary with same content
def to_dict(self):
"""Transform to dictionary
Returns:
dict: dictionary with same content
"""
return {key: self.__getitem__(key).value for key in self.options()} |
Set an option for chaining.
Args:
option (str): option name
value (str): value, default None
def set(self, option, value=None):
"""Set an option for chaining.
Args:
option (str): option name
value (str): value, default None
"""
option = self._container.optionxform(option)
if option in self.options():
self.__getitem__(option).value = value
else:
self.__setitem__(option, value)
return self |
Sets the value to a given list of options, e.g. multi-line values
Args:
values (list): list of values
separator (str): separator for values, default: line separator
indent (str): indentation depth in case of line separator
def set_values(self, values, separator='\n', indent=4*' '):
"""Sets the value to a given list of options, e.g. multi-line values
Args:
values (list): list of values
separator (str): separator for values, default: line separator
indent (str): indentation depth in case of line separator
"""
self._updated = True
self._multiline_value_joined = True
self._values = values
if separator == '\n':
values.insert(0, '')
separator = separator + indent
self._value = separator.join(values) |
Read and parse a filename.
Args:
filename (str): path to file
encoding (str): encoding of file, default None
def read(self, filename, encoding=None):
"""Read and parse a filename.
Args:
filename (str): path to file
encoding (str): encoding of file, default None
"""
with open(filename, encoding=encoding) as fp:
self._read(fp, filename)
self._filename = os.path.abspath(filename) |
Update the read-in configuration file.
def update_file(self):
"""Update the read-in configuration file.
"""
if self._filename is None:
raise NoConfigFileReadError()
with open(self._filename, 'w') as fb:
self.write(fb) |
Call ConfigParser to validate config
Args:
kwargs: are passed to :class:`configparser.ConfigParser`
def validate_format(self, **kwargs):
"""Call ConfigParser to validate config
Args:
kwargs: are passed to :class:`configparser.ConfigParser`
"""
args = dict(
dict_type=self._dict,
allow_no_value=self._allow_no_value,
inline_comment_prefixes=self._inline_comment_prefixes,
strict=self._strict,
empty_lines_in_values=self._empty_lines_in_values
)
args.update(kwargs)
parser = ConfigParser(**args)
updated_cfg = str(self)
parser.read_string(updated_cfg) |
Create a new section in the configuration.
Raise DuplicateSectionError if a section by the specified name
already exists. Raise ValueError if name is DEFAULT.
Args:
section (str or :class:`Section`): name or Section type
def add_section(self, section):
"""Create a new section in the configuration.
Raise DuplicateSectionError if a section by the specified name
already exists. Raise ValueError if name is DEFAULT.
Args:
section (str or :class:`Section`): name or Section type
"""
if section in self.sections():
raise DuplicateSectionError(section)
if isinstance(section, str):
# create a new section
section = Section(section, container=self)
elif not isinstance(section, Section):
raise ValueError("Parameter must be a string or Section type!")
self._structure.append(section) |
Returns list of configuration options for the named section.
Args:
section (str): name of section
Returns:
list: list of option names
def options(self, section):
"""Returns list of configuration options for the named section.
Args:
section (str): name of section
Returns:
list: list of option names
"""
if not self.has_section(section):
raise NoSectionError(section) from None
return self.__getitem__(section).options() |
Gets an option value for a given section.
Args:
section (str): section name
option (str): option name
Returns:
:class:`Option`: Option object holding key/value pair
def get(self, section, option):
"""Gets an option value for a given section.
Args:
section (str): section name
option (str): option name
Returns:
:class:`Option`: Option object holding key/value pair
"""
if not self.has_section(section):
raise NoSectionError(section) from None
section = self.__getitem__(section)
option = self.optionxform(option)
try:
value = section[option]
except KeyError:
raise NoOptionError(option, section)
return value |
Return a list of (name, value) tuples for options or sections.
If section is given, return a list of tuples with (name, value) for
each option in the section. Otherwise, return a list of tuples with
(section_name, section_type) for each section.
Args:
section (str): optional section name, default UNSET
Returns:
list: list of :class:`Section` or :class:`Option` objects
def items(self, section=_UNSET):
"""Return a list of (name, value) tuples for options or sections.
If section is given, return a list of tuples with (name, value) for
each option in the section. Otherwise, return a list of tuples with
(section_name, section_type) for each section.
Args:
section (str): optional section name, default UNSET
Returns:
list: list of :class:`Section` or :class:`Option` objects
"""
if section is _UNSET:
return [(sect.name, sect) for sect in self.sections_blocks()]
section = self.__getitem__(section)
return [(opt.key, opt) for opt in section.option_blocks()] |
Checks for the existence of a given option in a given section.
Args:
section (str): name of section
option (str): name of option
Returns:
bool: whether the option exists in the given section
def has_option(self, section, option):
"""Checks for the existence of a given option in a given section.
Args:
section (str): name of section
option (str): name of option
Returns:
bool: whether the option exists in the given section
"""
if section not in self.sections():
return False
else:
option = self.optionxform(option)
return option in self[section] |
Set an option.
Args:
section (str): section name
option (str): option name
value (str): value, default None
def set(self, section, option, value=None):
"""Set an option.
Args:
section (str): section name
option (str): option name
value (str): value, default None
"""
try:
section = self.__getitem__(section)
except KeyError:
raise NoSectionError(section) from None
option = self.optionxform(option)
if option in section:
section[option].value = value
else:
section[option] = value
return self |
Remove an option.
Args:
section (str): section name
option (str): option name
Returns:
bool: whether the option was actually removed
def remove_option(self, section, option):
"""Remove an option.
Args:
section (str): section name
option (str): option name
Returns:
bool: whether the option was actually removed
"""
try:
section = self.__getitem__(section)
except KeyError:
raise NoSectionError(section) from None
option = self.optionxform(option)
existed = option in section.options()
if existed:
del section[option]
return existed |
Remove a file section.
Args:
name: name of the section
Returns:
bool: whether the section was actually removed
def remove_section(self, name):
"""Remove a file section.
Args:
name: name of the section
Returns:
bool: whether the section was actually removed
"""
existed = self.has_section(name)
if existed:
idx = self._get_section_idx(name)
del self._structure[idx]
return existed |
Transform to dictionary
Returns:
dict: dictionary with same content
def to_dict(self):
"""Transform to dictionary
Returns:
dict: dictionary with same content
"""
return {sect: self.__getitem__(sect).to_dict()
for sect in self.sections()} |
This function renders the template desginated by the argument to the
designated directory using the given context.
Args:
template (string) : the source template to use (relative to ./templates)
out_dir (string) : the name of the output directory
context (dict) : the template rendering context
def render_template(template, out_dir='.', context=None):
'''
This function renders the template desginated by the argument to the
designated directory using the given context.
Args:
template (string) : the source template to use (relative to ./templates)
out_dir (string) : the name of the output directory
context (dict) : the template rendering context
'''
# the directory containing templates
template_directory = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'..',
'templates',
template
)
# the files and empty directories to copy
files = []
empty_dirs = []
for (dirpath, _, filenames) in os.walk(template_directory):
# if there are no files in the directory
if len(filenames) == 0:
# add the directory to the list
empty_dirs.append(os.path.relpath(dirpath, template_directory))
# otherwise there are files in this directory
else:
# add the files to the list
files.extend([os.path.join(dirpath, filepath) for filepath in filenames])
# for each template file
for source_file in files:
# open a new file that we are going to write to
with open(source_file, 'r') as file:
# create a template out of the source file contents
template = Template(file.read())
# render the template with the given contents
template_rendered = template.render(**(context or {}))
# the location of the source relative to the template directory
source_relpath = os.path.relpath(source_file, template_directory)
# the target filename
filename = os.path.join(out_dir, source_relpath)
# create a jinja template out of the file path
filename_rendered = Template(filename).render(**context)
# the directory of the target file
source_dir = os.path.dirname(filename_rendered)
# if the directory doesn't exist
if not os.path.exists(source_dir):
# create the directories
os.makedirs(source_dir)
# create the target file
with open(filename_rendered, 'w') as target_file:
# write the rendered template to the target file
target_file.write(template_rendered)
# for each empty directory
for dirpath in empty_dirs:
try:
# dirname
dirname = os.path.join(out_dir, dirpath)
# treat the dirname as a jinja template
dirname_rendered = Template(dirname).render(**context)
# if the directory doesn't exist
if not os.path.exists(dirname_rendered):
# create the directory in the target, replacing the name
os.makedirs(dirname_rendered)
except OSError as exc:
# if the directory already exists
if exc.errno == errno.EEXIST and os.path.isdir(dirpath):
# keep going (noop)
pass
# otherwise its an error we don't handle
else:
# pass it along
raise |
Publish a message with the specified action_type and payload over the
event system. Useful for debugging.
def publish(type, payload):
"""
Publish a message with the specified action_type and payload over the
event system. Useful for debugging.
"""
async def _produce():
# fire an action with the given values
await producer.send(action_type=type, payload=payload)
# notify the user that we were successful
print("Successfully dispatched action with type {}.".format(type))
# create a producer
producer = ActionHandler()
# start the producer
producer.start()
# get the current event loop
loop = asyncio.get_event_loop()
# run the production sequence
loop.run_until_complete(_produce())
# start the producer
producer.stop() |
This factory returns an action handler that deletes a new instance of
the specified model when a delete action is recieved, assuming the
action follows nautilus convetions.
Args:
Model (nautilus.BaseModel): The model to delete when the action
received.
Returns:
function(type, payload): The action handler for this model
def delete_handler(Model, name=None, **kwds):
"""
This factory returns an action handler that deletes a new instance of
the specified model when a delete action is recieved, assuming the
action follows nautilus convetions.
Args:
Model (nautilus.BaseModel): The model to delete when the action
received.
Returns:
function(type, payload): The action handler for this model
"""
# necessary imports
from nautilus.database import db
async def action_handler(service, action_type, payload, props, notify=True, **kwds):
# if the payload represents a new instance of `model`
if action_type == get_crud_action('delete', name or Model):
try:
# the props of the message
message_props = {}
# if there was a correlation id in the request
if 'correlation_id' in props:
# make sure it ends up in the reply
message_props['correlation_id'] = props['correlation_id']
# the id in the payload representing the record to delete
record_id = payload['id'] if 'id' in payload else payload['pk']
# get the model matching the payload
try:
model_query = Model.select().where(Model.primary_key() == record_id)
except KeyError:
raise RuntimeError("Could not find appropriate id to remove service record.")
# remove the model instance
model_query.get().delete_instance()
# if we need to tell someone about what happened
if notify:
# publish the success event
await service.event_broker.send(
payload='{"status":"ok"}',
action_type=change_action_status(action_type, success_status()),
**message_props
)
# if something goes wrong
except Exception as err:
# if we need to tell someone about what happened
if notify:
# publish the error as an event
await service.event_broker.send(
payload=str(err),
action_type=change_action_status(action_type, error_status()),
**message_props
)
# otherwise we aren't supposed to notify
else:
# raise the exception normally
raise err
# return the handler
return action_handler |
This factory returns an action handler that responds to read requests
by resolving the payload as a graphql query against the internal schema.
Args:
Model (nautilus.BaseModel): The model to delete when the action
received.
Returns:
function(type, payload): The action handler for this model
def read_handler(Model, name=None, **kwds):
"""
This factory returns an action handler that responds to read requests
by resolving the payload as a graphql query against the internal schema.
Args:
Model (nautilus.BaseModel): The model to delete when the action
received.
Returns:
function(type, payload): The action handler for this model
"""
async def action_handler(service, action_type, payload, props, **kwds):
# if the payload represents a new instance of `model`
if action_type == get_crud_action('read', name or Model):
# the props of the message
message_props = {}
# if there was a correlation id in the request
if 'correlation_id' in props:
# make sure it ends up in the reply
message_props['correlation_id'] = props['correlation_id']
try:
# resolve the query using the service schema
resolved = service.schema.execute(payload)
# create the string response
response = json.dumps({
'data': {key:value for key,value in resolved.data.items()},
'errors': resolved.errors
})
# publish the success event
await service.event_broker.send(
payload=response,
action_type=change_action_status(action_type, success_status()),
**message_props
)
# if something goes wrong
except Exception as err:
# publish the error as an event
await service.event_broker.send(
payload=str(err),
action_type=change_action_status(action_type, error_status()),
**message_props
)
# return the handler
return action_handler |
This action handler factory reaturns an action handler that
responds to actions with CRUD types (following nautilus conventions)
and performs the necessary mutation on the model's database.
Args:
Model (nautilus.BaseModel): The model to delete when the action
received.
Returns:
function(type, payload): The action handler for this model
def crud_handler(Model, name=None, **kwds):
"""
This action handler factory reaturns an action handler that
responds to actions with CRUD types (following nautilus conventions)
and performs the necessary mutation on the model's database.
Args:
Model (nautilus.BaseModel): The model to delete when the action
received.
Returns:
function(type, payload): The action handler for this model
"""
# import the necessary modules
from nautilus.network.events import combine_action_handlers
from . import update_handler, create_handler, delete_handler, read_handler
# combine them into one handler
return combine_action_handlers(
create_handler(Model, name=name),
read_handler(Model, name=name),
update_handler(Model, name=name),
delete_handler(Model, name=name),
) |
Publish a message with the specified action_type and payload over the
event system. Useful for debugging.
def ask(type, payload):
"""
Publish a message with the specified action_type and payload over the
event system. Useful for debugging.
"""
async def _produce():
# notify the user that we were successful
print("Dispatching action with type {}...".format(type))
# fire an action with the given values
response = await producer.ask(action_type=type, payload=payload)
# show the user the reply
print(response)
# create a producer
producer = ActionHandler()
# start the producer
producer.start()
# get the current event loop
loop = asyncio.get_event_loop()
# run the production sequence
loop.run_until_complete(_produce())
# start the producer
producer.stop() |
This method converts a type into a dict.
def _from_type(self, config):
"""
This method converts a type into a dict.
"""
def is_user_attribute(attr):
return (
not attr.startswith('__') and
not isinstance(getattr(config, attr), collections.abc.Callable)
)
return {attr: getattr(config, attr) for attr in dir(config) \
if is_user_attribute(attr)} |
This function traverses a query and collects the corresponding
information in a dictionary.
async def walk_query(obj, object_resolver, connection_resolver, errors, current_user=None, __naut_name=None, obey_auth=True, **filters):
"""
This function traverses a query and collects the corresponding
information in a dictionary.
"""
# if the object has no selection set
if not hasattr(obj, 'selection_set'):
# yell loudly
raise ValueError("Can only resolve objects, not primitive types")
# the name of the node
node_name = __naut_name or obj.name.value if obj.name else obj.operation
# the selected fields
selection_set = obj.selection_set.selections
def _build_arg_tree(arg):
"""
This function recursively builds the arguments for lists and single values
"""
# TODO: what about object arguments??
# if there is a single value
if hasattr(arg, 'value'):
# assign the value to the filter
return arg.value
# otherwise if there are multiple values for the argument
elif hasattr(arg, 'values'):
return [_build_arg_tree(node) for node in arg.values]
# for each argument on this node
for arg in obj.arguments:
# add it to the query filters
filters[arg.name.value] = _build_arg_tree(arg.value)
# the fields we have to ask for
fields = [field for field in selection_set if not field.selection_set]
# the links between objects
connections = [field for field in selection_set if field.selection_set]
try:
# resolve the model with the given fields
models = await object_resolver(node_name, [field.name.value for field in fields], current_user=current_user, obey_auth=obey_auth, **filters)
# if something went wrong resolving the object
except Exception as e:
# add the error as a string
errors.append(e.__str__())
# stop here
return None
# add connections to each matching model
for model in models:
# if is an id for the model
if 'pk' in model:
# for each connection
for connection in connections:
# the name of the connection
connection_name = connection.name.value
# the target of the connection
node = {
'name': node_name,
'pk': model['pk']
}
try:
# go through the connection
connected_ids, next_target = await connection_resolver(
connection_name,
node,
)
# if there are connections
if connected_ids:
# add the id filter to the list
filters['pk_in'] = connected_ids
# add the connection field
value = await walk_query(
connection,
object_resolver,
connection_resolver,
errors,
current_user=current_user,
obey_auth=obey_auth,
__naut_name=next_target,
**filters
)
# there were no connections
else:
value = []
# if something went wrong
except Exception as e:
# add the error as a string
errors.append(e.__str__())
# stop here
value = None
# set the connection to the appropriate value
model[connection_name] = value
# return the list of matching models
return models |
This action handler interprets the payload as a query to be executed
by the api gateway service.
async def query_handler(service, action_type, payload, props, **kwds):
"""
This action handler interprets the payload as a query to be executed
by the api gateway service.
"""
# check that the action type indicates a query
if action_type == query_action_type():
print('encountered query event {!r} '.format(payload))
# perform the query
result = await parse_string(payload,
service.object_resolver,
service.connection_resolver,
service.mutation_resolver,
obey_auth=False
)
# the props for the reply message
reply_props = {'correlation_id': props['correlation_id']} if 'correlation_id' in props else {}
# publish the success event
await service.event_broker.send(
payload=result,
action_type=change_action_status(action_type, success_status()),
**reply_props
) |
This function returns the standard summary for mutations inputs
and outputs
def summarize_mutation_io(name, type, required=False):
"""
This function returns the standard summary for mutations inputs
and outputs
"""
return dict(
name=name,
type=type,
required=required
) |
This function returns the name of a mutation that performs the specified
crud action on the given model service
def crud_mutation_name(action, model):
"""
This function returns the name of a mutation that performs the specified
crud action on the given model service
"""
model_string = get_model_string(model)
# make sure the mutation name is correctly camelcases
model_string = model_string[0].upper() + model_string[1:]
# return the mutation name
return "{}{}".format(action, model_string) |
Args:
service : The service being created by the mutation
Returns:
(list) : a list of all of the fields availible for the service,
with the required ones respected.
def create_mutation_inputs(service):
"""
Args:
service : The service being created by the mutation
Returns:
(list) : a list of all of the fields availible for the service,
with the required ones respected.
"""
# grab the default list of field summaries
inputs = _service_mutation_summaries(service)
# make sure the pk isn't in the list
inputs.remove([field for field in inputs if field['name'] == 'id'][0])
# return the final list
return inputs |
Args:
service : The service being updated by the mutation
Returns:
(list) : a list of all of the fields availible for the service. Pk
is a required field in order to filter the results
def update_mutation_inputs(service):
"""
Args:
service : The service being updated by the mutation
Returns:
(list) : a list of all of the fields availible for the service. Pk
is a required field in order to filter the results
"""
# grab the default list of field summaries
inputs = _service_mutation_summaries(service)
# visit each field
for field in inputs:
# if we're looking at the id field
if field['name'] == 'id':
# make sure its required
field['required'] = True
# but no other field
else:
# is required
field['required'] = False
# return the final list
return inputs |
Args:
service : The service being deleted by the mutation
Returns:
([str]): the only input for delete is the pk of the service.
def delete_mutation_inputs(service):
"""
Args:
service : The service being deleted by the mutation
Returns:
([str]): the only input for delete is the pk of the service.
"""
from nautilus.api.util import summarize_mutation_io
# the only input for delete events is the pk of the service record
return [summarize_mutation_io(name='pk', type='ID', required=True)] |
This function create the actual mutation io summary corresponding to the model
def _summarize_o_mutation_type(model):
"""
This function create the actual mutation io summary corresponding to the model
"""
from nautilus.api.util import summarize_mutation_io
# compute the appropriate name for the object
object_type_name = get_model_string(model)
# return a mutation io object
return summarize_mutation_io(
name=object_type_name,
type=_summarize_object_type(model),
required=False
) |
This function returns the summary for a given model
def _summarize_object_type(model):
"""
This function returns the summary for a given model
"""
# the fields for the service's model
model_fields = {field.name: field for field in list(model.fields())}
# summarize the model
return {
'fields': [{
'name': key,
'type': type(convert_peewee_field(value)).__name__
} for key, value in model_fields.items()
]
} |
This function combines the given action handlers into a single function
which will call all of them.
def combine_action_handlers(*handlers):
"""
This function combines the given action handlers into a single function
which will call all of them.
"""
# make sure each of the given handlers is callable
for handler in handlers:
# if the handler is not a function
if not (iscoroutinefunction(handler) or iscoroutine(handler)):
# yell loudly
raise ValueError("Provided handler is not a coroutine: %s" % handler)
# the combined action handler
async def combined_handler(*args, **kwds):
# goes over every given handler
for handler in handlers:
# call the handler
await handler(*args, **kwds)
# return the combined action handler
return combined_handler |
This factory returns an action handler that updates a new instance of
the specified model when a update action is recieved, assuming the
action follows nautilus convetions.
Args:
Model (nautilus.BaseModel): The model to update when the action
received.
Returns:
function(type, payload): The action handler for this model
def update_handler(Model, name=None, **kwds):
"""
This factory returns an action handler that updates a new instance of
the specified model when a update action is recieved, assuming the
action follows nautilus convetions.
Args:
Model (nautilus.BaseModel): The model to update when the action
received.
Returns:
function(type, payload): The action handler for this model
"""
async def action_handler(service, action_type, payload, props, notify=True, **kwds):
# if the payload represents a new instance of `Model`
if action_type == get_crud_action('update', name or Model):
try:
# the props of the message
message_props = {}
# if there was a correlation id in the request
if 'correlation_id' in props:
# make sure it ends up in the reply
message_props['correlation_id'] = props['correlation_id']
# grab the nam eof the primary key for the model
pk_field = Model.primary_key()
# make sure there is a primary key to id the model
if not pk_field.name in payload:
# yell loudly
raise ValueError("Must specify the pk of the model when updating")
# grab the matching model
model = Model.select().where(pk_field == payload[pk_field.name]).get()
# remove the key from the payload
payload.pop(pk_field.name, None)
# for every key,value pair
for key, value in payload.items():
# TODO: add protection for certain fields from being
# changed by the api
setattr(model, key, value)
# save the updates
model.save()
# if we need to tell someone about what happened
if notify:
# publish the scucess event
await service.event_broker.send(
payload=ModelSerializer().serialize(model),
action_type=change_action_status(action_type, success_status()),
**message_props
)
# if something goes wrong
except Exception as err:
# if we need to tell someone about what happened
if notify:
# publish the error as an event
await service.event_broker.send(
payload=str(err),
action_type=change_action_status(action_type, error_status()),
**message_props
)
# otherwise we aren't supposed to notify
else:
# raise the exception normally
raise err
# return the handler
return action_handler |
This function returns a graphql mutation corresponding to the provided
summary.
def graphql_mutation_from_summary(summary):
"""
This function returns a graphql mutation corresponding to the provided
summary.
"""
# get the name of the mutation from the summary
mutation_name = summary['name']
# print(summary)
# the treat the "type" string as a gra
input_name = mutation_name + "Input"
input_fields = build_native_type_dictionary(summary['inputs'], name=input_name, respect_required=True)
# the inputs for the mutation are defined by a class record
inputs = type('Input', (object,), input_fields)
# the outputs for the mutation are attributes to the class record
output_name = mutation_name + "Output"
outputs = build_native_type_dictionary(summary['outputs'], name=output_name)
# a no-op in order to satisfy the introspection query
mutate = classmethod(lambda *_, **__ : 'hello')
# create the appropriate mutation class record
mutation = type(mutation_name, (graphene.Mutation,), {
'Input': inputs,
'mutate': mutate,
**outputs
})
# return the newly created mutation record
return mutation |
This function takes a series of ditionaries and creates an argument
string for a graphql query
def arg_string_from_dict(arg_dict, **kwds):
"""
This function takes a series of ditionaries and creates an argument
string for a graphql query
"""
# the filters dictionary
filters = {
**arg_dict,
**kwds,
}
# return the correctly formed string
return ", ".join("{}: {}".format(key, json.dumps(value)) for key,value in filters.items()) |
This function creates a graphql schema that provides a single model
def create_model_schema(target_model):
""" This function creates a graphql schema that provides a single model """
from nautilus.database import db
# create the schema instance
schema = graphene.Schema(auto_camelcase=False)
# grab the primary key from the model
primary_key = target_model.primary_key()
primary_key_type = convert_peewee_field(primary_key)
# create a graphene object
class ModelObjectType(PeeweeObjectType):
class Meta:
model = target_model
pk = Field(primary_key_type, description="The primary key for this object.")
@graphene.resolve_only_args
def resolve_pk(self):
return getattr(self, self.primary_key().name)
class Query(graphene.ObjectType):
""" the root level query """
all_models = List(ModelObjectType, args=args_for_model(target_model))
@graphene.resolve_only_args
def resolve_all_models(self, **args):
# filter the model query according to the arguments
# print(filter_model(target_model, args)[0].__dict__)
return filter_model(target_model, args)
# add the query to the schema
schema.query = Query
return schema |
the name of a service that manages the connection between services
def connection_service_name(service, *args):
''' the name of a service that manages the connection between services '''
# if the service is a string
if isinstance(service, str):
return service
return normalize_string(type(service).__name__) |
This function verifies the token using the secret key and returns its
contents.
def read_session_token(secret_key, token):
"""
This function verifies the token using the secret key and returns its
contents.
"""
return jwt.decode(token.encode('utf-8'), secret_key,
algorithms=[token_encryption_algorithm()]
) |
The default action Handler has no action.
async def handle_action(self, action_type, payload, **kwds):
"""
The default action Handler has no action.
"""
# if there is a service attached to the action handler
if hasattr(self, 'service'):
# handle roll calls
await roll_call_handler(self.service, action_type, payload, **kwds) |
This method is used to announce the existence of the service
async def announce(self):
"""
This method is used to announce the existence of the service
"""
# send a serialized event
await self.event_broker.send(
action_type=intialize_service_action(),
payload=json.dumps(self.summarize())
) |
This function starts the service's network intefaces.
Args:
port (int): The port for the http server.
def run(self, host="localhost", port=8000, shutdown_timeout=60.0, **kwargs):
"""
This function starts the service's network intefaces.
Args:
port (int): The port for the http server.
"""
print("Running service on http://localhost:%i. " % port + \
"Press Ctrl+C to terminate.")
# apply the configuration to the service config
self.config.port = port
self.config.host = host
# start the loop
try:
# if an event broker has been created for this service
if self.event_broker:
# start the broker
self.event_broker.start()
# announce the service
self.loop.run_until_complete(self.announce())
# the handler for the http server
http_handler = self.app.make_handler()
# create an asyncio server
self._http_server = self.loop.create_server(http_handler, host, port)
# grab the handler for the server callback
self._server_handler = self.loop.run_until_complete(self._http_server)
# start the event loop
self.loop.run_forever()
# if the user interrupted the server
except KeyboardInterrupt:
# keep going
pass
# when we're done
finally:
try:
# clean up the service
self.cleanup()
# if we end up closing before any variables get assigned
except UnboundLocalError:
# just ignore it (there was nothing to close)
pass
# close the event loop
self.loop.close() |
This function is called when the service has finished running
regardless of intentionally or not.
def cleanup(self):
"""
This function is called when the service has finished running
regardless of intentionally or not.
"""
# if an event broker has been created for this service
if self.event_broker:
# stop the event broker
self.event_broker.stop()
# attempt
try:
# close the http server
self._server_handler.close()
self.loop.run_until_complete(self._server_handler.wait_closed())
self.loop.run_until_complete(self._http_handler.finish_connections(shutdown_timeout))
# if there was no handler
except AttributeError:
# keep going
pass
# more cleanup
self.loop.run_until_complete(self.app.shutdown())
self.loop.run_until_complete(self.app.cleanup()) |
This method provides a programatic way of added invidual routes
to the http server.
Args:
url (str): the url to be handled by the request_handler
request_handler (nautilus.network.RequestHandler): The request handler
def add_http_endpoint(self, url, request_handler):
"""
This method provides a programatic way of added invidual routes
to the http server.
Args:
url (str): the url to be handled by the request_handler
request_handler (nautilus.network.RequestHandler): The request handler
"""
self.app.router.add_route('*', url, request_handler) |
This method provides a decorator for adding endpoints to the
http server.
Args:
route (str): The url to be handled by the RequestHandled
config (dict): Configuration for the request handler
Example:
.. code-block:: python
import nautilus
from nauilus.network.http import RequestHandler
class MyService(nautilus.Service):
# ...
@MyService.route('/')
class HelloWorld(RequestHandler):
def get(self):
return self.finish('hello world')
def route(cls, route, config=None):
"""
This method provides a decorator for adding endpoints to the
http server.
Args:
route (str): The url to be handled by the RequestHandled
config (dict): Configuration for the request handler
Example:
.. code-block:: python
import nautilus
from nauilus.network.http import RequestHandler
class MyService(nautilus.Service):
# ...
@MyService.route('/')
class HelloWorld(RequestHandler):
def get(self):
return self.finish('hello world')
"""
def decorator(wrapped_class, **kwds):
# add the endpoint at the given route
cls._routes.append(
dict(url=route, request_handler=wrapped_class)
)
# return the class undecorated
return wrapped_class
# return the decorator
return decorator |
This function generates a session token signed by the secret key which
can be used to extract the user credentials in a verifiable way.
def generate_session_token(secret_key, **payload):
"""
This function generates a session token signed by the secret key which
can be used to extract the user credentials in a verifiable way.
"""
return jwt.encode(payload, secret_key, algorithm=token_encryption_algorithm()).decode('utf-8') |
This function provides a standard representation of mutations to be
used when services announce themselves
def summarize_mutation(mutation_name, event, inputs, outputs, isAsync=False):
"""
This function provides a standard representation of mutations to be
used when services announce themselves
"""
return dict(
name=mutation_name,
event=event,
isAsync=isAsync,
inputs=inputs,
outputs=outputs,
) |
Creates a PasswordHash from the given password.
def new(cls, password, rounds):
"""Creates a PasswordHash from the given password."""
if isinstance(password, str):
password = password.encode('utf-8')
return cls(cls._new(password, rounds)) |
Ensure that loaded values are PasswordHashes.
def coerce(cls, key, value):
"""Ensure that loaded values are PasswordHashes."""
if isinstance(value, PasswordHash):
return value
return super(PasswordHash, cls).coerce(key, value) |
Recreates the internal hash.
def rehash(self, password):
"""Recreates the internal hash."""
self.hash = self._new(password, self.desired_rounds)
self.rounds = self.desired_rounds |
This function configures the database used for models to make
the configuration parameters.
def init_db(self):
"""
This function configures the database used for models to make
the configuration parameters.
"""
# get the database url from the configuration
db_url = self.config.get('database_url', 'sqlite:///nautilus.db')
# configure the nautilus database to the url
nautilus.database.init_db(db_url) |
This attribute provides the mapping of services to their auth requirement
Returns:
(dict) : the mapping from services to their auth requirements.
def auth_criteria(self):
"""
This attribute provides the mapping of services to their auth requirement
Returns:
(dict) : the mapping from services to their auth requirements.
"""
# the dictionary we will return
auth = {}
# go over each attribute of the service
for attr in dir(self):
# make sure we could hit an infinite loop
if attr != 'auth_criteria':
# get the actual attribute
attribute = getattr(self, attr)
# if the service represents an auth criteria
if isinstance(attribute, Callable) and hasattr(attribute, '_service_auth'):
# add the criteria to the final results
auth[getattr(self, attr)._service_auth] = attribute
# return the auth mapping
return auth |
This function handles the registration of the given user credentials in the database
async def login_user(self, password, **kwds):
"""
This function handles the registration of the given user credentials in the database
"""
# find the matching user with the given email
user_data = (await self._get_matching_user(fields=list(kwds.keys()), **kwds))['data']
try:
# look for a matching entry in the local database
passwordEntry = self.model.select().where(
self.model.user == user_data[root_query()][0]['pk']
)[0]
# if we couldn't acess the id of the result
except (KeyError, IndexError) as e:
# yell loudly
raise RuntimeError('Could not find matching registered user')
# if the given password matches the stored hash
if passwordEntry and passwordEntry.password == password:
# the remote entry for the user
user = user_data[root_query()][0]
# then return a dictionary with the user and sessionToken
return {
'user': user,
'sessionToken': self._user_session_token(user)
}
# otherwise the passwords don't match
raise RuntimeError("Incorrect credentials") |
This function is used to provide a sessionToken for later requests.
Args:
uid (str): The
async def register_user(self, password, **kwds):
"""
This function is used to provide a sessionToken for later requests.
Args:
uid (str): The
"""
# so make one
user = await self._create_remote_user(password=password, **kwds)
# if there is no pk field
if not 'pk' in user:
# make sure the user has a pk field
user['pk'] = user['id']
# the query to find a matching query
match_query = self.model.user == user['id']
# if the user has already been registered
if self.model.select().where(match_query).count() > 0:
# yell loudly
raise RuntimeError('The user is already registered.')
# create an entry in the user password table
password = self.model(user=user['id'], password=password)
# save it to the database
password.save()
# return a dictionary with the user we created and a session token for later use
return {
'user': user,
'sessionToken': self._user_session_token(user)
} |
This function resolves a given object in the remote backend services
async def object_resolver(self, object_name, fields, obey_auth=False, current_user=None, **filters):
"""
This function resolves a given object in the remote backend services
"""
try:
# check if an object with that name has been registered
registered = [model for model in self._external_service_data['models'] \
if model['name']==object_name][0]
# if there is no connection data yet
except AttributeError:
raise ValueError("No objects are registered with this schema yet.")
# if we dont recognize the model that was requested
except IndexError:
raise ValueError("Cannot query for object {} on this service.".format(object_name))
# the valid fields for this object
valid_fields = [field['name'] for field in registered['fields']]
# figure out if any invalid fields were requested
invalid_fields = [field for field in fields if field not in valid_fields]
try:
# make sure we never treat pk as invalid
invalid_fields.remove('pk')
# if they weren't asking for pk as a field
except ValueError:
pass
# if there were
if invalid_fields:
# yell loudly
raise ValueError("Cannot query for fields {!r} on {}".format(
invalid_fields, registered['name']
))
# make sure we include the id in the request
fields.append('pk')
# the query for model records
query = query_for_model(fields, **filters)
# the action type for the question
action_type = get_crud_action('read', object_name)
# query the appropriate stream for the information
response = await self.event_broker.ask(
action_type=action_type,
payload=query
)
# treat the reply like a json object
response_data = json.loads(response)
# if something went wrong
if 'errors' in response_data and response_data['errors']:
# return an empty response
raise ValueError(','.join(response_data['errors']))
# grab the valid list of matches
result = response_data['data'][root_query()]
# grab the auth handler for the object
auth_criteria = self.auth_criteria.get(object_name)
# if we care about auth requirements and there is one for this object
if obey_auth and auth_criteria:
# build a second list of authorized entries
authorized_results = []
# for each query result
for query_result in result:
# create a graph entity for the model
graph_entity = GraphEntity(self, model_type=object_name, id=query_result['pk'])
# if the auth handler passes
if await auth_criteria(model=graph_entity, user_id=current_user):
# add the result to the final list
authorized_results.append(query_result)
# overwrite the query result
result = authorized_results
# apply the auth handler to the result
return result |
the default behavior for mutations is to look up the event,
publish the correct event type with the args as the body,
and return the fields contained in the result
async def mutation_resolver(self, mutation_name, args, fields):
"""
the default behavior for mutations is to look up the event,
publish the correct event type with the args as the body,
and return the fields contained in the result
"""
try:
# make sure we can identify the mutation
mutation_summary = [mutation for mutation in \
self._external_service_data['mutations'] \
if mutation['name'] == mutation_name][0]
# if we couldn't get the first entry in the list
except KeyError as e:
# make sure the error is reported
raise ValueError("Could not execute mutation named: " + mutation_name)
# the function to use for running the mutation depends on its schronicity
# event_function = self.event_broker.ask \
# if mutation_summary['isAsync'] else self.event_broker.send
event_function = self.event_broker.ask
# send the event and wait for a response
value = await event_function(
action_type=mutation_summary['event'],
payload=args
)
try:
# return a dictionary with the values we asked for
return json.loads(value)
# if the result was not valid json
except json.decoder.JSONDecodeError:
# just throw the value
raise RuntimeError(value) |
This function checks if there is a user with the same uid in the
remote user service
Args:
**kwds : the filters of the user to check for
Returns:
(bool): wether or not there is a matching user
async def _check_for_matching_user(self, **user_filters):
"""
This function checks if there is a user with the same uid in the
remote user service
Args:
**kwds : the filters of the user to check for
Returns:
(bool): wether or not there is a matching user
"""
# there is a matching user if there are no errors and no results from
user_data = self._get_matching_user(user_filters)
# return true if there were no errors and at lease one result
return not user_data['errors'] and len(user_data['data'][root_query()]) |
This method creates a service record in the remote user service
with the given email.
Args:
uid (str): the user identifier to create
Returns:
(dict): a summary of the user that was created
async def _create_remote_user(self, **payload):
"""
This method creates a service record in the remote user service
with the given email.
Args:
uid (str): the user identifier to create
Returns:
(dict): a summary of the user that was created
"""
# the action for reading user entries
read_action = get_crud_action(method='create', model='user')
# see if there is a matching user
user_data = await self.event_broker.ask(
action_type=read_action,
payload=payload
)
# treat the reply like a json object
return json.loads(user_data) |
Calculation of WER with Levenshtein distance.
Works only for iterables up to 254 elements (uint8).
O(nm) time and space complexity.
>>> calculate_wer("who is there".split(), "is there".split())
1
>>> calculate_wer("who is there".split(), "".split())
3
>>> calculate_wer("".split(), "who is there".split())
3
def calculate_wer(reference, hypothesis):
"""
Calculation of WER with Levenshtein distance.
Works only for iterables up to 254 elements (uint8).
O(nm) time and space complexity.
>>> calculate_wer("who is there".split(), "is there".split())
1
>>> calculate_wer("who is there".split(), "".split())
3
>>> calculate_wer("".split(), "who is there".split())
3
"""
# initialisation
import numpy
d = numpy.zeros((len(reference)+1)*(len(hypothesis)+1), dtype=numpy.uint8)
d = d.reshape((len(reference)+1, len(hypothesis)+1))
for i in range(len(reference)+1):
for j in range(len(hypothesis)+1):
if i == 0:
d[0][j] = j
elif j == 0:
d[i][0] = i
# computation
for i in range(1, len(reference)+1):
for j in range(1, len(hypothesis)+1):
if reference[i-1] == hypothesis[j-1]:
d[i][j] = d[i-1][j-1]
else:
substitution = d[i-1][j-1] + 1
insertion = d[i][j-1] + 1
deletion = d[i-1][j] + 1
d[i][j] = min(substitution, insertion, deletion)
return d[len(reference)][len(hypothesis)]/float(len(reference)) |
Get a parser object
def get_parser():
"""Get a parser object"""
from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
parser = ArgumentParser(description=__doc__,
formatter_class=ArgumentDefaultsHelpFormatter)
parser.add_argument("-s1", dest="s1", help="sequence 1")
parser.add_argument("-s2", dest="s2", help="sequence 2")
return parser |
Perform a GET web request and return a bs4 parser
async def _async_request_soup(url):
'''
Perform a GET web request and return a bs4 parser
'''
from bs4 import BeautifulSoup
import aiohttp
_LOGGER.debug('GET %s', url)
async with aiohttp.ClientSession() as session:
resp = await session.get(url)
text = await resp.text()
return BeautifulSoup(text, 'html.parser') |
Check whether the current channel is correct. If not try to determine it
using fuzzywuzzy
async def async_determine_channel(channel):
'''
Check whether the current channel is correct. If not try to determine it
using fuzzywuzzy
'''
from fuzzywuzzy import process
channel_data = await async_get_channels()
if not channel_data:
_LOGGER.error('No channel data. Cannot determine requested channel.')
return
channels = [c for c in channel_data.get('data', {}).keys()]
if channel in channels:
return channel
else:
res = process.extractOne(channel, channels)[0]
_LOGGER.debug('No direct match found for %s. Resort to guesswork.'
'Guessed %s', channel, res)
return res |
Get channel list and corresponding urls
async def async_get_channels(no_cache=False, refresh_interval=4):
'''
Get channel list and corresponding urls
'''
# Check cache
now = datetime.datetime.now()
max_cache_age = datetime.timedelta(hours=refresh_interval)
if not no_cache and 'channels' in _CACHE:
cache = _CACHE.get('channels')
cache_age = cache.get('last_updated')
if now - cache_age < max_cache_age:
_LOGGER.debug('Found channel list in cache.')
return cache
else:
_LOGGER.debug('Found outdated channel list in cache. Update it.')
_CACHE.pop('channels')
soup = await _async_request_soup(BASE_URL + '/plan.html')
channels = {}
for li_item in soup.find_all('li'):
try:
child = li_item.findChild()
if not child or child.name != 'a':
continue
href = child.get('href')
if not href or not href.startswith('/programme/chaine'):
continue
channels[child.get('title')] = BASE_URL + href
except Exception as exc:
_LOGGER.error('Exception occured while fetching the channel '
'list: %s', exc)
if channels:
_CACHE['channels'] = {'last_updated': now, 'data': channels}
return _CACHE['channels'] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.