def make_geo_stub(self, data: typing.Dict,
**kwargs) -> test_models.GeoStub:
return test_models.GeoStub(
geo_stub_id=data.pop("geo_stub_id"),
longitude=data.pop("longitude"),
latitude=data.pop("latitude"),
)
def make_trip(self, data: typing.Dict, **kwargs) -> mbta_models.Trip:
return mbta_models.Trip(
trip_id=data.pop("trip_id"),
route_id=data.pop("route_id"),
service_id=data.pop("service_id"),
**data,
)
def validate_options(self, raw_options: DictType) -> bool:
"""
At this point, raw_options is basically taken directly from the Command kwargs
raw_options *can* be modified in place
Raise errors/warnings based on the initial kwarg values; implement in each class
"""
if raw_options.get("color_list") and raw_options.get("color_scheme"):
raise ConflictingArgs(
"--color-list and --color-scheme cannot both be specified.")
if raw_options.get("color_scheme"):
if not raw_options.get("colorvar"):
self.warnings.append(
f"--colorvar was not specified, so --color-scheme is ignored."
)
else:
cs = raw_options.get("color_scheme")
if not self.validate_color_scheme(cs):
self.warnings.append(
f"Using default color scheme because --color-scheme argument '{cs}' does not seem to be a valid color scheme. Run `csvviz info colorschemes` to get a list of valid color schemes."
)
raw_options.pop("color_scheme")
return True
async def perform_action(self, link: typing.Dict) -> int:
"""
Perform a link in the context of an operation, respecting the 'run', 'paused' and 'run_one_step' operation
states. Calling data_svc.create('core_chain', link) directly will schedule the link for execution,
ignoring the state of the operation.
:param link:
:return: the id of the created link
"""
operation_svc = self.get_service('operation_svc')
op_id = link['op_id']
operation = (await self.data_svc.dao.get('core_operation',
dict(id=op_id)))[0]
while operation['state'] != operation_svc.op_states['RUNNING']:
if operation['state'] == operation_svc.op_states['RUN_ONE_LINK']:
link_id = await self.data_svc.create_link(link)
await self.data_svc.dao.update(
'core_operation', 'id', op_id,
dict(state=operation_svc.op_states['PAUSED']))
return link_id
else:
await asyncio.sleep(30)
operation = (await
self.data_svc.dao.get('core_operation',
dict(id=op_id)))[0]
link.pop('adversary_map_id')
return await self.data_svc.create_link(link)
def make_route_pattern(self, data: typing.Dict,
**kwargs) -> mbta_models.RoutePattern:
return mbta_models.RoutePattern(
route_pattern_id=data.pop("route_pattern_id"),
route_id=data.pop("route_id"),
**data,
)
def get_occurences(
search: str, value: str, check: bool, key: str, d: t.Dict
) -> t.Dict:
len_search = len(search)
len_value = len(value)
# If the search is longer than the text we are searching it's pointless
if len_search > len_value:
d.pop(search, None)
return d
occ_count = MoneyStringConverter.find_count(search, value)
if check and len(occ_count) > 0:
for idx, o in enumerate(occ_count):
similarKeys = []
for k in key:
z = d.get(k)
if z:
similarKeys.extend(z)
if o in similarKeys:
occ_count.pop(idx)
if occ_count == []:
d.pop(search, None)
return d
d[search] = occ_count
return d
def make_stop(self, data: typing.Dict, **kwargs) -> mbta_models.Stop:
try:
lon = data.pop("stop_lon")
lat = data.pop("stop_lat")
data["stop_lonlat"] = f"POINT({lon} {lat})"
except KeyError:
pass
return mbta_models.Stop(data.pop("stop_id"), **data)
async def receive_json(self, content: typing.Dict, **kwargs):
"""
Called with decoded JSON content.
"""
# TODO assert format, if does not match return message.
request_id = content.pop("request_id")
action = content.pop("action")
await self.handle_action(action, request_id=request_id, **content)
def make_calendar_date(self, data: typing.Dict,
**kwargs) -> mbta_models.CalendarDate:
return mbta_models.CalendarDate(
data.pop("service_id"),
data.pop("date"),
data.pop("exception_type"),
**data,
)
def make_direction(self, data: typing.Dict,
**kwargs) -> mbta_models.Direction:
return mbta_models.Direction(
route_id=data.pop("route_id"),
direction_id=data.pop("direction_id"),
direction=data.pop("direction"),
direction_destination=data.pop("direction_destination"),
)
def make_shape(self, data: typing.Dict, **kwargs) -> mbta_models.Shape:
return mbta_models.Shape(
data.pop("shape_id"),
data.pop("shape_pt_lon"),
data.pop("shape_pt_lat"),
data.pop("shape_pt_sequence"),
**data,
)
def make_agency(self, data: typing.Dict, **kwargs) -> mbta_models.Agency:
return mbta_models.Agency(
data.pop("agency_id"),
data.pop("agency_name"),
data.pop("agency_url"),
data.pop("agency_timezone"),
**data,
)
def insert(self, record: typing.Dict) -> typing.Dict:
try:
record = self._record_to_id(record)
if record['_id'] is None:
record.pop('_id')
self.collection.insert_one(record)
except DuplicateKeyError:
raise DuplicateError('Duplicate record')
return self._record_from_id(record)
def from_record(record: typing.Dict) -> HighScore:
skills = {
name: Skill(**skill_dict)
for name, skill_dict in record.pop('skills').items()
}
if 'xp_sum' in record:
record.pop('xp_sum')
record.update(skills)
return HighScore(**record)
def make_route(self, data: typing.Dict, **kwargs) -> mbta_models.Route:
return mbta_models.Route(
data.pop("route_id"),
data.pop("agency_id"),
data.pop("route_long_name"),
data.pop("route_type"),
data.pop("listed_route"),
**data,
)
def make_linked_dataset(self, data: typing.Dict,
**kwargs) -> mbta_models.LinkedDataset:
return mbta_models.LinkedDataset(
url=data.pop("url"),
trip_updates=data.pop("trip_updates"),
vehicle_positions=data.pop("vehicle_positions"),
service_alerts=data.pop("service_alerts"),
authentication_type=data.pop("authentication_type"),
)
def make_calendar_attribute(self, data: typing.Dict,
**kwargs) -> mbta_models.CalendarAttribute:
return mbta_models.CalendarAttribute(
data.pop("service_id"),
data.pop("service_description"),
data.pop("service_schedule_name"),
data.pop("service_schedule_type"),
**data,
)
def make_stop_time(self, data: typing.Dict,
**kwargs) -> mbta_models.StopTime:
return mbta_models.StopTime(
trip_id=data.pop("trip_id"),
arrival_time=data.pop("arrival_time"),
departure_time=data.pop("departure_time"),
stop_id=data.pop("stop_id"),
stop_sequence=data.pop("stop_sequence"),
**data,
)
def make_calendar(self, data: typing.Dict,
**kwargs) -> mbta_models.Calendar:
return mbta_models.Calendar(
data.pop("service_id"),
data.pop("monday"),
data.pop("tuesday"),
data.pop("wednesday"),
data.pop("thursday"),
data.pop("friday"),
data.pop("saturday"),
data.pop("sunday"),
data.pop("start_date"),
data.pop("end_date"),
)
def __init__(self, Model: django.db.models.Model, kwargs: ty.Dict):
self.first = kwargs.pop("first", settings.PAGINATION_SIZE)
self.after = kwargs.pop("after", None)
self.before = kwargs.pop("before", None)
self.sort_by = kwargs.pop("sortBy", None)
self.sort_direction = kwargs.pop("sortDirection", "desc")
assert self.sort_direction in DjangoQuery.VALID_SORT_DIRECTIONS
self.filters = kwargs
self.get_total = False
self.get_has_next_page = False
self._model = Model
self.objs = self._model.objects
self._query_fields = None
def emit_cud_locally(cls, resource_name: str, payload: typing.Dict):
"""Performs a CUD action in the Model class that was previously
subscribed to CUD changes using the same resource_name"""
model_class: Model = cls.map_event_to_model_class.get(
resource_name, None)
if not model_class:
# In case the service is subscribed to
# the CUD event using an event handler
cls.emit_locally(resource_name, payload)
return
# Remove field that's not part of the ObjectModel class
object_id = payload['id']
cud_operation = payload.pop('cud_operation')
if cud_operation == CudEvent.DELETED:
model_class.objects.filter(pk=object_id).delete()
else:
try:
model_instance: ObjectModel = model_class.objects.get(
pk=object_id, )
except model_class.DoesNotExist:
model_instance: ObjectModel = model_class(pk=object_id)
# This is the way that DRF uses for updating models
for attr, value in payload.items():
setattr(model_instance, attr, value)
model_instance.save()
async def resolve_create(_, info, input: ty.Dict):
# TODO- Actually fill this out properly
response = {
"error": False,
"message": "Create Successfull!",
"node": None
}
try:
id = str(uuid.uuid4())
password = input.pop("password")
avatar_bytes = Identicon(id).identicon
key, presigned_url = settings.S3_CLIENT.generate_presigned_url(
bucket="",
key="",
content_type="image/png",
method="",
)
requests.put(presigned_url,
data=avatar_bytes,
headers={"Content-Type": "image/png"})
permission_group = PermissionGroup.objects.get(name="")
inst = User.objects.create(
**{
**input, "id": id,
"password": generate_hashed_password(password),
"avatar": S3FieldObject(location="", bucket="", key=""),
"permission_group": permission_group
})
inst.save()
return {**response, "node": inst}
except Exception as err:
return {
**response, "error": True,
"message": f"Create Error: {err}"
}
def _resolve_release(
self,
message_types: typing.List[typing.Dict],
release: typing.Dict,
templates: typing.Dict[str, jinja2.Template],
) -> str:
groups = {}
for group_name, group in release.pop("entries", {}).items():
groups[group_name] = [
self._resolve_entry(entry, templates["entry"])
for entry in group
]
release["entry_groups"] = []
for message_type in message_types:
name = message_type.get("name")
title = message_type.get("title", name)
if name in groups:
release["entry_groups"].append({
"name": name,
"title": title,
"entries": groups.get(name)
})
template = templates["release"]
return template.render(**self._config.get_context(), **release)
def remove_empty_fields(d: typing.Dict) -> typing.Dict:
"""
Recursively remove empty collections and Nones from dict
"""
if d is None:
return None
# stash keys because we can't change a dict while iterating
# using keys()
keys = list(d.keys())
for k in keys:
v = d[k]
if isinstance(v, dict):
remove_empty_fields(v)
if v is None or v == {} or v == []:
d.pop(k)
return d
async def resolve_update(_, info, id: str, input: ty.Dict):
response = {
"error": False,
"message": "Create Successfull!",
"node": None
}
try:
inst = User.objects.get(id=id)
if "password" in input:
password = input.pop("password")
inst.password = generate_hashed_password(password)
for k, v in input.items():
setattr(inst, k, v)
inst.save()
return {**response, "node": inst}
except User.DoesNotExist:
return {
**response, "error": True,
"message": f"The object with id {id} could not be found."
}
except Exception as err:
return {
**response, "error": True,
"message": f"Create Error: {err}"
}
async def get_song(self, message: typing.Dict) -> typing.Dict:
id = int(message.pop("id"))
try:
song = await Song.objects.select_related("artist").get(id=id)
except NoMatch:
return {"type": "song.missing", "detail": "Song not found"}
song_dict = await song.get_dict()
return song_dict
async def delete_song(self, message: typing.Dict) -> typing.Dict:
id = int(message.pop("id"))
try:
song = await Song.objects.get(id=id)
except NoMatch:
return {"type": "song.missing", "detail": "Song not found"}
await song.delete()
return {"type": "song.deleted", "detail": "Song successfully deleted"}
def __init__(
self,
*,
tasks: typing.List[typing.Callable],
web_server_config: typing.Dict = None,
stop_signal=signal.SIGINT,
timeout=0.1,
) -> None:
"""
tasks (typing.List[Awaitables]): List of tasks to be run by the worker
web_server_config (typing.Dict): Web server configuration.
Example: {
'client_connected_cb': client_on_connect_callback
'host': 127.0.0.1,
'port': 8888,
'limit' 100,
'family': socket.AF_UNSPEC,
'flags': socket.AI_PASSIVE,
'sock': None,
'backlog': 100,
'ssl': None,
'reuse_address': None,
'reuse_port': None,
'ssl_handshake_timeout': None,
'start_serving: True,
}
"""
self.tasks = tasks
self.timeout = timeout
self.web_server: typing.Optional[asyncio.AbstractServer] = None
self._loop = None
self._state = self.INIT
self.stop_signal = stop_signal
web_server_config = copy.deepcopy(web_server_config)
if web_server_config is not None:
self.client_connected_cb = web_server_config.pop(
"client_connected_cb")
self.web_server_host = web_server_config.pop(
"host", self.WEB_SERVER_HOST)
self.web_server_port = web_server_config.pop(
"port", self.WEB_SERVER_PORT)
self.web_server_config = web_server_config
def render(self, config: typing.Dict):
"""
Loads the Configuration Value into the template and returns the filled out html fragment
"""
options = {"loader": jinja2.BaseLoader()}
if config.get("jinja_options", None):
options.update(config.pop("jinja_options"))
template = jinja2.Environment(**options).from_string(
self.get_template())
return template.render(config)
def _add_log_level(_: str, method_name: str, event_dict: t.Dict) -> t.Dict:
"""
Add the log level to the event dict.
"""
if method_name == "warn":
# The stdlib has an alias
method_name = "warning"
event_dict['level'] = event_dict.pop('__level__', method_name)
return event_dict
