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(" ", "")
