smartXML 1.0.8__py3-none-any.whl

smartXML/_elements_utils.py

@@ -0,0 +1,75 @@
+def _find_one_in_sons(
+    element: "Element",
+    names_list: list[str],
+    with_content: str = None,
+) -> "Element":
+    if not names_list:
+        return element
+    for name in names_list:
+        for son in element._sons:
+            if _check_match(son, name):
+                found = _find_one_in_sons(son, names_list[1:], with_content)
+                if found:
+                    if with_content is None or found.content == with_content:
+                        return found
+    return None
+
+
+def _check_match(element: "Element", names: str) -> bool:
+    if names and element.name != names:
+        return False
+    return True
+
+
+def _find_one(element: "Element", names: str, with_content: str) -> "Element":
+
+    if _check_match(element, names):
+        if with_content is None or element.content == with_content:
+            return element
+
+    names_list = names.split("|")
+
+    if len(names_list) > 1:
+        if element.name == names_list[0]:
+            found = _find_one_in_sons(element, names_list[1:], with_content)
+            if found:
+                return found
+
+    for son in element._sons:
+        found = _find_one(son, names, with_content)
+        if found:
+            return found
+    return None
+
+
+def _find_all(element: "Element", names: str, with_content: str) -> list["Element"]:
+    results = []
+    if _check_match(element, names=names):
+        if with_content is None or element.content == with_content:
+            results.extend([element])
+            for son in element._sons:
+                results.extend(_find_all(son, names, with_content))
+            return results
+
+    names_list = names.split("|")
+
+    if _check_match(element, names_list[0]):
+        if with_content is None or element.content == with_content:
+            sons = []
+            sons.extend(element._sons)
+            match = []
+            for index, name in enumerate(names_list[1:]):
+                for son in sons:
+                    if son.name == name:
+                        if index == len(names_list) - 2:
+                            results.append(son)
+                        else:
+                            match.extend(son._sons)
+                sons.clear()
+                sons.extend(match)
+                match.clear()
+
+    for son in element._sons:
+        results.extend(_find_all(son, names, with_content))
+
+    return results

smartXML/element.py

@@ -0,0 +1,250 @@
+from typing import Union
+import warnings
+
+from ._elements_utils import (
+    _find_one,
+    _find_all,
+)
+
+class IllegalOperation(Exception):
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(self.message)
+
+
+
+class ElementBase:
+    def __init__(self, name: str):
+        self._name = name
+        self._sons = []
+        self._parent = None
+
+    def is_comment(self) -> bool:
+        """Check if the element is a comment."""
+        return False
+
+    @property
+    def parent(self):
+        """Get the parent of the element."""
+        return self._parent
+    @property
+    def name(self) -> str:
+        """Get the name of the element."""
+        return self._name
+
+    @name.setter
+    def name(self, new_name: str):
+        """Set the name of the element."""
+        if not new_name or new_name[0].isdigit():
+            raise ValueError(f"Invalid tag name '{new_name}'")
+        self._name = new_name
+
+    def to_string(self, indentation: str = "\t") -> str:
+        """
+        Convert the XML tree to a string.
+        :param indentation: string used for indentation, default is tab character
+        :return: XML string
+        """
+        return self._to_string(0, indentation)
+
+    def _to_string(self, index: int, indentation: str) -> str:
+        pass
+
+    def get_path(self) -> str:
+        """ Get the full path of the element
+        returns: the path as a string from the root of the XML tree, separated by |.
+        """
+        elements = []
+        current = self
+        while current is not None:
+            elements.append(current._name)
+            current = current._parent
+        return "|".join(reversed(elements))
+
+    def add_before(self, sibling: "Element"):
+        """Add this element before the given sibling element."""
+        parent = sibling._parent
+        if parent is None:
+            raise ValueError(f"Element {sibling.name} has no parent")
+        index = parent._sons.index(sibling)
+        parent._sons.insert(index, self)
+        self._parent = parent
+
+    def add_after(self, sibling: "Element"):
+        """Add this element after the given sibling element."""
+        parent = sibling._parent
+        if parent is None:
+            raise ValueError(f"Element {sibling.name} has no parent")
+        index = parent._sons.index(sibling)
+        parent._sons.insert(index + 1, self)
+        self._parent = parent
+
+    def add_as_son_of(self, parent: "Element"):
+        """Add this element as a son of the given parent element."""
+        warnings.warn(
+            "add_as_son_of() is deprecated and will be removed in version 1.1.0 . add_before() ot add_after() instead.",
+            category=DeprecationWarning,
+            stacklevel=2
+        )
+        parent._sons.append(self)
+        self._parent = parent
+
+    def set_as_parent_of(self, son: "Element"):
+        """Set this element as the parent of the given son element."""
+        warnings.warn(
+            "set_as_parent_of() is deprecated and will be removed in version 1.1.0 . add_before() ot add_after() instead.",
+            category=DeprecationWarning,
+            stacklevel=2
+        )
+        self._sons.append(son)
+        son._parent = self
+
+    def remove(self):
+        """Remove this element from its parent's sons."""
+        self._parent._sons.remove(self)
+        self._parent = None
+
+
+class TextOnlyComment(ElementBase):
+    """A comment that only contains text, not other elements."""
+    def __init__(self, text: str):
+        super().__init__("")
+        self._text = text
+
+    def is_comment(self) -> bool:
+        return True
+
+    def _to_string(self, index: int, indentation: str) -> str:
+        indent = indentation * index
+        return f"{indent}<!-- {self._text} -->\n"
+
+
+class CData(ElementBase):
+    """A CDATA section that contains text."""
+    def __init__(self, text: str):
+        super().__init__("")
+        self._text = text
+
+    def _to_string(self, index: int, indentation: str) -> str:
+        indent = indentation * index
+        return f"{indent}<![CDATA[{self._text}]]>\n"
+
+
+class Doctype(ElementBase):
+    """A DOCTYPE declaration."""
+    def __init__(self, text: str):
+        super().__init__("")
+        self._text = text
+
+    def _to_string(self, index: int, indentation: str) -> str:
+        indent = indentation * index
+        sons_indent = indentation * (index + 1)
+        children_str = ""
+        for son in self._sons:
+            if isinstance(son, TextOnlyComment):
+                children_str = children_str + son._to_string(index + 1, indentation)
+            else:
+                children_str = children_str + sons_indent + "<" + son.name + ">\n"
+        if children_str:
+            return f"{indent}<{self._text}[\n{children_str}{indent}]>\n"
+        else:
+            return f"{indent}<![CDATA[{self._text}]]>\n"
+
+
+class Element(ElementBase):
+    """An XML element that can contain attributes, content, and child elements."""
+    def __init__(self, name: str):
+        super().__init__(name)
+        self.content = ""
+        self.attributes = {}
+        self._is_empty = False  # whether the element is self-closing
+
+    def comment_out(self):
+        """Convert this element into a comment.
+        raises IllegalOperation, if any parent or any descended is a comment
+        """
+        def find_comment_son(element: "Element") -> bool:
+            if element.is_comment():
+                return True
+            for son in element._sons:
+                if find_comment_son(son):
+                    return True
+            return False
+
+        parent = self.parent
+        while parent:
+            if parent.is_comment():
+                raise IllegalOperation("Cannot comment out an element whose parent is a comment")
+            parent = parent.parent
+
+        for son in self._sons:
+            if find_comment_son(son):
+                raise IllegalOperation("Cannot comment out an element whose descended is a comment")
+
+        self.__class__ = Comment
+
+    def _to_string(self, index: int, indentation: str, with_endl=True) -> str:
+        indent = indentation * index
+
+        attributes_str = " ".join(
+            f'{key}="{value}"' for key, value in self.attributes.items()  # f-string formats the pair as key="value"
+        )
+
+        attributes_part = f" {attributes_str}" if attributes_str else ""
+
+        if self._is_empty:
+            result = f"{indent}<{self.name}{attributes_part}/>"
+        else:
+            opening_tag = f"<{self.name}{attributes_part}>"
+            closing_tag = f"</{self.name}>"
+
+            children_str = "".join(son._to_string(index + 1, indentation) for son in self._sons)
+
+            if children_str:
+                result = f"{indent}{opening_tag}{self.content}\n{children_str}{indent}{closing_tag}"
+            else:
+                result = f"{indent}{opening_tag}{self.content}{closing_tag}"
+
+        if with_endl:
+            result += "\n"
+        return result
+
+    def find(
+        self,
+        name: str = None,
+        only_one: bool = True,
+        with_content: str = None,
+    ) -> Union["Element", list["Element"], None]:
+        """
+        Find element(s) by name or content or both
+        :param name: name of the element to find, can be nested using |, e.g. "parent|child|subchild"
+        :param only_one: stop at first find or return all found elements
+        :param with_content: filter by content
+        :return: the elements found,
+                if found, return the elements that match the last name in the path,
+                if not found, return None if only_one is True, else return empty list
+        """
+        if only_one:
+            return _find_one(self, name, with_content=with_content)
+        else:
+            return _find_all(self, name, with_content=with_content)
+
+
+class Comment(Element):
+    """An XML comment that can contain other elements."""
+    def __init__(self, name: str):
+        super().__init__(name)
+
+    def is_comment(self) -> bool:
+        return True
+
+    def uncomment(self):
+        """Convert this comment back into a normal element."""
+        self.__class__ = Element
+
+    def _to_string(self, index: int, indentation: str) -> str:
+        indent = indentation * index
+        if len(self._sons) == 0:
+            return f"{indent}<!-- {super()._to_string(0, indentation, False)} -->\n"
+        else:
+            return f"{indent}<!--\n{super()._to_string(index +1, indentation, False)}\n{indent}-->\n"

smartXML/xmltree.py

@@ -0,0 +1,321 @@
+from pathlib import Path
+from enum import Enum
+import re
+from typing import Any
+
+from .element import ElementBase, Element, Comment, CData, Doctype, TextOnlyComment
+
+
+class BadXMLFormat(Exception):
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(self.message)
+
+
+class TokenType(Enum):
+    comment_start = 1
+    full = 2
+    closing = 3
+    content = 4
+    c_data = 5
+    doctype = 6
+
+
+def _divide_to_tokens(file_content):
+    tokens = []
+
+    last_char = ""
+    last_index = 0
+
+    index = 0
+    while index < len(file_content):
+        char = file_content[index]
+
+        if char == "!" and index < len(file_content) + 10:
+            # check fot CDATA:
+            if file_content[index : index + 8] == "![CDATA[" and last_char == "<":
+                cdata_end = file_content.find("]]>", index)
+                if cdata_end == -1:
+                    raise BadXMLFormat("Malformed CDATA section")
+                cdata_content = file_content[index + 8 : cdata_end]
+                tokens.append((TokenType.c_data, cdata_content))
+                last_index = cdata_end + 2
+                last_char = ">"
+                index = last_index + 1
+                continue
+            elif file_content[index : index + 8] == "!DOCTYPE":
+                start = file_content.find("[", index)
+                if start == -1:
+                    raise BadXMLFormat("Malformed DOCTYPE declaration")
+                doctype = file_content[index:start]
+                tokens.append((TokenType.doctype, doctype))
+
+                last_char = ""
+                last_index = start + 1
+                index = start + 1
+                continue
+
+        if char == ">":
+            if last_char == "<":
+                tokens.append((TokenType.full, file_content[last_index + 1 : index].strip()))
+            else:
+                tokens.append((TokenType.closing, file_content[last_index + 1 : index].strip()))
+            last_char = char
+            last_index = index
+        elif char == "<":
+            if last_char == "<":
+                # this is a case of opening a comment of type <!-- TAG>...</TAG --> (or bad format)
+                tokens.append((TokenType.comment_start, file_content[last_index + 1 : index].strip()))
+            if last_char == ">":
+                text = file_content[last_index + 1 : index - 1].strip()
+                if text:
+                    tokens.append((TokenType.content, file_content[last_index + 1 : index].strip()))
+            last_char = char
+            last_index = index
+        index += 1
+
+    return tokens
+
+
+def _add_ready_token(ready_nodes, element: ElementBase, depth: int):
+    if depth in ready_nodes:
+        ready_nodes[depth].append(element)
+    else:
+        ready_nodes[depth] = [element]
+
+    if depth + 1 in ready_nodes:
+        element._sons = ready_nodes[depth + 1]
+        del ready_nodes[depth + 1]
+        for son in element._sons:
+            son._parent = element
+
+
+def _parse_element(data: str) -> Element:
+    if data[0] == "!":
+        return Element(data)
+    tag_name_match = re.match(r"(\S+)\s*(.*)", data)
+
+    if not tag_name_match:
+        raise BadXMLFormat(f'Could not parse tag name and attributes from line: "{data}"')
+    name = tag_name_match.group(1)
+    if not name[0].isalpha():
+        raise BadXMLFormat(f"Tag {name} can not starts with a number")
+    attributes_string = tag_name_match.group(2).strip()
+    attributes = {}
+
+    for match in re.compile(r"(\S+)\s*=\s*([^\s=]+|\"[^\"]*\"|\'[^\']*\')").finditer(attributes_string):
+        attr_name, attr_value = match.groups()
+        attributes[attr_name] = attr_value.strip().strip('"')
+
+    element = Element(name)
+    element.attributes = attributes
+    return element
+
+
+class SmartXML:
+    def __init__(self, data: Path = None):
+        self._file_name = data
+        self._declaration = ""
+        self._tree = None
+        self._doctype = None
+        if data:
+            self._tree, self._doctype = self._read(self._file_name)
+
+    @property
+    def tree(self) -> ElementBase:
+        """Get the root element of the XML tree."""
+        return self._tree
+
+    @property
+    def declaration(self) -> str:
+        """Get the XML declaration."""
+        return self._declaration
+
+    def _parse_declaration(self, file_content: str):
+        start = file_content.find("<?xml")
+        end = file_content.find("?>", start)
+        if (start >= 0 and end == -1) or (start == -1 and end > 0):
+            raise BadXMLFormat("Malformed XML declaration")
+        if start > 0:
+            raise BadXMLFormat("XML declaration must be at the beginning of the file")
+        if start >= 0 and end >= 0:
+            declaration = file_content[start + 5 : end].strip()
+            self._declaration = declaration
+            file_content = file_content[end + 2 :]
+
+        return file_content
+
+    def read(self, file_name: Path) -> None:
+        """
+        Read and parse the XML file into an element tree.
+        :param file_name: Path to the XML file
+        :raises:
+            TypeError: if file_name is not a pathlib.Path object
+            FileNotFoundError: if file_name does not exist
+            BadXMLFormat: if the XML format is invalid
+        """
+        if not isinstance(file_name, Path):
+            raise TypeError("file_name must be a pathlib.Path object")
+        if not file_name.exists():
+            raise FileNotFoundError(f"File {file_name} does not exist")
+
+        self._tree, self._doctype = self._read(file_name)
+
+    def _read(self, file_name: Path) -> tuple[Any, None] | tuple[Any, Any]:
+        self._file_name = file_name
+        ready_nodes = {}  # depth -> list of elements
+        incomplete_nodes = []
+        depth = 0
+
+        count_comment_start = 0
+        count_comment_end = 0
+
+        file_content = self._file_name.read_text()
+        file_content = self._parse_declaration(file_content)
+
+        tokens = _divide_to_tokens(file_content)
+
+        for token in tokens:
+            token_type = token[0]
+            data = token[1]
+
+            if token_type == TokenType.full:
+                if data.endswith("/"):
+                    data = data[:-1].strip()
+                    element = _parse_element(data)
+                    element._is_empty = True
+                    if incomplete_nodes[-1].name == "!--":
+                        element.comment_out()
+                    _add_ready_token(ready_nodes, element, depth + 1)
+
+                elif data.startswith("/"):
+                    data = data[1:].strip()
+                    element = incomplete_nodes.pop()
+                    if data.endswith("--"):
+                        # this is a case of closing a comment of type <!-- TAG>...</TAG -->
+                        data = data[:-2].strip()
+                        count_comment_end += 1
+
+                    if element.name != data:
+                        raise BadXMLFormat(f"Mismatched XML tags, opening: {element.name}, closing: {data}")
+                    _add_ready_token(ready_nodes, element, depth)
+                    depth -= 1
+
+                elif data.startswith("!--"):
+                    if incomplete_nodes and isinstance(incomplete_nodes[-1], Comment):
+                        raise BadXMLFormat("Nested comments are not allowed")
+
+                    if data.endswith("--"):
+                        element = TextOnlyComment(data[3:-2].strip())
+                        _add_ready_token(ready_nodes, element, depth + 1)
+                    else:
+                        # this is a case of opening a comment of type <!-- TAG>...</TAG -->
+                        count_comment_start += 1
+                        name = data[3:].strip()
+                        incomplete_nodes.append(Comment(name))
+                        depth += 1
+
+                else:
+                    element = _parse_element(data)
+                    if incomplete_nodes and incomplete_nodes[-1].name == "!--":
+                        element.comment_out()
+                    parent_is_doctype = incomplete_nodes and isinstance(incomplete_nodes[-1], Doctype)
+                    if parent_is_doctype:
+                        _add_ready_token(ready_nodes, element, depth + 1)
+                    else:
+                        incomplete_nodes.append(element)
+                        depth += 1
+
+            elif token_type == TokenType.comment_start:
+                if incomplete_nodes and isinstance(incomplete_nodes[-1], Comment):
+                    raise BadXMLFormat("Nested comments are not allowed")
+                count_comment_start += 1
+                if data != "!--":
+                    raise BadXMLFormat("Malformed comment closure")
+                element = Comment(data)  # This is a placeholder, indicating future soms are in a comment
+                incomplete_nodes.append(element)
+
+            elif token_type == TokenType.closing:
+                element = incomplete_nodes.pop()
+                if data == "--":
+                    count_comment_end += 1
+                if isinstance(element, Doctype):
+                    _add_ready_token(ready_nodes, element, depth)
+                    depth -= 1
+
+            elif token_type == TokenType.content:
+                incomplete_nodes[-1].content = data
+
+            elif token_type == TokenType.doctype:
+                element = Doctype(data)
+                incomplete_nodes.append(element)
+                depth += 1
+
+            elif token_type == TokenType.c_data:
+                element = CData(data)
+                _add_ready_token(ready_nodes, element, depth + 1)
+
+        if count_comment_start != count_comment_end:
+            raise BadXMLFormat("Mismatched comment tags")
+
+        if len(ready_nodes.get(1, [])) == 1:
+            return ready_nodes[1][0], None
+        if (
+            len(ready_nodes.get(1, [])) == 2
+            and isinstance(ready_nodes[1][0], Doctype)
+            and isinstance(ready_nodes[1][1], Element)
+        ):
+            return ready_nodes[1][1], ready_nodes[1][0]
+        raise BadXMLFormat("xml contains more than one outer element")
+
+    def write(self, file_name: Path = None, indentation: str = "\t") -> str | None:
+        """Write the XML tree back to the file.
+        :param file_name: Path to the XML file, if None, overwrite the original file
+        :param indentation: string used for indentation, default is tab character
+        :return: XML string if file_name is None, else None
+        :raises:
+            ValueError: if file name is not specified
+            TypeError: if file_name is not a pathlib.Path object
+            FileNotFoundError: if file_name does not exist
+        """
+
+        if file_name:
+            self._file_name = file_name
+        if not self._file_name:
+            raise ValueError("File name is not specified")
+
+        with open(self._file_name, "w") as file:
+            if self._declaration:
+                file.write(f"<?xml {self._declaration}?>\n")
+            file.write(self.to_string(indentation))
+
+    def to_string(self, indentation: str = "\t") -> str:
+        """
+        Convert the XML tree to a string.
+        :param indentation: string used for indentation, default is tab character
+        :return: XML string
+        """
+        result = self._doctype.to_string(indentation) if self._doctype else ""
+        return result + self._tree.to_string(indentation)
+
+    def find(
+        self,
+        name: str = "",
+        only_one: bool = True,
+        with_content: str = None,
+    ) -> Element | list[Element] | None:
+        """
+        Find element(s) by name or content or both
+        :param name: name of the element to find, can be nested using |, e.g. "parent|child|subchild"
+        :param only_one: stop at first find or return all found elements
+        :param with_content: filter by content
+        :return: the elements found,
+                if found, return the elements that match the last name in the path,
+                if not found, return None if only_one is True, else return empty list
+        :raises:
+            ValueError: if neither name nor with_content is provided
+
+        """
+        if not name and with_content is None:
+            raise ValueError("At least one search criteria must be provided")
+        return self._tree.find(name, only_one, with_content)

smartxml-1.0.8.dist-info/METADATA

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: smartXML
+Version: 1.0.8
+Summary: smartXML package enables you to read, search, manipulate, and write XML files with ease
+Author-email: Dudu Arbel <duduarbel@gmail.com>
+License-Expression: MIT
+Project-URL: Changelog, https://github.com/duduarbel/smartXML/blob/main/changelog.md
+Keywords: python,example
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: mypy>=1.8; extra == "dev"
+Requires-Dist: ruff>=0.3; extra == "dev"
+
+# smartXML
+
+The **smartXML** package enables you to read, search, manipulate, and write XML files with ease.
+
+The API is designed to be simple, but it will be enhanced according to usage and requests.
+The package includes a `SmartXML` representing the XML file, and `ElementBase` representing each element in the XML tree
+### SmartXML:
+- properties:
+    - `root`: the root element of the XML file
+    - `declaration`: the XML declaration (e.g., `<?xml version="1.0" encoding="UTF-8"?>`)
+- methods:
+    - `read`: reads the XML file from the root element
+    - `write`: writes the XML to a file
+    - `find`: finds elements from the root element
+
+### ElementBase: (base class for Element, Comment, TextOnlyComment, CData, and Doctype)
+- properties:
+    - `name`: the name of the element
+    - `parent`: the parent element
+- methods:
+    - `find`: finds elements from the current element
+    - `remove`: removes the current element from its parent
+    - `comment_out`: comments out the current element
+    - `add_before`: adds an element before the current element
+    - `add_after`: adds an element after the current element
+    - `add_as_son_of`: adds an element as a son of the current element
+    - `set_as_parent_of`: sets the current element as the parent of another element
+    - `to_string`: converts the current element to a string
+
+
+### Usage Example
+
+```python
+from pathlib import Path
+from smartXML.xmltree import SmartXML, TextOnlyComment
+
+input_file = Path('./example.xml')
+xml = SmartXML(input_file)
+
+firstName = xml.find('students|student|firstName', with_content='Bob')
+bob = firstName.parent
+bob.comment_out()
+header = TextOnlyComment('Bob is out')
+header.add_before(bob)
+
+xml.write()
+```
+result (example.xml):
+```xml
+<students>
+  <!-- Bob is out -->
+  <!--
+    <student id="S002">
+	  <firstName>Bob</firstName>
+	  <lastName>Levi</lastName>
+    </student>
+  -->
+</students>
+```

smartxml-1.0.8.dist-info/RECORD

@@ -0,0 +1,8 @@
+smartXML/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+smartXML/_elements_utils.py,sha256=nYGBbQVr5OG6blEbwSrBMXzM71Qtj5fyNGxC1xQVRRY,2372
+smartXML/element.py,sha256=8ZmBZ-UDC5FiGcbpPiJv3_9qqHgNfI4PpswFYv-C_9o,8455
+smartXML/xmltree.py,sha256=-oDroh1wC457fLkzIc_yZLDILlbf8yfhu5OWohACkok,12320
+smartxml-1.0.8.dist-info/METADATA,sha256=xF9GoGkboLeoyIRXAypne-Aj1Qmt4O6pLecP0CnCfus,2816
+smartxml-1.0.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+smartxml-1.0.8.dist-info/top_level.txt,sha256=r3cP_uWcWF46t1J8P4-T4dJJEMY7El0Mdkuj1p0Ialk,9
+smartxml-1.0.8.dist-info/RECORD,,

smartxml-1.0.8.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

smartxml-1.0.8.dist-info/top_level.txt

@@ -0,0 +1 @@
+smartXML