def omdb_data(arguments):
movie_name, year = arguments
client = OMDBClient(apikey=OMDB_API_KEY)
try:
result = client.get(title=movie_name, year=year, fullplot=True, tomatoes=True)
except HTTPError as e:
print(e)
client.set_default("apikey", OMDB_API_KEY_fallback)
result = client.get(title=movie_name, year=year, fullplot=True, tomatoes=True)
result_to_keep = {}
for key in requested_flat_fields:
result_to_keep[key] = result.get(key, None)
for nested_field in requested_nested_fields:
requested_nested_list = requested_nested_fields[nested_field]
nested_list = result.get(nested_field, None)
if nested_list:
for nested_dict in nested_list:
source = nested_dict.get("source", None)
if source:
value = nested_dict.get("value", None)
if source in requested_nested_list:
source_formatted = to_snake_case(source)
key = f"{nested_field}_{source_formatted}"
result_to_keep[key] = value
requested_sources = requested_nested_fields[nested_field]
for requested_source in requested_sources:
source_formatted = to_snake_case(requested_source)
key = f"{nested_field}_{source_formatted}"
if not key in result_to_keep:
result_to_keep[key] = None
else:
requested_sources = requested_nested_fields[nested_field]
for requested_source in requested_sources:
source_formatted = to_snake_case(requested_source)
key = f"{nested_field}_{source_formatted}"
result_to_keep[key] = None
return t.Row(*list(result_to_keep.keys()))(*list(result_to_keep.values()))
def new_from_json_dict(cls, data):
new_data = {
utils.to_snake_case(key): value
for key, value in data.items()
}
return cls(**new_data)
def scrap_row(self, row, key_val, base_airport, query_time):
col_dict = {}
pq(row).find("td").each(lambda i, td:
col_dict.update({
to_snake_case(key_val[i]): pq(td).text().replace("*", "").replace("^", "").replace(
"(", "").replace(")", ""),
"_base_airport": base_airport,
"_query_time": query_time,
"id": str(gen_uuid())
})
)
if bool(col_dict) is True:
flight_number = col_dict["flight"].replace(" ", "")
col_dict["flight"] = flight_number
number = re.split('(?<![A-Z0-9])[A-Z0-9]{2}', flight_number)
import datetime
now = datetime.datetime.now()
col_dict["fs_url"] = "https://www.flightstats.com/v2/flight-tracker/{0}/{1}/{2}/{3}/{4}".format(
flight_number[0:2],
number[1], str(now.year), str(now.month), str(now.day))
col_dict["fs_api"] = "https://www.flightstats.com/v2/api-next/flight-tracker/{0}/{1}/{2}/{3}/{4}".format(
flight_number[0:2],
number[1], str(now.year), str(now.month), str(now.day))
col_dict["track_url"] = "{0}://{1}/api/v1/track/{2}/{3}".format(
self.request.protocol, self.request.host, flight_number[0:2],
number[1])
return col_dict
def __init__(self, cls, attrs, meta):
"""Initialize new document class metadata."""
self.cls = cls
self.fields = {}
self.options = {}
self.bind_init()
fields = {}
for base in reversed(cls.__bases__):
if isinstance(getattr(base, '_meta', None), self.__class__):
fields.update(base._meta.fields)
if attrs:
for name, attr in attrs.items():
if isinstance(attr, BaseField):
fields[name] = attr
self.fields = fields
if meta:
self.options.update(vars(meta))
self.connection = self.options.pop('connection', None)
self.collection = self.options.pop('collection', None)
if not self.collection:
self.collection = to_snake_case(cls.__name__)
self.subdocument = not bool(self.connection)
if not self.subdocument and '_id' not in self.fields:
self.fields['_id'] = Field(ObjectId, require=False)
self.bind_fields()
def get_image(cls) -> pygame.Surface:
if not cls.image:
screen_name = utils.to_snake_case(cls.__name__)
cls.image = pygame.transform.scale(
utils.load_image(f'screens/{screen_name}/{screen_name}.png'),
(config.width, config.height)
)
return cls.image
def cpp_fence(self):
"""Preprocessor macro to use to prevent symbol redefinition
#ifndef {{ node.cpp_fence }}
#define {{ node.cpp_fence }}
// ...
# endif
"""
return "NMODL_AST_" + to_snake_case(self.class_name).upper() + '_HPP'
def test_case_converters():
test_str = "lower_snake_case"
expected = "LowerSnakeCase"
result = utils.to_camel_case(test_str)
assert result == expected, "Snake case not converted to upper camel case"
expected = "lowerSnakeCase"
result = utils.to_camel_case(test_str, False)
assert result == expected, "Snake case not converted to lower camel case"
test_str = "UpperCamelCase"
expected = "upper_camel_case"
result = utils.to_snake_case(test_str)
assert result == expected, "Camel case not converted to lower snake case"
expected = "UPPER_CAMEL_CASE"
result = utils.to_snake_case(test_str, True)
assert result == expected, "Camel case not converted to upper snake case"
def delete(self, name):
with model.session_scope() as session:
user_session = self.get_user_session(session)
user_session.policy.verify('conf_del')
name = to_snake_case(name)
self.get_schema(name)
config.reset_setting(session, name)
self.finish()
def _get_default_template_values(vpc_stacks, region, request):
"""Build a dictionary of default values to inject in the jinja templated cluster configs."""
default_values = {
dimension: request.node.funcargs.get(dimension)
for dimension in DIMENSIONS_MARKER_ARGS
}
default_values["key_name"] = request.config.getoption("key_name")
vpc = vpc_stacks[region]
for key, value in vpc.cfn_outputs.items():
default_values[to_snake_case(key)] = value
return default_values
def get_scrapped_result(self, html, callback=None):
dict_response = {"data": {}, "meta": ""}
dict_meta = {}
d = pq(html)
title_html = pq(d.find('title').html())
title_text = title_html.text()
if "Not Available" in title_text:
"""
TODO if Not available give empty dictionary
"""
dict_meta = {"code": 408,
"message": MSG_SERVICE_UNAVAILABLE}
dict_response["meta"] = dict_meta
elif "PEPOLENQM009" in title_text:
"""
TODO if it exists Continue scraping
"""
dict_data = {}
form_html = pq(d.find('form[name="enquiryForm"]').html())
result_html = pq(form_html.find('.outerBox > table > tr'))
result_html.each(lambda e, tb_row:
dict_data.update(
{to_snake_case(
pq(tb_row).text().split(":")[0].strip().replace(" ", "_")).replace("__",
"_").replace(
".", ""):
pq(tb_row).text().split(":")[
1].strip()})
)
dict_meta = {
"code": 200,
"message": str(MSG_RECORD_EXISTS).format(dict_data["name"], dict_data["application_no"],
dict_data["date_of_application"], dict_data["pass_type"],
dict_data["status"], MSG_GOOD_BYE)
};
dict_response["meta"] = dict_meta
dict_response["data"] = dict_data
elif "PEPOLENQM007" in title_text:
dict_meta = {
"code": 403,
"message": MSG_RECORD_NOT_FOUND
}
dict_response["meta"] = dict_meta
else:
dict_meta = {
"code": 503,
"message": MSG_INTERNAL_SERVER_ERROR
};
dict_response["meta"] = dict_meta
return callback(dict_response)
def __init__(self, ps, **kw):
kw.setdefault('name', qu.to_snake_case(type(self).__name__))
kw.setdefault('dtype', tf.float32)
super().__init__(**kw)
if isinstance(ps, qu.Config):
self.cfg = ps
else:
self.cfg = qu.Config(**dict(self.cfg_items(ps)))
cfg = self.cfg
if cfg.initer_stddev:
self.initer = ki.TruncatedNormal(stddev=cfg.initer_stddev)
def __init__(self, json_data):
definition = json_data['definition']
self.name = utils.to_snake_case(
definition['name']).split(',')[0].strip()
self.type = definition['filterType']
self.damage = definition['damage']['diceString']
self.damage_type = definition['damageType']
self.equipped = True if json_data['equipped'] == "true" else False
self.range = int(definition['range'])
self.long_range = int(definition['longRange'])
self.properties = []
if 'properties' in definition:
self.properties += [p['name'] for p in definition['properties']]
def get_setter_method_declaration(self, class_name):
setter_method = "set_" + to_snake_case(self.varname)
setter_type = self.member_typename
reference = "" if self.is_base_type_node else "&&"
if self.is_base_type_node:
return f"""
/**
* \\brief Setter for member variable \\ref {class_name}.{self.varname}
*/
void {setter_method}({setter_type} {self.varname});
"""
else:
return f"""
def get_setter_method_definition(self, class_name):
setter_method = "set_" + to_snake_case(self.varname)
setter_type = self.member_typename
reference = "" if self.is_base_type_node else "&&"
if self.is_base_type_node:
return f"""
void {class_name}::{setter_method}({setter_type} {self.varname}) {{
// why don't we use a coding convention instead of this workaround for
// variable shadowing?
this->{self.varname} = {self.varname};
}}
"""
elif self.is_vector:
return f"""
void {class_name}::{setter_method}({setter_type}&& {self.varname}) {{
this->{self.varname} = {self.varname};
// set parents
for (auto& ii : {self.varname}) {{
ii->set_parent(this);
}}
}}
void {class_name}::{setter_method}(const {setter_type}& {self.varname}) {{
this->{self.varname} = {self.varname};
// set parents
for (auto& ii : {self.varname}) {{
ii->set_parent(this);
}}
}}
"""
elif self.is_pointer_node or self.optional:
return f"""
void {class_name}::{setter_method}({setter_type}&& {self.varname}) {{
this->{self.varname} = {self.varname};
// set parents
if ({self.varname}) {{
{self.varname}->set_parent(this);
}}
}}
void {class_name}::{setter_method}(const {setter_type}& {self.varname}) {{
this->{self.varname} = {self.varname};
// set parents
if ({self.varname}) {{
{self.varname}->set_parent(this);
}}
}}
"""
else:
return f"""
def __init__(self, json_data):
definition = json_data['definition']
modifier = [
x for x in definition['modifiers'] if x['type'] == 'damage'
][0]
self.name = utils.to_snake_case(definition['name'])
self.school = definition['school']
self.requires_attack_roll = definition['requiresAttackRoll']
self.type = modifier['type']
self.sub_type = modifier['subType']
self.damages = {1: modifier['die']['diceString']}
if 'higherLevelDefinitions' in modifier['atHigherLevels']:
for d in modifier['atHigherLevels']['higherLevelDefinitions']:
self.damages[d['level']] = d['dice']['diceString']
def post(self, name):
with model.session_scope() as session:
user_session = self.get_user_session(session)
user_session.policy.verify('conf_edit')
name = to_snake_case(name)
schema = self.get_schema(name)
fileinfo = self.request.files['file'][0]
body = fileinfo['body']
if schema['type'] == 'image' and schema['accept'] == '.svg':
body = yield self.clean_svg(body)
config.set_setting(session, name, body.encode('utf-8'))
self.finish()
def cpp_header_deps(self):
"""Get list of C++ headers required by the C++ declaration of this class
Returns:
string list of paths to C++ headers relative to BUILD_DIR
"""
dependent_classes = set()
if self.base_class:
dependent_classes.add(self.base_class)
for child in self.children:
if child.is_ptr_excluded_node or child.is_vector:
dependent_classes.add(child.class_name)
return sorted([
"ast/{}.hpp".format(to_snake_case(clazz))
for clazz in dependent_classes
])
def get(self, name):
with model.session_scope() as session:
user_session = self.get_user_session(session)
user_session.policy.verify('conf_view')
name = to_snake_case(name)
schema = self.get_schema(name)
if schema['type'] == 'image' and schema['accept'] == '.svg':
self.set_header('Content-Type', 'image/svg+xml')
else:
self.clear_header('Content-Type')
value = config.get_setting(
session,
name,
force_default=self.get_argument('default', None) != None)
self.write(value)
self.finish()
def has_proficiency(self, arg):
return True if utils.to_snake_case(
arg) in self.proficiencies else False
def __init__(self, **kw):
kw.setdefault('name', qu.to_snake_case(type(self).__name__))
super().__init__(**kw)
def ast_enum_name(self):
return to_snake_case(self.class_name).upper()
def get_getter_method(self, class_name):
getter_method = self.getter_method if self.getter_method else "get_" + to_snake_case(
self.varname)
getter_override = " override" if self.getter_override else ""
return_type = self.member_typename
return f"""
)
from utils import to_snake_case, copy_rename
this_dir = os.path.dirname(os.path.abspath(__file__))
json_logs_dir = os.path.join(this_dir, "../../logs/multi-device/")
output_file_path = os.path.abspath(os.path.join(json_logs_dir, "runs.csv"))
typing_test_json_logs_dir = os.path.join(this_dir,
"../../logs/multi-device-typing")
typing_test_output_file_path = os.path.abspath(
os.path.join(typing_test_json_logs_dir, "runs.csv"))
p_registry_path = os.path.abspath(os.path.join(json_logs_dir,
"p_registry.csv"))
record_columns = dict((to_snake_case(col), col) for col in [
"participant",
"corpusSize",
"keyStrokeDelay",
"targetAccuracy",
"version",
"isTest",
"totalSuggestions",
"suggestionsType",
"numberOfPracticeTasks",
"numberOfTypingTasks",
"startDate",
"endDate",
"timeZone",
"wave",
"configUuid",
def cpp_header(self):
"""Path to C++ header file of this class relative to BUILD_DIR"""
return "ast/" + to_snake_case(self.class_name) + ".hpp"
