def __get_functions_parameters(cls, methods_info): all_parameters = [] for method_name, method_info in methods_info.items(): args = [inflection.camelize(arg, False) for arg in method_info["args"]] defaults = method_info["defaults"] formatted_args = [] for i, arg in enumerate(reversed(args)): if i >= len(defaults): formatted_args.insert(0, arg) else: formatted_args.insert(0, arg + " = " + str(defaults[-i - 1])) if i == len(defaults) - 1: formatted_args[0] = "[" + formatted_args[0] if i == len(args) - len(defaults) - 1: formatted_args[0] += "]" append_in_args = ("\n" + cls.TAB * 3).join([cls.ARGS_COOK_TEMPLATE.format(name=arg) for arg in args]) func_parameters = dict(name=method_name, args=", ".join(formatted_args), cook=append_in_args, rawArgs=", ".join(args), camelCaseName=inflection.camelize(method_name, False)) all_parameters.append(func_parameters) return all_parameters
def _add_enums_from_oneof_types(target_object, param, method): """ Create a type for each oneOf type in param and add it to target_object. :param object target_object: The target object where to add the oneOf types to :param list param: the oneOf array :param str method: name of RPC """ for o in param: classes = pjs.ObjectBuilder(o).build_classes() class_names = dir(classes) # find the generated class name that matches our schema root title class_name = None for c in class_names: if c.lower() == inflection.camelize(o['title'].replace(' ', '_')).lower(): class_name = c break # create class name <Type><Method w/o set->, e.g. Perspective+CameraParams pretty_class_name = underscorize(method[4:]) pretty_class_name = inflection.camelize(pretty_class_name) pretty_class_name = class_name + pretty_class_name # add type to target_object class_type = getattr(classes, class_name) setattr(target_object, pretty_class_name, class_type) # create and add potential enums to type _add_enums(class_type(), class_type)
def format_field(self, value, format_spec): if format_spec == "pascal": return inflection.camelize(value, True) elif format_spec == "camel": return inflection.camelize(value, False) else: return super().format_field(value, format_spec)
def format_keys(obj, format_type=None): """ Takes either a dict or list and returns it with camelized keys only if JSON_API_FORMAT_KEYS is set. :format_type: Either 'dasherize', 'camelize' or 'underscore' """ if format_type is None: format_type = getattr(settings, "JSON_API_FORMAT_KEYS", False) if format_type in ("dasherize", "camelize", "underscore", "capitalize"): if isinstance(obj, dict): formatted = OrderedDict() for key, value in obj.items(): if format_type == "dasherize": # inflection can't dasherize camelCase key = inflection.underscore(key) formatted[inflection.dasherize(key)] = format_keys(value, format_type) elif format_type == "camelize": formatted[inflection.camelize(key, False)] = format_keys(value, format_type) elif format_type == "capitalize": formatted[inflection.camelize(key)] = format_keys(value, format_type) elif format_type == "underscore": formatted[inflection.underscore(key)] = format_keys(value, format_type) return formatted if isinstance(obj, list): return [format_keys(item, format_type) for item in obj] else: return obj else: return obj
def send_json_request(self,request): ''' Sends json request to device over serial port and returns result ''' request_python = json.loads(request) try: request_id = request_python["id"] except TypeError: pass except KeyError: error_message = 'Request does not contain an id.' raise IOError(error_message) try: request_python["method"] = inflection.camelize(request_python["method"],False) except TypeError: pass except KeyError: error_message = 'Request does not contain a method.' raise IOError(error_message) try: request_python[0] = inflection.camelize(request_python[0],False) request_id = request_python[0] except IndexError: error_message = 'Request does not contain a method.' raise IOError(error_message) request = json.dumps(request_python,separators=(',',':')) request += '\n' self._debug_print('request', request) response = self._serial_interface.write_read(request,use_readline=True,check_write_freq=True) self._debug_print('response', response) result = self._handle_response(response,request_id) return result
def render(self, data, accepted_media_type=None, renderer_context=None): view = renderer_context.get('view') resource_name = get_resource_name(view) if isinstance(data, dict): for key, value in data.items(): data[inflection.camelize(key, False)] = data.pop(key) elif isinstance(data, (list, tuple)): for obj in data: if hasattr(obj, 'items'): for key, value in obj.items(): obj[inflection.camelize(key, False)] = obj.pop(key) resource_name = inflection.pluralize(resource_name) if resource_name == False: return super(JSONRenderer, self).render( data, accepted_media_type, renderer_context) try: data_copy = copy.copy(data) content = data_copy.pop('results') data = {resource_name : content, "meta" : data_copy} except (TypeError, KeyError, AttributeError) as e: data = {resource_name : data} return super(JSONRenderer, self).render( data, accepted_media_type, renderer_context)
def validate_instance_in_data(self, data, instance, attributes, relationship_keys=None): self.assertTrue( all(key in data for key in self.INSTANCE_TOP_LEVEL_KEYS)) instance_attributes = data['attributes'] for key in attributes: instance_attribute = getattr(instance, key) if hasattr(instance_attribute, '__call__'): instance_attribute = instance_attribute() self.assertEqual( instance_attributes[camelize(key, False)], instance_attribute) if not relationship_keys: return True relationships = data['relationships'] for relationship_name in relationship_keys: name = camelize(relationship_name, False) self.assertTrue(name in relationships) data = self.convert_to_list(relationships[name]['data']) instance_relationship = self.convert_to_list( getattr(instance, relationship_name)) for data_object, instance_object in zip(data, instance_relationship): self.assertEqual(data_object['id'], str(instance_object.id)) try: instance_type = instance_object.type except AttributeError: instance_type = instance_object.__class__.__name__ self.assertEqual(data_object['type'], instance_type)
def code_generator(self, schema): renderer = pystache.Renderer() template_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'mapreduce', 'raw_comparator.tpl.java') return renderer.render_path(template_path, { 'namespace' : schema.namespace, 'class_name' : inflection.camelize(('{0}GroupingComparator' if self.sortMode == JavaHadoopComparatorGenerator.GROUPING else '{0}OrderComparator').format(schema.name)), 'class_name_container' : inflection.camelize(schema.name), 'imports' : self.import_maker( ['java.io.IOException', 'org.apache.hadoop.io.RawComparator', 'org.apache.hadoop.io.WritableComparator', 'org.apache.hadoop.io.WritableUtils' ], schema), 'items' : [ { 'name_cammel' : inflection.camelize(field.name), 'name_underscore' : inflection.camelize(inflection.underscore(field.name)), 'comparator_name' : inflection.camelize('{0}Comparator'.format(field.name)), 'comparator_obj' : '{0}.Comparator'.format(self.get_equivalence(field, self.HADOOP_TYPE)), 'order_ascending' : field.order.lower() != 'descending' if field.order else True, 'order_descending' : field.order.lower() == 'descending' if field.order else False, 'order_ignore' : (field.order.lower() == 'ignore' and self.sortMode == JavaHadoopComparatorGenerator.GROUPING) if field.order else False, 'size_name' : 'FIELD_{0}_SIZE'.format(inflection.underscore(field.name).upper()), 'size_value' : self.get_equivalence(field, self.HADOOP_TYPE_SIZE) } for pos, field in enumerate(schema.fields) ] } )
def _load_from_xml(self, xml): self._id = xml.get('id') self._code = xml.get('code') for child in xml.getchildren(): if len(child.getchildren()) > 0: # Determine if children are all of the same type, e.g. Items # has many Item children, or if the current child should be # instantiated as a class is_list = len(set([i.tag for i in child.getchildren()])) == 1 if not is_list: # Single object try: cls = getattr(sys.modules[__name__], inflection.camelize(child.tag)) setattr(self, inflection.underscore(child.tag), cls.from_xml(child, parent=self)) except AttributeError: # No class for this object, ignore it pass continue else: setattr(self, inflection.underscore(child.tag), []) for item_xml in child.getchildren(): try: cls = getattr(sys.modules[__name__], inflection.camelize(item_xml.tag)) attr = getattr(self, inflection.underscore(child.tag)) attr.append(cls.from_xml(item_xml, parent=self)) except AttributeError: # Give up, remaining items are all the same and # there is no class for them break continue key = inflection.underscore(child.tag) value = child.text if value is not None: # Parse numeric types if re.match(r'^[\d]+$', value): value = int(value) elif re.match(r'^[\d.]+$', value): value = float(value) # Parse datetimes, use naive detection of key to avoid trying # to parse every field elif 'date' in key: try: value = arrow.get(value).datetime except Exception: pass self._data[key] = value # Reset dirty data because all data should now be clean self._to_persist = {}
def camel(self, data, many=None): items = [] if many: for i in data: items.append( {camelize(key, uppercase_first_letter=False): value for key, value in i.items()} ) return items return { camelize(key, uppercase_first_letter=False): value for key, value in data.items() }
def format_keys(obj, format_type=None): """ .. warning:: `format_keys` function and `JSON_API_FORMAT_KEYS` setting are deprecated and will be removed in the future. Use `format_field_names` and `JSON_API_FORMAT_FIELD_NAMES` instead. Be aware that `format_field_names` only formats keys and preserves value. Takes either a dict or list and returns it with camelized keys only if JSON_API_FORMAT_KEYS is set. :format_type: Either 'dasherize', 'camelize', 'capitalize' or 'underscore' """ warnings.warn( "`format_keys` function and `JSON_API_FORMAT_KEYS` setting are deprecated and will be " "removed in the future. " "Use `format_field_names` and `JSON_API_FORMAT_FIELD_NAMES` instead. Be aware that " "`format_field_names` only formats keys and preserves value.", DeprecationWarning ) if format_type is None: format_type = json_api_settings.FORMAT_KEYS if format_type in ('dasherize', 'camelize', 'underscore', 'capitalize'): if isinstance(obj, dict): formatted = OrderedDict() for key, value in obj.items(): if format_type == 'dasherize': # inflection can't dasherize camelCase key = inflection.underscore(key) formatted[inflection.dasherize(key)] \ = format_keys(value, format_type) elif format_type == 'camelize': formatted[inflection.camelize(key, False)] \ = format_keys(value, format_type) elif format_type == 'capitalize': formatted[inflection.camelize(key)] \ = format_keys(value, format_type) elif format_type == 'underscore': formatted[inflection.underscore(key)] \ = format_keys(value, format_type) return formatted if isinstance(obj, list): return [format_keys(item, format_type) for item in obj] else: return obj else: return obj
def format_value(value, format_type=None): if format_type is None: format_type = getattr(settings, 'JSON_API_FORMAT_KEYS', False) if format_type == 'dasherize': # inflection can't dasherize camelCase value = inflection.underscore(value) value = inflection.dasherize(value) elif format_type == 'camelize': value = inflection.camelize(value, False) elif format_type == 'capitalize': value = inflection.camelize(value) elif format_type == 'underscore': value = inflection.underscore(value) return value
def format_value(value, format_type=None): if format_type is None: format_type = json_api_settings.format_type if format_type == 'dasherize': # inflection can't dasherize camelCase value = inflection.underscore(value) value = inflection.dasherize(value) elif format_type == 'camelize': value = inflection.camelize(value, False) elif format_type == 'capitalize': value = inflection.camelize(value) elif format_type == 'underscore': value = inflection.underscore(value) return value
def format_keys(obj, format_type=None): """ Takes either a dict or list and returns it with camelized keys only if REST_EMBER_FORMAT_KEYS is set. :format_type: Either 'camelize' or 'underscore' """ if getattr(settings, 'REST_EMBER_FORMAT_KEYS', False)\ and format_type in ('camelize', 'underscore'): if isinstance(obj, dict): formatted = {} for key, value in obj.items(): if format_type == 'camelize': formatted[inflection.camelize(key, False)]\ = format_keys(value, format_type) elif format_type == 'underscore': formatted[inflection.underscore(key)]\ = format_keys(value, format_type) return formatted if isinstance(obj, list): return [format_keys(item, format_type) for item in obj] else: return obj else: return obj
def run(): parser = argparse.ArgumentParser(prog = get_script_name_from_python_file(__file__)) parser.add_argument("name") args = parser.parse_args() if is_name_valid(args.name): template_basename = 'script_template' script_exe_name = 'git_' + args.name script_py_name = args.name + '.py' templates = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'misc', template_basename) # CREATE EXECUTABLE FILE script_exe_path = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), script_exe_name) create_file(templates, script_exe_path, { r'<name>': args.name }) st = os.stat(script_exe_path) os.chmod(script_exe_path, st.st_mode | stat.S_IEXEC) # CREATE PYTHON FILE template_py_path = templates + '_py' script_py_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), script_py_name) create_file(template_py_path, script_py_path, { r'<name>': args.name }) # CREATE PYTHON TEST FILE template_test_py_path = templates + '_test_py' script_test_py_path = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), 'test', script_py_name) create_file(template_test_py_path, script_test_py_path, { r'<name>': args.name, r'<main_method_name>': inflection.camelize(args.name) }) # DONE print('Templates for new script successfuly created. Run "' + script_exe_name + '" to try it out.') else: print('The name has to be of the form "new_script_name"') sys.exit(-1)
def __init__(self, field): self.field = field # Try to name this XSD type # Note: should we use field.context.key ? # The problem is that when dealing with List/Dict fields, the value_type # field also inherits the parent's context name = field.getName() or str(inflection.parameterize(field.title)) if not name: try: name = field.getTaggedValue("name") except KeyError: pass assert name, "The field should be named" name = inflection.underscore(name) self.typename = inflection.camelize(name) self.name = inflection.dasherize(name) # Compute occurence indicators self.min_occurs = 1 if field.required else 0 self.max_occurs = 1
def gen_db_model(self, schema_name, table_name): sql = """ SELECT column_name, column_default, data_type, column_key, is_nullable, character_maximum_length, column_comment FROM information_schema.columns WHERE TABLE_SCHEMA = :schema_name AND TABLE_NAME = :table_name ORDER BY ORDINAL_POSITION""" with self.create_session(self._default_db) as session: entities = session.execute(sql, dict(schema_name=schema_name, table_name=table_name)) metas = [GenMeta(entity) for entity in entities if entity[0] != 'pkid'] model_meta = DbModelMeta() model_meta.table_metas = metas for meta in metas: if model_meta.has_id is False: model_meta.has_id = meta.column_name == 'id' model_meta.is_string_id = meta.column_name == 'id' and \ u'varchar' == meta.data_type if model_meta.has_created_at is False: model_meta.has_created_at = meta.column_name == 'created_at' if model_meta.has_updated_at is False: model_meta.has_updated_at = meta.column_name == 'updated_at' if model_meta.has_is_deleted is False: model_meta.has_is_deleted = meta.column_name == 'is_deleted' model_meta.class_name = inflection.singularize(inflection.camelize(table_name)) template_path = os.path.join(os.path.dirname(__file__)) t = Loader(template_path, **{}).load('model.tpl') print t.generate(**model_meta.__dict__)
def create(self, name): docstring = name.rstrip('.') name = re.sub('\W', '_', name.rstrip('.')) if re.match('^\w*$', docstring): # docstring seems to not be a sentence but a camelcase classname # or a underscored upgrade directory name. # Lets make it human readable for use as docstring. docstring = inflection.humanize( inflection.underscore(name)) step_name = '{0}_{1}'.format( datetime.now().strftime(DATETIME_FORMAT), inflection.underscore(name)) step_directory = os.path.join(self.upgrades_directory, step_name) os.mkdir(step_directory) Path(step_directory).joinpath('__init__.py').touch() code_path = os.path.join(step_directory, 'upgrade.py') with open(code_path, 'w+') as code_file: code_file.write( PYTHON_TEMPLATE.format( classname=inflection.camelize(name), docstring=docstring)) return step_directory
def _resolve(self, path, migration_file): """ Resolve a migration instance from a file. :param migration_file: The migration file :type migration_file: str :rtype: orator.migrations.migration.Migration """ name = '_'.join(migration_file.split('_')[4:]) migration_file = os.path.join(path, '%s.py' % migration_file) # Loading parent module parent = os.path.join(path, '__init__.py') if not os.path.exists(parent): with open(parent, 'w'): pass load_module('migrations', parent) # Loading module mod = load_module('migrations.%s' % name, migration_file) klass = getattr(mod, inflection.camelize(name)) instance = klass() instance.set_connection(self.get_repository().get_connection()) return instance
def makeTask(templateData): tasks = templateData["mappings"]["tasks"] for task in tasks: templateFilename = "templates/_name_Task.java" outputFilename = ( "src/main/java/" + templateData["directory"] + "/tasks/" + inflection.camelize(task) + "Task.java" ) modelTemplateData = templateData taskMappings = tasks[task] if "response" in taskMappings: modelTemplateData["response"] = taskMappings["response"] else: modelTemplateData["response"] = {} if "model" in taskMappings: modelTemplateData["model"] = taskMappings["model"] else: modelTemplateData["model"] = {} if "viewModels" in taskMappings: modelTemplateData["viewModels"] = taskMappings["viewModels"] else: modelTemplateData["viewModels"] = [] makeTemplateFromData(modelTemplateData, templateFilename, outputFilename)
def _resolve(cls, path, factory_file): """ Resolve a migration instance from a file. :param path: The path to factories directory :type path: str :param factory_file: The migration file :type factory_file: str :rtype: Factory """ variables = {} name = factory_file factory_file = os.path.join(path, factory_file) with open(factory_file) as fh: exec(fh.read(), {}, variables) klass = variables[inflection.camelize(name)] instance = klass() return instance
def run(self): end_time = dt.utcnow() if self.__last_run: start_time = self.__last_run + datetime.timedelta(seconds=1) else: start_time = end_time - datetime.timedelta(seconds=60) # Set the start_time for the next run self.__last_run = end_time logger.info("Running CloudwatchCollector on %s metrics between %s and %s" % (len(self.__config['metrics']), start_time, end_time)) for metric in self.__config['metrics']: # TODO: Support for dimensions for dynamo table names # http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/MonitoringDynamoDB.html namespace = metric['namespace'] metric_name = metric['metric_name'] # Collect the remaining metric dimensions besides metric_name and namespace dimensions = {} for key in metric: if not key in ('metric_name', 'namespace'): dimensions[inflection.camelize(key)] = metric[key] # If metric_name is a list, process each seperately with the same values for namespace and dimensions if isinstance(metric_name, list): [self.process_metrics(name, namespace, dimensions, start_time, end_time) for name in metric_name] else: self.process_metrics(metric_name, namespace, dimensions, start_time, end_time)
def get(self): '''Returns a JSON object of each of the routes, the verbs they respond to, and some documentation on them.''' handlers_module = importlib.import_module('daedalus.frontend.handlers') non_important_handlers = [inflection.camelize(module_name) for module_name in getattr(handlers_module, '__non_important_handlers')] handler_names = [handler_name for handler_name in dir(handlers_module) if re.match(r'.*?Handler', handler_name) and handler_name not in non_important_handlers] data = {} for handler_name in handler_names: match = re.match(r'(.*?)Handler', handler_name) key = match.group(1).lower() handler = getattr(handlers_module, handler_name) route, _ = handler.route() verbs = [] for verb in ('get', 'post', 'delete', 'put', 'options', 'head'): doc = getattr(handler, verb, None).__doc__ if doc: verbs.append({'verb': verb, 'doc': doc}) data[key] = { 'route': route, 'verbs': verbs } self.write(data)
def build_classes(self,strict=False): """ Args: strict: use this to validate required fields while creating the class Returns: """ builder = classbuilder.ClassBuilder(self.resolver) for nm, defn in iteritems(self.schema.get('definitions', {})): uri = util.resolve_ref_uri( self.resolver.resolution_scope, "#/definitions/" + nm) builder.construct(uri, defn) nm = self.schema['title'] if 'title' in self.schema else self.schema['id'] nm = inflection.parameterize(six.text_type(nm), '_') kw = {"strict" : strict} builder.construct(nm, self.schema,**kw) self._resolved = builder.resolved return ( util.Namespace.from_mapping(dict( (inflection.camelize(uri.split('/')[-1]), klass) for uri, klass in six.iteritems(builder.resolved))) )
def __new__(meta, name, bases, attrs): for name, attr in six.iteritems(attrs): if isinstance(attr, types.BaseType): camelized = inflection.camelize(name, uppercase_first_letter=False) attr.serialized_name = attr.serialized_name or camelized attr.deserialize_from = attr.deserialize_from or camelized return super(BetfairModelMeta, meta).__new__(meta, name, bases, attrs)
def generate_model_name(name): """ Generate model name. :param name: String representing a field or route name. """ model_name = inflection.camelize(name.strip('/')) return inflection.singularize(model_name)
def get_resource_name(view): """ Return the name of a resource. """ try: # Check the view resource_name = getattr(view, 'resource_name') except AttributeError: try: # Check the meta class resource_name = ( getattr(view, 'serializer_class') .Meta.resource_name) except AttributeError: # Use the model try: resource_name = ( getattr(view, 'serializer_class') .Meta.model.__name__) except AttributeError: try: resource_name = view.model.__name__ except AttributeError: resource_name = view.__class__.__name__ if isinstance(resource_name, six.string_types): return inflection.camelize(resource_name, False) return resource_name
def do_oper(self): """ vnc db crud operations """ # Get the class name from object type cls_name = camelize(self.object_type) # Get the class object self.cls = self._str_to_class(cls_name) if self.cls is None: raise ValueError("Invalid object_type: %s" % self.object_type) # This creates an object, if not existing, else update the object results = None if self.object_op == 'create': results = self._create_oper() elif self.object_op == 'update': results = self._update_oper() elif self.object_op == 'bulk_create': results = self._bulk_create_oper() elif self.object_op == 'bulk_update': results = self._bulk_update_oper() elif self.object_op == 'bulk_query': results = self._bulk_query_oper() elif self.object_op == 'delete': results = self._delete_oper() elif self.object_op == 'read': results = self._read_oper() elif self.object_op == 'list': results = self._list_oper() elif self.object_op == 'ref_delete': results = self._ref_delete_oper() elif self.object_op == 'ref_update': results = self._ref_update_oper() elif self.object_op == 'bulk_ref_update': results = self._bulk_ref_update_oper() elif self.object_op == 'fq_name_to_id': results = self._fq_name_to_id_oper() elif self.object_op == 'id_to_fq_name': results = self._id_to_fq_name_oper() else: raise ValueError( "Unsupported operation '%s' for object type '%s'", self.object_op, self.object_type) return results
def execute(self, *args): action_ = "Action%s" % inflection.camelize(args[0]) action_args = args[1:] module = next(module for module in actions.__modules__ if hasattr(module, action_)) try: getattr(module, action_)(*action_args, **self.__dict__) except Exception, ex: raise MavaException("Something went wrong with this action.\n%s" % ex.message)
def __init__(self, obj): self.obj = obj # Try to name this XSD type name = str(inflection.underscore(type(obj).__name__)) self.typename = inflection.camelize(name) self.name = name = inflection.dasherize(name)
def test_camelize(camel, underscore): assert camel == inflection.camelize(underscore)
def _envelope_plural_name(self): return camelize(pluralize( getattr(self.Meta, 'plural_name', self._envelope_name)), uppercase_first_letter=False)
def to_camel(s: str) -> str: s = re.sub("_(url)$", lambda m: f"_{m.group(1).upper()}", s) return inflection.camelize(s, uppercase_first_letter=False)
def get_tag_name(s): assert s.startswith("@") return inflection.camelize(s[1:])
from typing import Optional, Sequence, Any, NamedTuple, Mapping, Union, Tuple, Type import inflection from typeit import TypeConstructor, flags generate_constructor_and_serializer = TypeConstructor class AttrStyle(Enum): CAMELIZED = "camelized" DASHERIZED = "dasherized" UNDERSCORED = "underscored" camelized = TypeConstructor & flags.GlobalNameOverride( lambda x: inflection.camelize(x, uppercase_first_letter=False)) dasherized = TypeConstructor & flags.GlobalNameOverride(inflection.dasherize) underscored = TypeConstructor AttrOverrides = Mapping[Union[property, Tuple[Type, str]], str] class DataSetListApi(NamedTuple): """""" api_version_number: Optional[str] = None api_url: Optional[str] = None api_key: Optional[str] = None
def __from_dict(self, values: dict): name_mappings = getattr(self, '_name_mappings', {}) for prop in self.properties(): if getattr(type(self), prop).fset is None: continue prop_value = values.get( name_mappings.get(prop, prop), values.get( inflection.camelize(prop, uppercase_first_letter=False))) if prop_value is not None: if isinstance(prop_value, np.generic): prop_value = prop_value.item() additional_types = [] prop_type = self.prop_type(prop, additional=additional_types) if prop_type is None: # This shouldn't happen setattr(self, prop, prop_value) elif issubclass(prop_type, dt.datetime): if isinstance(prop_value, int): setattr( self, prop, dt.datetime.fromtimestamp(prop_value / 1000).isoformat()) else: import re matcher = re.search('\\.([0-9]*)Z$', prop_value) if matcher: sub_seconds = matcher.group(1) if len(sub_seconds) > 6: prop_value = re.sub( matcher.re, '.{}Z'.format(sub_seconds[:6]), prop_value) try: setattr(self, prop, isoparse(prop_value)) except ValueError: if str in additional_types: setattr(self, prop, prop_value) elif issubclass(prop_type, dt.date) and type(prop_value) is not dt.date: date_value = None if isinstance(prop_value, float): # Assume it's an Excel date if prop_value > 59: prop_value -= 1 # Excel leap year bug, 1900 is not a leap year! date_value = dt.datetime(1899, 12, 31) + dt.timedelta( days=prop_value).date() elif isinstance(prop_value, str): for format in _valid_date_formats: try: date_value = dt.datetime.strptime( prop_value, format).date() break except ValueError: pass setattr(self, prop, date_value or prop_value) elif issubclass(prop_type, float) and isinstance( prop_value, str): if prop_value.endswith('%'): setattr(self, prop, float(prop_value[:-1]) / 100) else: setattr(self, prop, float(prop_value)) elif issubclass(prop_type, EnumBase): setattr(self, prop, get_enum_value(prop_type, prop_value)) elif issubclass(prop_type, Base): if isinstance(prop_value, Base): setattr(self, prop, prop_value) else: setattr(self, prop, prop_type.from_dict(prop_value)) elif issubclass(prop_type, (list, tuple)): item_type = self.prop_item_type(prop) if issubclass(item_type, Base): item_values = tuple( v if isinstance(v, ( Base, EnumBase)) else item_type.from_dict(v) for v in prop_value) elif issubclass(item_type, EnumBase): item_values = tuple( get_enum_value(item_type, v) for v in prop_value) else: item_values = tuple(prop_value) setattr(self, prop, item_values) else: setattr(self, prop, prop_value)
def get_vnc_cls(object_type): cls_name = camelize(object_type) return getattr(vnc_api.gen.resource_client, cls_name, None)
def _get_class_name(self, name): return inflection.camelize(name)
def items_with_ids(self): map = {} for item in self.json_field.json_enum_items: map[item] = inflection.camelize(item, True) return map
def get_operation_id(self, operation_keys): operation_id = super(CamelCaseOperationIDAutoSchema, self).get_operation_id(operation_keys) return camelize(operation_id, uppercase_first_letter=False)
def preprocess(self, key, value): return inflection.camelize(key), value
def test_camelize_with_underscores(): assert "CamelCase" == inflection.camelize('Camel_Case')
def defname(obj, name: str = None) -> Optional[str]: """Get the definition name for an object.""" defname = name or getattr(obj, "__name__", None) if (obj is dict or origin(obj) is dict) and name: defname = name return inflection.camelize(defname) if defname else None
def setter_function_name(self): return 'set%s' % inflection.camelize(self.json_field.json_name.lower(), True)
def on_bind_field(self, field_name, field_obj): """Use camelCase externally and snake_case internally""" name = field_obj.data_key or field_name field_obj.data_key = camelize(name, uppercase_first_letter=False)
def name(self): return inflection.camelize(self.json_field.json_name.lower(), False)
def pascal(text): return inflection.camelize(text, uppercase_first_letter=True)
def camelcase(value): return camelize(str(value).lower(), uppercase_first_letter=False)
def camel(text): return inflection.camelize(text, uppercase_first_letter=False)
def create(self, model, **kwargs): model = self.check_noun(model) model = sanitized_string(model) classname = inflection.camelize(model) singular = inflection.singularize(classname) plural = inflection.pluralize(classname) class_type = kwargs.get('class_type', None) extra = {} filename = f"{model.lower()}.py" template = 'view-function.tpl' template_import = 'view-function-import.tpl' view_name = inflection.underscore(singular) route_name = f'{inflection.underscore(model)}/' template_name = f'{model.lower()}.html' if class_type is not None: filename = f"{model.lower()}_{class_type}.py" template = 'view-class.tpl' template_import = 'view-class-import.tpl' if class_type not in ['template']: view_name = inflection.underscore(singular) + f'-{class_type}' template_name += f'_{class_type.lower()}.html' extra[ 'object_name'] = plural if class_type == 'list' else singular if class_type in ['form', 'update', 'create']: extra['form_class'] = f'{classname}Form' if class_type in ['list']: route_name = f'{inflection.underscore(plural)}/' extra['pagination'] = True if class_type in ['detail', 'update']: route_name += '<slug:slug>' content = rendered_file_template(path=self.TEMPLATES_DIRECTORY, template=template, context={ 'model': model, 'classname': classname, 'class_type': class_type, 'route_name': route_name, 'view_name': view_name, 'template_name': template_name, **extra, }) import_content = rendered_file_template(path=self.TEMPLATES_DIRECTORY, template=template_import, context={ 'model': model, 'classname': classname, 'class_type': class_type, }) self.add_import(template=template_import, content=import_content) if self.create_file(path=self.cwd, filename=filename, content=content): resource = f"{model}_view." if class_type: resource = f"{classname}{class_type.capitalize()}View." log_success(DEFAULT_CREATE_MESSAGE.format(filename, resource))
import inflection import jinja2 import requests import sys PKG = sys.argv[1] FNAME = sys.argv[2] if __name__ == "__main__": pypi_query = requests.get(f'https://pypi.org/pypi/{PKG}/json') pypi_result = pypi_query.json() template_env = jinja2.Environment(loader=jinja2.FileSystemLoader( searchpath="./")) template = template_env.get_template("python.j2") with open(f'./poet/{FNAME}.resources', 'r') as file: print( template.render( package_name=PKG, resources=file.read(), class_name=inflection.camelize(FNAME.replace('-', '_')), fname=FNAME, **pypi_result, ))
def class_name(json_name): return inflection.camelize(json_name, True)
def transform(self, field_name): return camelize(field_name, uppercase_first_letter=False)
def to_json_name(x: str) -> str: return inflection.camelize(x, False)
def name(self): return inflection.camelize(self.model_cls.__name__, uppercase_first_letter=False)
def test_camelize_with_lower_downcases_the_first_letter(): assert 'capital' == inflection.camelize('Capital', False)
def test_positive_run_custom_job_template_by_ip(session, module_org, module_subnet): """Run a job template on a host connected by ip :id: e283ae09-8b14-4ce1-9a76-c1bbd511d58c :Setup: Create a working job template. :Steps: 1. Set remote_execution_connect_by_ip on host to true 2. Navigate to an individual host and click Run Job 3. Select the job and appropriate template 4. Run the job :expectedresults: Verify the job was successfully ran against the host :CaseLevel: System """ with VirtualMachine( distro=DISTRO_RHEL6, provisioning_server=settings.compute_resources.libvirt_hostname, bridge=settings.vlan_networking.bridge, ) as client: client.install_katello_ca() client.register_contenthost(module_org.label, lce='Library') assert client.subscribed add_remote_execution_ssh_key(client.ip_addr) Host.update({ 'name': client.hostname, 'subnet-id': module_subnet.id, }) # connect to host by ip Host.set_parameter({ 'host': client.hostname, 'name': 'remote_execution_connect_by_ip', 'value': 'True', }) hostname = client.hostname job_template_name = gen_string('alpha') with session: session.organization.select(module_org.name) assert session.host.search(hostname)[0]['Name'] == hostname session.jobtemplate.create({ 'template.name': job_template_name, 'template.template_editor.rendering_options': 'Input', 'template.template_editor.editor': '<%= input("command") %>', 'job.provider_type': 'SSH', 'inputs': [{ 'name': 'command', 'required': True, 'input_type': 'User input', }], }) assert session.jobtemplate.search( job_template_name)[0]['Name'] == job_template_name session.jobinvocation.run({ 'job_category': 'Miscellaneous', 'job_template': job_template_name, 'search_query': 'name ^ {}'.format(hostname), 'template_content.command': 'ls', }) job_description = '{0} with inputs command="ls"'.format( camelize(job_template_name.lower())) session.jobinvocation.wait_job_invocation_state( entity_name=job_description, host_name=hostname) status = session.jobinvocation.read(entity_name=job_description, host_name=hostname) assert status['overview']['hosts_table'][0]['Status'] == 'success'
def get_class_from_type(type): return eval(singularize(camelize(type)))
def serialize_key(self, key): return inflection.camelize(key, uppercase_first_letter=False).rstrip('_')
def function_definition_name(header_name): return camelize(header_name.replace(".h", "")).replace(" ", "")