def package_name(cls, package: str) -> str:
"""Convert the given package name to safe snake case."""
return ".".join(
map(
lambda x: text.snake_case(utils.safe_snake(x, default="pkg")),
package.split("."),
))
def enumeration_name(cls, name: str) -> str:
"""
Strip reference prefix and turn to snake case.
If the name is one of the python reserved words append the
prefix _value
"""
return text.snake_case(safe_snake(name)).upper()
def attribute_name(cls, name: str) -> str:
"""
Strip reference prefix and turn to snake case.
If the name is one of the python reserved words append the
prefix _value
"""
local_name = text.suffix(name)
return text.snake_case(safe_snake(local_name))
def test_output(self):
self.assertEqual("value_1", safe_snake("1"))
self.assertEqual("value_minus_-1", safe_snake("-1"))
self.assertEqual("value_--1", safe_snake("--1"))
self.assertEqual("value", safe_snake(""))
self.assertEqual("value_1 0-2e", safe_snake("1.0-2e"))
self.assertEqual("value", safe_snake("τσου!!"))
self.assertEqual("chris", safe_snake("chris"))
def read_root_name(path: Path) -> str:
try:
recovering_parser = etree.XMLParser(
recover=True, resolve_entities=False, no_network=True
)
tree = etree.parse(str(path), parser=recovering_parser) # nosec
_, local_name = split_qname(tree.getroot().tag)
return text.pascal_case(utils.safe_snake(local_name, "Type"))
except Exception:
return ""
def field_name(self, name: str, class_name: str) -> str:
"""
Convert the given name to a field name according to the selected
conventions or use an existing alias.
Provide the class name as context for the naming schemes.
"""
alias = self.field_aliases.get(name)
if alias:
return alias
safe_name = utils.safe_snake(name, self.field_safe_prefix)
return self.field_case(safe_name, class_name=class_name)
def module_name(cls, module: str) -> str:
"""Convert the given module name to safe snake case."""
return text.snake_case(utils.safe_snake(text.clean_uri(module), default="mod"))
def _package_name(self, part: str) -> str:
return self.package_case(
utils.safe_snake(part, self.package_safe_prefix))
def _class_name(self, name: str) -> str:
return self.class_case(utils.safe_snake(name, self.class_safe_prefix))
def _attribute_name(self, name: str) -> str:
return self.field_case(utils.safe_snake(name, self.field_safe_prefix))
def _module_name(self, name: str) -> str:
return self.module_case(
utils.safe_snake(clean_uri(name), self.module_safe_prefix))
def constant_name(name: str) -> str:
"""Apply python conventions for constant names."""
return text.snake_case(utils.safe_snake(name)).upper()
def attribute_name(name: str) -> str:
"""Apply python conventions for instance variable names."""
return text.snake_case(utils.safe_snake(name))
def test_with_stop_words(self):
self.assertEqual("def_value", safe_snake("def"))
def class_name(name: str) -> str:
"""Apply python conventions for class names."""
return text.pascal_case(utils.safe_snake(name, "type"))
def module_name(cls, name: str) -> str:
return text.snake_case(safe_snake(name, default="mod"))
def package_name(cls, name: str) -> str:
return ".".join(
map(
lambda x: text.snake_case(safe_snake(x, default="pkg")), name.split(".")
)
)
def class_name(cls, name: str) -> str:
"""Convert class names to pascal case."""
return text.pascal_case(safe_snake(name, "type"))
