def test_parse_value(self, mock_deserialize):
self.assertEqual(1, ParserUtils.parse_value(None, [int], 1))
self.assertIsNone(ParserUtils.parse_value(None, [int], lambda: 1))
self.assertTrue(2, ParserUtils.parse_value("1", [int], None))
mock_deserialize.assert_called_once_with("1", [int],
ns_map=None,
format=None)
def test_parse_value_with_tokens_true(self):
actual = ParserUtils.parse_value(" 1 2 3", [int], list, None, True)
self.assertEqual([1, 2, 3], actual)
actual = ParserUtils.parse_value(["1", "2", "3"], [int], list, None, True)
self.assertEqual([1, 2, 3], actual)
actual = ParserUtils.parse_value(None, [int], lambda: [1, 2, 3], None, True)
self.assertEqual([1, 2, 3], actual)
def test_parse_value_with_ns_map(self, mock_to_python):
ns_map = dict(a=1)
ParserUtils.parse_value(" 1 2 3", [int], list, ns_map, True)
ParserUtils.parse_value(" 1 2 3", [str], None, ns_map, False)
self.assertEqual(4, mock_to_python.call_count)
mock_to_python.assert_has_calls([
mock.call("1", [int], ns_map=ns_map, format=None),
mock.call("2", [int], ns_map=ns_map, format=None),
mock.call("3", [int], ns_map=ns_map, format=None),
mock.call(" 1 2 3", [str], ns_map=ns_map, format=None),
])
def parse_value(cls, value: Any, var: XmlVar) -> Any:
"""Convert any value to one of the given var types."""
return ParserUtils.parse_value(value,
var.types,
var.default,
ns_map=EMPTY_MAP,
tokens=var.tokens)
def bind_value(self, var: XmlVar, value: Any) -> Any:
"""
Bind value according to the class var.
The return value can be:
- a dataclass instance
- a dictionary with unknown attributes
- a list of unknown elements
- an enumeration
- a primitive value
"""
if var.dataclass and var.clazz:
return self.parse_context(value, var.clazz)
if var.is_attributes:
return dict(value)
if var.is_wildcard:
return (value if isinstance(value, str) else self.parse_context(
value, AnyElement))
return ParserUtils.parse_value(var.types,
value,
var.default,
tokens=var.is_tokens)
def bind(self, qname: str, text: NoneStr, tail: NoneStr, objects: List) -> bool:
obj: Any = None
if self.has_children:
obj = AnyElement(
qname=qname,
text=ParserUtils.normalize_content(text),
tail=ParserUtils.normalize_content(tail),
attributes=ParserUtils.parse_any_attributes(self.attrs, self.ns_map),
children=ParserUtils.fetch_any_children(self.position, objects),
)
objects.append((self.var.qname, obj))
else:
var = self.var
ns_map = self.ns_map
datatype = ParserUtils.data_type(self.attrs, self.ns_map)
obj = ParserUtils.parse_value(text, [datatype.type], var.default, ns_map)
if var.derived:
obj = DerivedElement(qname=qname, value=obj)
objects.append((qname, obj))
if self.mixed:
tail = ParserUtils.normalize_content(tail)
if tail:
objects.append((None, tail))
return True
def parse_element(self, element: Element, objects: List) -> Tuple:
qname = QName(element.tag)
value = element.text
ns_map = element.nsmap
obj = ParserUtils.parse_value(self.types, value, self.default, ns_map,
self.tokens)
return qname, obj
def parse_value(self, value: Any, types: List[Type]) -> Any:
"""Parse simple values, treat warnings as errors and return None."""
try:
with warnings.catch_warnings():
warnings.filterwarnings("error", category=ConverterWarning)
return ParserUtils.parse_value(value,
types,
ns_map=self.ns_map)
except Exception:
return None
def bind(self, qname: str, text: NoneStr, tail: NoneStr, objects: List) -> bool:
var = self.var
ns_map = self.ns_map
obj = ParserUtils.parse_value(text, var.types, var.default, ns_map, var.tokens)
if var.derived:
obj = DerivedElement(qname=qname, value=obj)
objects.append((qname, obj))
return True
def parse_value(
cls,
value: Any,
types: List[Type],
default: Any,
tokens: bool,
fmt: Optional[str],
) -> Any:
"""Convert any value to one of the given var types."""
return ParserUtils.parse_value(value, types, default, EMPTY_MAP,
tokens, fmt)
def parse_element(self, element: Element, objects: List) -> Tuple:
"""
Parse the given element text according to the node possible types.
:return: A tuple of the object's qualified name and the new object.
"""
qname = QName(element.tag)
value = element.text
ns_map = element.nsmap
obj = ParserUtils.parse_value(self.var.types, value, self.var.default,
ns_map, self.var.is_tokens)
return qname, obj
def bind(self, qname: str, text: NoneStr, tail: NoneStr,
objects: List) -> bool:
obj = ParserUtils.parse_value(
text,
self.var.types,
self.var.default,
self.ns_map,
self.var.tokens,
self.var.format,
)
if obj is None and not self.var.nillable:
obj = ""
if self.var.derived:
obj = DerivedElement(qname=qname, value=obj)
objects.append((qname, obj))
return True
def bind(self, qname: str, text: NoneStr, tail: NoneStr,
objects: List) -> bool:
obj = ParserUtils.parse_value(
text,
[self.datatype.type],
None,
self.ns_map,
False,
self.datatype.format,
)
if obj is None and not self.nillable:
obj = ""
if self.datatype.wrapper:
obj = self.datatype.wrapper(obj)
if self.derived:
obj = DerivedElement(qname=qname, value=obj)
objects.append((qname, obj))
return True
def test_parse_value(self, mock_to_python):
self.assertEqual(1, ParserUtils.parse_value([int], None, 1))
self.assertIsNone(ParserUtils.parse_value([int], None, lambda: 1))
self.assertTrue(2, ParserUtils.parse_value([int], "1", None))
mock_to_python.assert_called_once_with([int], "1", None)
def test_parse_value_with_format(self, mock_to_python):
ParserUtils.parse_value(" 1 2 3", [str], list, _format="Nope")
self.assertEqual(1, mock_to_python.call_count)
mock_to_python.assert_called_once_with(" 1 2 3", [str],
ns_map=None,
format="Nope")
