def test_to_python_float(self):
"""str > float in the ordering for now :("""
self.assertEqual(1.0, to_python([float], "1"))
self.assertEqual(1.0, to_python([float, str], "1"))
self.assertEqual("1", to_python([str, float], "1"))
self.assertEqual("1", to_python([str, float], "1", in_order=False))
self.assertEqual("a", to_python([float], "a"))
def test_to_python_single_value_dataclass(self):
@dataclass
class Foo:
value: int
self.assertEqual(Foo("1"), to_python([Foo], "1"))
self.assertEqual(1.0, to_python([float, UseType], "1"))
self.assertEqual(Foo("1"), to_python([Foo], "1", in_order=False))
def test_to_python_enum(self):
class QNameType(Enum):
a = QName("a")
b = QName("b")
self.assertEqual(UseType.OPTIONAL, to_python([UseType], "optional"))
self.assertEqual("optional", to_python([str, UseType], "optional"))
self.assertEqual(UseType.OPTIONAL,
to_python([str, UseType], "optional", in_order=False))
self.assertEqual(QNameType.a, to_python([QNameType], "a"))
def attribute_default(cls, attr: Attr, ns_map: Optional[Dict] = None) -> Any:
"""Normalize default value/factory by the attribute type."""
if attr.is_list:
return "list"
if attr.is_map:
return "dict"
if not isinstance(attr.default, str):
return attr.default
data_types = {
attr_type.native_code: attr_type.native_type
for attr_type in attr.types
if attr_type.native
}
local_types = list(set(data_types.values()))
default_value = to_python(local_types, attr.default, ns_map, in_order=False)
if isinstance(default_value, str):
if DataType.NMTOKENS.code in data_types:
default_value = " ".join(
filter(None, map(str.strip, re.split(r"\s+", default_value)))
)
default_value = quoteattr(default_value)
elif isinstance(default_value, float) and math.isinf(default_value):
default_value = f"float('{default_value}')"
elif isinstance(default_value, Decimal):
default_value = repr(default_value)
elif isinstance(default_value, QName):
default_value = (
f'QName("{default_value.namespace}", "{default_value.localname}")'
)
return default_value
def parse_value(
cls,
types: List[Type],
value: Any,
default: Any = None,
ns_map: Optional[Dict] = None,
tokens: bool = False,
) -> Any:
"""Convert xml string values to s python primitive type."""
if value is None:
return None if callable(default) else default
if tokens:
value = value if isinstance(value, list) else value.split()
return list(map(lambda x: to_python(types, x, ns_map), value))
return to_python(types, value, ns_map)
def parse_value(
cls,
types: List[Type],
value: Any,
default: Any = None,
ns_map: Optional[Dict] = None,
) -> Any:
"""Convert xml string values to s python primitive type."""
if value is None:
return None if callable(default) else default
return to_python(types, value, ns_map)
def attribute_default(attr: Attr, ns_map: Optional[Dict] = None) -> Any:
"""Generate the field default value/factory for the given attribute."""
if attr.is_list:
return "list"
if attr.is_map:
return "dict"
if not isinstance(attr.default, str):
return attr.default
data_types = {
attr_type.native_code: attr_type.native_type
for attr_type in attr.types if attr_type.native
}
local_types = list(set(data_types.values()))
default_value = to_python(local_types,
attr.default,
ns_map,
in_order=False)
if isinstance(default_value, str):
if DataType.NMTOKENS.code in data_types:
default_value = quoteattr(" ".join(
filter(None, map(str.strip, re.split(r"\s+", default_value)))))
elif default_value.startswith("@enum@"):
source, enumeration = default_value[6:].split("::", 1)
attr_type = next(attr_type for attr_type in attr.types
if attr_type.name == source)
if attr_type.alias:
source = attr_type.alias
default_value = f"{class_name(source)}.{constant_name(enumeration)}"
else:
default_value = quoteattr(default_value)
elif isinstance(default_value, float) and math.isinf(default_value):
default_value = f"float('{default_value}')"
elif isinstance(default_value, Decimal):
default_value = repr(default_value)
elif isinstance(default_value, QName):
default_value = (
f'QName("{default_value.namespace}", "{default_value.localname}")')
return default_value
def test_to_python_qname(self):
ns_map = {"foo": "bar"}
self.assertIsNone(to_python([QName], None, ns_map))
self.assertEqual(QName("bar", "x"), to_python([QName], "foo:x",
ns_map))
self.assertEqual(QName("bar"), to_python([QName], "bar", None))
def test_to_python_boolean(self):
"""str > float in the ordering for now :("""
for val in ("1", "true"):
self.assertEqual(True, to_python([bool], val))
self.assertEqual(True, to_python([bool, str], val))
self.assertEqual(val, to_python([str, bool], val))
self.assertEqual(True, to_python([str, bool], val, in_order=False))
for val in ("0", "false"):
self.assertEqual(False, to_python([bool], val))
self.assertEqual(False, to_python([bool, str], val))
self.assertEqual(val, to_python([str, bool], val))
self.assertEqual(False, to_python([str, bool], val,
in_order=False))
self.assertEqual("a", to_python([bool], "a"))
self.assertEqual(True, to_python([bool], "1 "))
self.assertEqual(False, to_python([bool], "false "))
def test_to_python_integer(self):
self.assertEqual(1, to_python([int], "1"))
self.assertEqual(1, to_python([int, str], "1"))
self.assertEqual("1", to_python([str, int], "1"))
self.assertEqual(1, to_python([str, int], "1", in_order=False))
self.assertEqual("a", to_python([int], "a"))
def test_to_python_unhandled_type(self):
class Foo:
pass
self.assertEqual("1", to_python([Foo], "1"))
def test_to_python_enum(self):
self.assertEqual(UseType.OPTIONAL, to_python([UseType], "optional"))
self.assertEqual("optional", to_python([str, UseType], "optional"))
self.assertEqual(UseType.OPTIONAL,
to_python([str, UseType], "optional", in_order=False))
