def make_test_cases(path: Path, group: TestGroup): schema_href = None schema_is_valid = False if (group.schema_test and group.schema_test.schema_document and group.schema_test.schema_document[0].href): schema_doc = group.schema_test.schema_document[0].href schema_validity = validity(group.schema_test.expected) if (group.name in ("wildZ003", "ctZ007") and len(group.schema_test.schema_document) > 0 and group.schema_test.schema_document[1].href): schema_doc = group.schema_test.schema_document[1].href schema_href = path.joinpath(schema_doc).resolve().relative_to(w3c) schema_is_valid = schema_validity.validity == ExpectedOutcome.VALID schema_name = text.snake_case(group.name) documentation = make_docstring(group) structure_style = "filenames" if group.name in ("schD5", "schD7", "xsd003b", "over015"): structure_style = "namespaces" elif group.name in ("addB132", "ctZ007"): structure_style = "single-package" for instance in group.instance_test: if not instance.instance_document or not instance.instance_document.href: raise ValueError("Missing instance document!") instance_path = path.joinpath( instance.instance_document.href).resolve() instance_href = instance_path.relative_to(w3c) instance_validity = validity(instance.expected) class_name = read_root_name(instance_path) version = pick_version(group.version) instance_is_valid = instance_validity.validity == ExpectedOutcome.VALID schema_path = str(schema_href) or "" if schema_path and instance_is_valid and schema_is_valid: yield TestCase( path=path, version=version, documentation=documentation, schema_name=schema_name, schema_path=schema_path, instance_name=text.snake_case(instance.name), instance_path=str(instance_href), class_name=class_name, structure_style=structure_style, )
def rename_attributes_with_index(cls, attrs: List[Attr], rename: List[Attr]): """Append the next available index number to all the rename attributes names.""" for index in range(1, len(rename)): num = 1 name = text.snake_case(rename[index].name) while any( text.snake_case(attr.name) == text.snake_case( f"{name}_{num}") for attr in attrs): num += 1 rename[index].name = f"{rename[index].name}_{num}"
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 test_snake_case(self): self.assertEqual("p00p", snake_case("p00p")) self.assertEqual("username", snake_case("USERName")) self.assertEqual("user_name", snake_case("UserNAME")) self.assertEqual("user_name", snake_case("USER_name")) self.assertEqual("user_name", snake_case("USER-NAME")) self.assertEqual("user_name", snake_case("User_Name")) self.assertEqual("user_name", snake_case("user_name")) self.assertEqual("suser_name", snake_case("SUserNAME"))
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 emit_event(self, event: str, name: str, **kwargs: Any): """Call if exist the parser's hook for the given element and event.""" if name not in self.event_names: self.event_names[name] = text.snake_case(QName(name).localname) method_name = f"{event}_{self.event_names[name]}" if hasattr(self, method_name): getattr(self, method_name)(**kwargs)
def process_duplicate_attribute_names(cls, attrs: List[Attr]) -> None: """Sanitize duplicate attribute names that might exist by applying rename strategies.""" grouped = group_by(attrs, lambda attr: text.snake_case(attr.name)) for items in grouped.values(): total = len(items) if total == 2 and not items[0].is_enumeration: cls.rename_attribute_by_preference(*items) elif total > 1: cls.rename_attributes_with_index(attrs, items)
def create(cls: Type[T], **kwargs) -> T: if not kwargs.get("ns_map"): kwargs.update({"ns_map": {"xs": Namespace.XS.uri}}) kwargs = { text.snake_case(etree.QName(key).localname): value for key, value in kwargs.items() if value is not None } data = { attr.name: kwargs[attr.name] for attr in fields(cls) if attr.name in kwargs } return cls(**data)
def package_name(cls, name): return text.snake_case(name)
def module_name(cls, name): return text.snake_case(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 test_build_with_no_meta_name_and_name_generator(self, *args): inspect = XmlContext(name_generator=lambda x: text.snake_case(x)) result = inspect.build(ItemsType) self.assertEqual(QName("items_type"), str(result.qname))
def module_name(cls, name: str) -> str: return text.snake_case(name)
def emit_event(self, event: str, name: str, **kwargs): """Call if exist the parser's hook for the given element and event.""" local_name = text.snake_case(QName(name).localname) method_name = f"{event}_{local_name}" if hasattr(self, method_name): getattr(self, method_name)(**kwargs)
def test_class_meta_with_no_meta_name_and_name_generator(self, *args): inspect = ModelInspect(name_generator=lambda x: text.snake_case(x)) result = inspect.class_meta(ItemsType) self.assertEqual(QName("items_type"), str(result.qname))
def real_name(self) -> str: if self.test: return text.snake_case(self.test) if self.id: return self.id return "value"
def package_name(cls, name: str) -> str: return ".".join( map( lambda x: text.snake_case(safe_snake(x, default="pkg")), name.split(".") ) )
def module_name(cls, name: str) -> str: return text.snake_case(safe_snake(name, default="mod"))
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_snake_case(self): self.assertEqual("user_name", snake_case("userName")) self.assertEqual("user_name", snake_case("User.Name")) self.assertEqual("user_name", snake_case("UserName")) self.assertEqual("user_name", snake_case("USER_NAME")) self.assertEqual("user_name", snake_case("user_name")) self.assertEqual("common_v48_0", snake_case("common_v48_0")) self.assertEqual("user", snake_case("user")) self.assertEqual("user", snake_case("User")) self.assertEqual("user", snake_case("USER")) self.assertEqual("user", snake_case("_user")) self.assertEqual("user", snake_case("_User")) self.assertEqual("user", snake_case("__user")) self.assertEqual("user_name", snake_case("user__name"))
def real_name(self) -> str: if self.test: return text.snake_case(self.test) if self.id: return self.id return DEFAULT_ATTR_NAME