msgspec-xml 0.1.1__tar.gz → 0.2.0__tar.gz

{msgspec_xml-0.1.1 → msgspec_xml-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: msgspec-xml
-Version: 0.1.1
+Version: 0.2.0
 Summary: XML Serialization/Deserialization using msgspec
 Project-URL: Homepage, https://pypi.org/project/msgspec-xml
 Project-URL: Issues, https://codefloe.com/buriedincode/msgspec-xml/issues

{msgspec_xml-0.1.1 → msgspec_xml-0.2.0}/msgspec_xml/__init__.py

@@ -1,5 +1,5 @@
 __all__ = ["XML", "Decoder", "Encoder", "decode", "encode"]
-__version__ = "0.1.1"
+__version__ = "0.2.0"
 
 from msgspec_xml.decoder import Decoder, decode
 from msgspec_xml.encoder import Encoder, encode

{msgspec_xml-0.1.1 → msgspec_xml-0.2.0}/msgspec_xml/decoder.py

@@ -10,9 +10,11 @@ from msgspec.structs import FieldInfo, fields
 from msgspec_xml.introspection import (
     FieldType,
     attribute_name,
+    class_namespaces,
     element_tag,
     inspect_annotation,
     item_tag,
+    wrapper_tag,
 )
 
 T = TypeVar("T", bound=Struct)
@@ -34,25 +36,29 @@ def decode(xml: str | bytes, type_: type[T]) -> T:
 
 
 def _decode_struct(element: Element, cls: type[Struct]) -> dict[str, Any]:
+    namespaces = class_namespaces(cls=cls)
     result: dict[str, Any] = {}
     for field in fields(cls):
         info = inspect_annotation(annotation=field.type)
-        value = _decode_field(element=element, field=field, info=info)
+        value = _decode_field(element=element, field=field, info=info, namespaces=namespaces)
         if value is not _MISSING:
             result[field.encode_name] = value
     return result
 
 
-def _decode_field(element: Element, field: FieldInfo, info: FieldType) -> Any:  # noqa: ANN401
+def _decode_field(
+    element: Element, field: FieldInfo, info: FieldType, namespaces: dict[str, str]
+) -> Any:  # noqa: ANN401
     xml = info.xml
     if xml.attr:
-        name = attribute_name(field=field, info=info)
+        name = attribute_name(field=field, info=info, namespaces=namespaces)
         return element.attrib.get(name, _MISSING)
     if xml.text:
         return (element.text or "").strip()
     if info.item is not None:
-        return _decode_list(element=element, field=field, info=info)
-    child = element.find(element_tag(field=field, info=info))
+        return _decode_list(element=element, field=field, info=info, namespaces=namespaces)
+    tag = element_tag(field=field, info=info, namespaces=namespaces)
+    child = element.find(tag)
     if child is None:
         return _MISSING
     if info.is_struct:
@@ -60,13 +66,16 @@ def _decode_field(element: Element, field: FieldInfo, info: FieldType) -> Any:
     return (child.text or "").strip()
 
 
-def _decode_list(element: Element, field: FieldInfo, info: FieldType) -> list[Any]:
+def _decode_list(
+    element: Element, field: FieldInfo, info: FieldType, namespaces: dict[str, str]
+) -> list[Any]:
     item = info.item
     assert item is not None  # noqa: S101
-    parent = element.find(info.xml.wrapper) if info.xml.wrapper else element
+    wrapper = wrapper_tag(info=info, namespaces=namespaces)
+    parent = element.find(wrapper) if wrapper else element
     if parent is None:
         return []
-    tag = item_tag(field=field, info=info)
+    tag = item_tag(field=field, info=info, namespaces=namespaces)
     return [_decode_item(element=child, item=item) for child in parent.findall(tag)]
 
 

msgspec_xml-0.2.0/msgspec_xml/encoder.py

@@ -0,0 +1,109 @@
+__all__ = ["Encoder", "encode"]
+
+from xml.etree import ElementTree as ET
+from xml.etree.ElementTree import Element
+
+from msgspec import Struct, to_builtins
+from msgspec.structs import FieldInfo, fields
+
+from msgspec_xml.introspection import (
+    FieldType,
+    attribute_name,
+    class_namespaces,
+    class_tag,
+    element_tag,
+    inspect_annotation,
+    item_tag,
+    wrapper_tag,
+)
+
+
+class Encoder:
+    def __init__(
+        self,
+        indent: int | None = None,
+        xml_declaration: bool = False,
+        short_empty_elements: bool = True,
+    ) -> None:
+        if indent is not None and indent < 0:
+            raise ValueError("'indent' must be a non-negative integer")
+        self.indent = indent
+        self.xml_declaration = xml_declaration
+        self.short_empty_elements = short_empty_elements
+
+    def encode(self, obj: Struct) -> bytes:
+        root = _encode_struct(obj=obj, tag=class_tag(cls=type(obj)))
+        if self.indent is not None:
+            ET.indent(root, space=" " * self.indent)
+        return ET.tostring(
+            root,
+            encoding="UTF-8",
+            xml_declaration=self.xml_declaration,
+            short_empty_elements=self.short_empty_elements,
+        )
+
+
+def encode(
+    obj: Struct,
+    indent: int | None = None,
+    xml_declaration: bool = False,
+    short_empty_elements: bool = True,
+) -> bytes:
+    return Encoder(
+        indent=indent, xml_declaration=xml_declaration, short_empty_elements=short_empty_elements
+    ).encode(obj=obj)
+
+
+def _encode_struct(obj: Struct, tag: str) -> Element:
+    cls = type(obj)
+    namespaces = class_namespaces(cls=cls)
+    for prefix, uri in namespaces.items():
+        ET.register_namespace(prefix, uri)
+    element = ET.Element(tag)
+    for field in fields(cls):
+        value = getattr(obj, field.name)
+        if value is None:
+            continue
+        info = inspect_annotation(annotation=field.type)
+        _encode_field(element=element, field=field, info=info, value=value, namespaces=namespaces)
+    return element
+
+
+def _encode_field(
+    element: Element, field: FieldInfo, info: FieldType, value: object, namespaces: dict[str, str]
+) -> None:
+    xml = info.xml
+    if xml.attr:
+        name = attribute_name(field=field, info=info, namespaces=namespaces)
+        element.set(name, _stringify(value=value))
+    elif xml.text:
+        element.text = _stringify(value)
+    elif info.item is not None:
+        _encode_list(element=element, field=field, info=info, value=value, namespaces=namespaces)  # ty: ignore[invalid-argument-type]
+    elif info.is_struct:
+        struct_tag = element_tag(field=field, info=info, namespaces=namespaces)
+        element.append(_encode_struct(obj=value, tag=struct_tag))  # ty: ignore[invalid-argument-type]
+    else:
+        tag = element_tag(field=field, info=info, namespaces=namespaces)
+        child = ET.SubElement(element, tag)
+        child.text = _stringify(value)
+
+
+def _encode_list(
+    element: Element, field: FieldInfo, info: FieldType, value: list, namespaces: dict[str, str]
+) -> None:
+    item = info.item
+    assert item is not None  # noqa: S101
+    wrapper = wrapper_tag(info=info, namespaces=namespaces)
+    parent = ET.SubElement(element, wrapper) if wrapper else element
+    tag = item_tag(field=field, info=info, namespaces=namespaces)
+    for item_value in value:
+        if item.is_struct:
+            parent.append(_encode_struct(obj=item_value, tag=tag))
+        else:
+            child = ET.SubElement(parent, tag)
+            child.text = _stringify(item_value)
+
+
+def _stringify(value: object) -> str:
+    return str(to_builtins(value))

{msgspec_xml-0.1.1 → msgspec_xml-0.2.0}/msgspec_xml/introspection.py

@@ -1,10 +1,13 @@
 __all__ = [
     "FieldType",
     "attribute_name",
+    "class_namespaces",
     "class_tag",
     "element_tag",
     "inspect_annotation",
     "item_tag",
+    "qualify",
+    "wrapper_tag",
 ]
 
 from types import NoneType
@@ -45,29 +48,59 @@ def class_tag(cls: type[Struct]) -> str:
     return cls.__name__
 
 
-def attribute_name(field: FieldInfo, info: FieldType) -> str:
-    return info.xml.tag or field.encode_name
+def class_namespaces(cls: type[Struct]) -> dict[str, str]:
+    return getattr(cls, "__namespaces__", {})
 
 
-def element_tag(field: FieldInfo, info: FieldType) -> str:
+def attribute_name(field: FieldInfo, info: FieldType, namespaces: dict[str, str]) -> str:
+    name = info.xml.tag or field.encode_name
+    return qualify(tag=name, ns=_resolve_ns(prefix=info.xml.ns, namespaces=namespaces))
+
+
+def element_tag(field: FieldInfo, info: FieldType, namespaces: dict[str, str]) -> str:
     if info.xml.tag:
-        return info.xml.tag
-    if info.is_struct:
-        return class_tag(cls=info.type)
-    return field.encode_name
+        name = info.xml.tag
+    elif info.is_struct:
+        name = class_tag(cls=info.type)
+    else:
+        name = field.encode_name
+    return qualify(tag=name, ns=_resolve_ns(prefix=info.xml.ns, namespaces=namespaces))
 
 
-def item_tag(field: FieldInfo, info: FieldType) -> str:
+def item_tag(field: FieldInfo, info: FieldType, namespaces: dict[str, str]) -> str:
     item = info.item
     if item is None:
         raise TypeError("item_tag() requires a list field")
+    prefix = item.xml.ns if item.xml.ns is not None else info.xml.ns
     if item.xml.tag:
-        return item.xml.tag
-    if info.xml.tag:
-        return info.xml.tag
-    if item.is_struct:
-        return class_tag(cls=item.type)
-    return field.encode_name
+        name = item.xml.tag
+    elif info.xml.tag:
+        name = info.xml.tag
+    elif item.is_struct:
+        name = class_tag(cls=item.type)
+    else:
+        name = field.encode_name
+    return qualify(tag=name, ns=_resolve_ns(prefix=prefix, namespaces=namespaces))
+
+
+def wrapper_tag(info: FieldType, namespaces: dict[str, str]) -> str | None:
+    if info.xml.wrapper is None:
+        return None
+    return qualify(tag=info.xml.wrapper, ns=_resolve_ns(prefix=info.xml.ns, namespaces=namespaces))
+
+
+def qualify(tag: str, ns: str | None) -> str:
+    return f"{{{ns}}}{tag}" if ns else tag
+
+
+def _resolve_ns(prefix: str | None, namespaces: dict[str, str]) -> str | None:
+    if prefix is None:
+        return None
+    if prefix not in namespaces:
+        raise ValueError(
+            f"Namespace prefix {prefix!r} is not declared in this Struct's __namespaces__."
+        )
+    return namespaces[prefix]
 
 
 def _split_xml(annotation: Any) -> tuple[Any, XML]:  # noqa: ANN401

{msgspec_xml-0.1.1 → msgspec_xml-0.2.0}/msgspec_xml/metadata.py

@@ -8,6 +8,7 @@ class XML(Struct, frozen=True, forbid_unknown_fields=True):
     wrapper: str | None = None
     attr: bool = False
     text: bool = False
+    ns: str | None = None
 
     def __post_init__(self) -> None:
         if self.attr and self.text:
@@ -16,10 +17,14 @@ class XML(Struct, frozen=True, forbid_unknown_fields=True):
             raise ValueError("Wrapper elements cannot be used on XML attributes.")
         if self.wrapper is not None and self.text:
             raise ValueError("Wrapper elements cannot be used on XML text.")
+        if self.ns is not None and self.text:
+            raise ValueError("Namespaces cannot be used on XML text.")
         if self.tag == "":
             raise ValueError("tag cannot be empty.")
         if self.wrapper == "":
             raise ValueError("wrapper cannot be empty.")
+        if self.ns == "":
+            raise ValueError("ns cannot be empty.")
 
     @property
     def is_element(self) -> bool: