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"