lupaxa-data-converter 0.1.0__tar.gz

lupaxa_data_converter-0.1.0/.gitignore

@@ -0,0 +1,24 @@
+# OS
+.DS_Store
+
+# Cursor
+.cursor/
+.superpowers/
+.worktrees/
+cursor-docs
+
+# Make
+.makefiles/
+
+# MkDocs
+site/
+
+# Python
+.venv/
+__pycache__/
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+dist/
+build/
+*.egg-info/

lupaxa_data_converter-0.1.0/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) The Lupaxa Project
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lupaxa_data_converter-0.1.0/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.5
+Name: lupaxa-data-converter
+Version: 0.1.0
+Summary: Python library that converts mappings between JSON, JSON5, XML, YAML, and TOML.
+Project-URL: Homepage, https://data-converter.thelupaxaproject.org/
+Project-URL: Documentation, https://data-converter.thelupaxaproject.org/
+Project-URL: Repository, https://github.com/lupaxa-developers-toolbox/data-converter
+Project-URL: Issues, https://github.com/lupaxa-developers-toolbox/data-converter/issues
+Author: The Lupaxa Project
+License: MIT License
+        
+        Copyright (c) The Lupaxa Project
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENCE
+Keywords: data-conversion,json,json5,toml,xml,yaml
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Markup
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Requires-Dist: defusedxml>=0.7
+Requires-Dist: json5>=0.12
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: tomli-w>=1.1
+Requires-Dist: tomli>=2.0; python_version < '3.11'
+Provides-Extra: dev
+Requires-Dist: bump-my-version>=1.2.0; extra == 'dev'
+Requires-Dist: hatch>=1.12.0; extra == 'dev'
+Requires-Dist: mkdocs-material==9.7.7; extra == 'dev'
+Requires-Dist: mkdocs==1.6.1; extra == 'dev'
+Requires-Dist: mypy>=1.12.0; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6.0; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: pytest-cov>=5.0; extra == 'test'
+Requires-Dist: pytest>=8.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+<!-- markdownlint-disable -->
+<p align="center">
+  <a href="https://github.com/lupaxa-developers-toolbox">
+    <img src="https://raw.githubusercontent.com/the-lupaxa-project/brand-assets/master/logos/organisations/developers-toolbox/readme-logo.png" alt="Project Logo" width="256"/><br/>
+  </a>
+</p>
+<h3 align="center">
+  The Lupaxa Developers Toolbox<br />
+  Part of The Lupaxa Project
+</h3>
+
+<br />
+
+# lupaxa-data-converter
+
+Python library that loads JSON, JSON5, XML, YAML, or TOML into a
+dictionary, then writes any of those formats.
+
+Built for scripts and tools used by The Lupaxa Project.
+
+The PyPI name is `lupaxa-data-converter`. The import path is
+`lupaxa.data_converter`. This is a library only — there is no console
+script and no `python -m` entry point.
+
+## Features
+
+- Load JSON, JSON5, XML, YAML, TOML, or a dictionary into one `DataConverter`
+- Dump the loaded mapping to any of those formats
+- Two passes through a standard dict — no pairwise converters
+- Fully typed, linted, formatted, and tested
+
+## Installation
+
+### From PyPI
+
+```bash
+pip install lupaxa-data-converter
+```
+
+### From source (development mode)
+
+```bash
+pip install -e ".[dev]"
+```
+
+Requires Python 3.10+. Runtime dependencies: `PyYAML`, `defusedxml`,
+`json5`, and `tomli-w` (`tomli` on Python 3.10).
+`lupaxa` is a namespace package — there is no `lupaxa/__init__.py`.
+
+## Usage
+
+```python
+from lupaxa.data_converter import DataConverter
+
+payload = {"name": "Lupaxa", "formats": ["json", "json5", "xml", "yaml", "toml"]}
+converter = DataConverter(payload, data_type="dict")
+
+print(converter.to_json())
+print(converter.to_json5())
+print(converter.to_xml())
+print(converter.to_yaml())
+print(converter.to_toml())
+```
+
+## Development
+
+Clone the repository and install with Make:
+
+```bash
+make init                # first-time makefile-skills checkout
+make python-install-dev  # editable install with [dev]
+make python-check        # lint, type-check, and test
+make mkdocs-serve        # local docs site
+```
+
+Documentation: <https://data-converter.thelupaxaproject.org/>.
+
+<a href="https://github.com/the-lupaxa-project">
+    <img src="https://raw.githubusercontent.com/the-lupaxa-project/brand-assets/master/logos/components/footer-for-child-orgs.svg" alt="The Lupaxa Project Footer" width="100%" />
+</a>

lupaxa_data_converter-0.1.0/README-PYPI.md

@@ -0,0 +1,80 @@
+<!-- markdownlint-disable -->
+<p align="center">
+  <a href="https://github.com/lupaxa-developers-toolbox">
+    <img src="https://raw.githubusercontent.com/the-lupaxa-project/brand-assets/master/logos/organisations/developers-toolbox/readme-logo.png" alt="Project Logo" width="256"/><br/>
+  </a>
+</p>
+<h3 align="center">
+  The Lupaxa Developers Toolbox<br />
+  Part of The Lupaxa Project
+</h3>
+
+<br />
+
+# lupaxa-data-converter
+
+Python library that loads JSON, JSON5, XML, YAML, or TOML into a
+dictionary, then writes any of those formats.
+
+Built for scripts and tools used by The Lupaxa Project.
+
+The PyPI name is `lupaxa-data-converter`. The import path is
+`lupaxa.data_converter`. This is a library only — there is no console
+script and no `python -m` entry point.
+
+## Features
+
+- Load JSON, JSON5, XML, YAML, TOML, or a dictionary into one `DataConverter`
+- Dump the loaded mapping to any of those formats
+- Two passes through a standard dict — no pairwise converters
+- Fully typed, linted, formatted, and tested
+
+## Installation
+
+### From PyPI
+
+```bash
+pip install lupaxa-data-converter
+```
+
+### From source (development mode)
+
+```bash
+pip install -e ".[dev]"
+```
+
+Requires Python 3.10+. Runtime dependencies: `PyYAML`, `defusedxml`,
+`json5`, and `tomli-w` (`tomli` on Python 3.10).
+`lupaxa` is a namespace package — there is no `lupaxa/__init__.py`.
+
+## Usage
+
+```python
+from lupaxa.data_converter import DataConverter
+
+payload = {"name": "Lupaxa", "formats": ["json", "json5", "xml", "yaml", "toml"]}
+converter = DataConverter(payload, data_type="dict")
+
+print(converter.to_json())
+print(converter.to_json5())
+print(converter.to_xml())
+print(converter.to_yaml())
+print(converter.to_toml())
+```
+
+## Development
+
+Clone the repository and install with Make:
+
+```bash
+make init                # first-time makefile-skills checkout
+make python-install-dev  # editable install with [dev]
+make python-check        # lint, type-check, and test
+make mkdocs-serve        # local docs site
+```
+
+Documentation: <https://data-converter.thelupaxaproject.org/>.
+
+<a href="https://github.com/the-lupaxa-project">
+    <img src="https://raw.githubusercontent.com/the-lupaxa-project/brand-assets/master/logos/components/footer-for-child-orgs.svg" alt="The Lupaxa Project Footer" width="100%" />
+</a>

lupaxa_data_converter-0.1.0/README.md

@@ -0,0 +1,51 @@
+<p align="center">
+  <a href="https://github.com/lupaxa-developers-toolbox">
+    <img src="https://raw.githubusercontent.com/the-lupaxa-project/brand-assets/master/logos/organisations/developers-toolbox/readme-logo.png" alt="Developers Toolbox" />
+  </a>
+</p>
+
+<h1 align="center">data-converter</h1>
+
+Python library that loads JSON, JSON5, XML, YAML, or TOML into a
+dictionary, then writes any of those formats.
+
+## Install
+
+```bash
+pip install lupaxa-data-converter
+```
+
+Requires Python 3.10+.
+
+## Usage
+
+```python
+from lupaxa.data_converter import DataConverter
+
+payload = {"name": "Lupaxa", "formats": ["json", "json5", "xml", "yaml", "toml"]}
+converter = DataConverter(payload, data_type="dict")
+
+print(converter.to_json())
+print(converter.to_json5())
+print(converter.to_xml())
+print(converter.to_yaml())
+print(converter.to_toml())
+```
+
+This is a library only. There is no console script and no
+`python -m` entry point.
+
+## Documentation
+
+Site pages live in `mkdocs/` and publish to
+<https://data-converter.thelupaxaproject.org/>.
+
+```bash
+make init
+make python-install-dev
+make mkdocs-serve
+```
+
+<a href="https://github.com/the-lupaxa-project">
+    <img src="https://raw.githubusercontent.com/the-lupaxa-project/brand-assets/master/logos/components/footer-for-child-orgs.svg" alt="The Lupaxa Project Footer" width="100%" />
+</a>

lupaxa_data_converter-0.1.0/docs/README.md

@@ -0,0 +1,23 @@
+<p align="center">
+    <a href="https://github.com/lupaxa-developers-toolbox">
+        <img src="https://raw.githubusercontent.com/the-lupaxa-project/brand-assets/master/logos/organisations/developers-toolbox/readme-logo.png" alt="Organisation Logo" />
+    </a>
+</p>
+
+<h1 align="center">Core Documentation</h1>
+
+The following documents define the standards that apply across **The Lupaxa Project**:
+
+| Document                              | Purpose                                                           |
+| :------------------------------------ | :---------------------------------------------------------------- |
+| [Code of Conduct](CODE_OF_CONDUCT.md) | Expected behaviour and reporting procedures.                      |
+| [How to Contribute](CONTRIBUTING.md)  | Development workflow, coding standards, and contribution process. |
+| [Governance](GOVERNANCE.md)           | Project governance, roles, and decision-making.                   |
+| [Maintainers](MAINTAINERS.md)         | Maintainer responsibilities and expectations.                     |
+| [Projects Overview](PROJECTS.md)      | Overview of organisations, repositories, and project structure.   |
+| [Security Policy](SECURITY.md)        | Responsible disclosure and secure development practices.          |
+| [Support Guide](SUPPORT.md)           | How to obtain help and support.                                   |
+
+<a href="https://github.com/the-lupaxa-project">
+    <img src="https://raw.githubusercontent.com/the-lupaxa-project/brand-assets/master/logos/components/footer-for-child-orgs.svg" alt="The Lupaxa Project Footer" width="100%" />
+</a>

lupaxa_data_converter-0.1.0/pyproject.toml

@@ -0,0 +1,104 @@
+[build-system]
+requires = ["hatchling>=1.18"]
+build-backend = "hatchling.build"
+
+[project]
+name = "lupaxa-data-converter"
+dynamic = ["version"]
+description = "Python library that converts mappings between JSON, JSON5, XML, YAML, and TOML."
+readme = "README-PYPI.md"
+license = { file = "LICENCE" }
+requires-python = ">=3.10"
+
+authors = [
+  { name = "The Lupaxa Project" }
+]
+
+keywords = ["json", "json5", "xml", "yaml", "toml", "data-conversion"]
+
+dependencies = [
+  "PyYAML>=6.0",
+  "defusedxml>=0.7",
+  "json5>=0.12",
+  "tomli>=2.0; python_version < '3.11'",
+  "tomli-w>=1.1",
+]
+
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Topic :: Text Processing :: Markup",
+  "Topic :: Utilities",
+]
+
+[project.urls]
+Homepage = "https://data-converter.thelupaxaproject.org/"
+Documentation = "https://data-converter.thelupaxaproject.org/"
+Repository = "https://github.com/lupaxa-developers-toolbox/data-converter"
+Issues = "https://github.com/lupaxa-developers-toolbox/data-converter/issues"
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.0",
+  "pytest-cov>=5.0",
+  "ruff>=0.6.0",
+  "mypy>=1.12.0",
+  "hatch>=1.12.0",
+  "bump-my-version>=1.2.0",
+  "mkdocs==1.6.1",
+  "mkdocs-material==9.7.7",
+]
+test = [
+  "pytest>=8.0",
+  "pytest-cov>=5.0",
+]
+
+[tool.hatch.version]
+path = "src/lupaxa/data_converter/version.py"
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "src/**",
+  "README.md",
+  "README-PYPI.md",
+  "LICENCE",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/lupaxa"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP", "SIM"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**/*.py" = ["S101"]
+
+[tool.ruff.format]
+quote-style = "double"
+
+[tool.mypy]
+python_version = "3.10"
+files = ["src", "tests"]
+mypy_path = "src"
+explicit_package_bases = true
+namespace_packages = true
+warn_unused_configs = true
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+addopts = "-ra -q --disable-warnings"
+testpaths = ["tests"]
+pythonpath = ["src", "."]

lupaxa_data_converter-0.1.0/src/lupaxa/data_converter/__init__.py

@@ -0,0 +1,14 @@
+"""lupaxa.data_converter — convert mappings between JSON, JSON5, XML, YAML, and TOML."""
+
+from __future__ import annotations
+
+from .converter import DataConverter
+from .exceptions import DataConverterError
+from .version import __version__, get_version
+
+__all__ = [
+    "DataConverter",
+    "DataConverterError",
+    "__version__",
+    "get_version",
+]

lupaxa_data_converter-0.1.0/src/lupaxa/data_converter/converter.py

@@ -0,0 +1,123 @@
+"""Public converter facade."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Literal
+
+from . import json5_codec, json_codec, toml_codec, xml_codec, yaml_codec
+from .exceptions import DataConverterError
+
+DataType = Literal["json", "json5", "xml", "yaml", "toml", "dict"]
+_SUPPORTED_TYPES = frozenset({"json", "json5", "xml", "yaml", "toml", "dict"})
+_TEXT_LOADERS = {
+    "json": json_codec.loads,
+    "json5": json5_codec.loads,
+    "yaml": yaml_codec.loads,
+    "toml": toml_codec.loads,
+}
+
+
+class DataConverter:
+    """Load any supported format to a dict, then dump to any supported format."""
+
+    def __init__(self, data: str | Mapping[str, Any], data_type: str = "json") -> None:
+        self._data_type = _normalize_type(data_type)
+        if self._data_type == "xml":
+            self._root_tag, self._data = xml_codec.loads(_as_text(data, "XML"))
+        else:
+            self._root_tag = "root"
+            self._data = _load(data, self._data_type)
+
+    @property
+    def data(self) -> dict[str, Any]:
+        """The loaded mapping."""
+        return self._data
+
+    @property
+    def data_type(self) -> str:
+        """Normalized source type."""
+        return self._data_type
+
+    @property
+    def root_tag(self) -> str:
+        """XML root tag used when serializing to XML."""
+        return self._root_tag
+
+    def to_json(self) -> str:
+        return json_codec.dumps(self._data)
+
+    def to_yaml(self) -> str:
+        return yaml_codec.dumps(self._data)
+
+    def to_xml(self, root_tag: str | None = None) -> str:
+        return xml_codec.dumps(self._data, root_tag=root_tag or self._root_tag)
+
+    def to_toml(self) -> str:
+        return toml_codec.dumps(self._data)
+
+    def to_json5(self) -> str:
+        return json5_codec.dumps(self._data)
+
+    @staticmethod
+    def dict_to_xml(data: Mapping[str, Any], root_tag: str = "root") -> str:
+        _require_mapping(data, "dictionary")
+        return xml_codec.dumps(data, root_tag=root_tag)
+
+    @staticmethod
+    def json_to_xml(json_data: Mapping[str, Any], root_tag: str = "root") -> str:
+        _require_mapping(json_data, "JSON object")
+        return xml_codec.dumps(json_data, root_tag=root_tag)
+
+    @staticmethod
+    def xml_to_json(xml_data: str) -> str:
+        _root_tag, payload = xml_codec.loads(_as_text(xml_data, "XML"))
+        return json_codec.dumps(payload)
+
+    @staticmethod
+    def yaml_to_dict(yaml_data: str) -> dict[str, Any]:
+        return yaml_codec.loads(_as_text(yaml_data, "YAML"))
+
+    @staticmethod
+    def toml_to_dict(toml_data: str) -> dict[str, Any]:
+        return toml_codec.loads(_as_text(toml_data, "TOML"))
+
+    @staticmethod
+    def json5_to_dict(json5_data: str) -> dict[str, Any]:
+        return json5_codec.loads(_as_text(json5_data, "JSON5"))
+
+
+def _normalize_type(data_type: str) -> DataType:
+    normalized = data_type.strip().lower()
+    if normalized not in _SUPPORTED_TYPES:
+        raise DataConverterError(
+            f"Unsupported data type: {data_type!r}. Use json, json5, xml, yaml, toml, or dict."
+        )
+    return normalized  # type: ignore[return-value]
+
+
+def _load(data: str | Mapping[str, Any], data_type: DataType) -> dict[str, Any]:
+    if data_type == "dict":
+        if not isinstance(data, Mapping):
+            raise DataConverterError("A dictionary mapping is required.")
+        return dict(data)
+    loader = _TEXT_LOADERS.get(data_type)
+    if loader is None:
+        raise DataConverterError(f"Unsupported data type: {data_type!r}.")
+    return loader(_as_text(data, data_type.upper()))
+
+
+def _as_text(data: object, label: str) -> str:
+    if isinstance(data, bytes):
+        try:
+            return data.decode("utf-8")
+        except UnicodeDecodeError as exc:
+            raise DataConverterError(f"Invalid {label} string.") from exc
+    if not isinstance(data, str):
+        raise DataConverterError(f"{label} string required.")
+    return data
+
+
+def _require_mapping(data: object, label: str) -> None:
+    if not isinstance(data, Mapping):
+        raise DataConverterError(f"A {label} mapping is required.")

lupaxa_data_converter-0.1.0/src/lupaxa/data_converter/exceptions.py

@@ -0,0 +1,10 @@
+"""Errors raised by ``lupaxa.data_converter``."""
+
+from __future__ import annotations
+
+
+class DataConverterError(Exception):
+    """Raised when a conversion cannot be completed."""
+
+    def __init__(self, message: str = "Data conversion error.") -> None:
+        super().__init__(message)

lupaxa_data_converter-0.1.0/src/lupaxa/data_converter/json5_codec.py

@@ -0,0 +1,27 @@
+"""JSON5 load and dump helpers."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+import json5
+
+from .exceptions import DataConverterError
+
+
+def dumps(data: Mapping[str, Any]) -> str:
+    try:
+        return json5.dumps(dict(data), ensure_ascii=False)
+    except (TypeError, ValueError) as exc:
+        raise DataConverterError("Cannot encode value as JSON5.") from exc
+
+
+def loads(text: str) -> dict[str, Any]:
+    try:
+        parsed = json5.loads(text)
+    except (ValueError, TypeError) as exc:
+        raise DataConverterError("Invalid JSON5.") from exc
+    if not isinstance(parsed, dict):
+        raise DataConverterError("JSON5 document must be a mapping.")
+    return parsed

lupaxa_data_converter-0.1.0/src/lupaxa/data_converter/json_codec.py

@@ -0,0 +1,26 @@
+"""JSON load and dump helpers."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from typing import Any
+
+from .exceptions import DataConverterError
+
+
+def dumps(data: Mapping[str, Any]) -> str:
+    try:
+        return json.dumps(data, ensure_ascii=False)
+    except (TypeError, ValueError) as exc:
+        raise DataConverterError("Cannot encode value as JSON.") from exc
+
+
+def loads(text: str) -> dict[str, Any]:
+    try:
+        parsed = json.loads(text)
+    except json.JSONDecodeError as exc:
+        raise DataConverterError(f"Invalid JSON: {exc.msg}.") from exc
+    if not isinstance(parsed, dict):
+        raise DataConverterError("JSON document must be a mapping.")
+    return parsed

lupaxa_data_converter-0.1.0/src/lupaxa/data_converter/toml_codec.py

@@ -0,0 +1,33 @@
+"""TOML load and dump helpers."""
+
+from __future__ import annotations
+
+import sys
+from collections.abc import Mapping
+from typing import Any
+
+import tomli_w
+
+from .exceptions import DataConverterError
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+
+def dumps(data: Mapping[str, Any]) -> str:
+    try:
+        return tomli_w.dumps(dict(data))
+    except (TypeError, ValueError) as exc:
+        raise DataConverterError("Cannot encode value as TOML.") from exc
+
+
+def loads(text: str) -> dict[str, Any]:
+    try:
+        parsed = tomllib.loads(text)
+    except tomllib.TOMLDecodeError as exc:
+        raise DataConverterError("Invalid TOML.") from exc
+    if not isinstance(parsed, dict):
+        raise DataConverterError("TOML document must be a mapping.")
+    return parsed

lupaxa_data_converter-0.1.0/src/lupaxa/data_converter/version.py

@@ -0,0 +1,10 @@
+"""Version information for the ``lupaxa.data_converter`` package."""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+
+
+def get_version() -> str:
+    """Return the current package version string."""
+    return __version__

lupaxa_data_converter-0.1.0/src/lupaxa/data_converter/xml_codec.py

@@ -0,0 +1,103 @@
+"""XML load and dump helpers."""
+
+from __future__ import annotations
+
+import re
+import xml.etree.ElementTree as ET
+from collections.abc import Mapping
+from typing import Any
+
+from defusedxml.ElementTree import ParseError, fromstring
+from defusedxml.minidom import parseString
+
+from .exceptions import DataConverterError
+
+_XML_NAME = re.compile(r"^[_A-Za-z][-._A-Za-z0-9]*$")
+
+
+def dumps(data: Mapping[str, Any], root_tag: str = "root") -> str:
+    root = ET.Element(_require_name(root_tag))
+    _append_mapping(data, root)
+    try:
+        raw = ET.tostring(root, encoding="unicode")
+        return parseString(raw).toprettyxml()
+    except DataConverterError:
+        raise
+    except Exception as exc:
+        raise DataConverterError("Cannot encode value as XML.") from exc
+
+
+def loads(text: str) -> tuple[str, dict[str, Any]]:
+    try:
+        root = fromstring(text)
+    except ParseError as exc:
+        raise DataConverterError("Invalid XML.") from exc
+    except Exception as exc:
+        raise DataConverterError("Invalid XML.") from exc
+    return root.tag, _element_payload(root)
+
+
+def _require_name(name: str) -> str:
+    if not name or not _XML_NAME.match(name):
+        raise DataConverterError(f"Invalid XML name: {name!r}.")
+    return name
+
+
+def _append_mapping(data: Mapping[str, Any], parent: ET.Element) -> None:
+    for key, value in data.items():
+        if key == "#text":
+            parent.text = "" if value is None else str(value)
+            continue
+        if key.startswith("@"):
+            parent.set(_require_name(key[1:]), "" if value is None else str(value))
+            continue
+        tag = _require_name(key)
+        if isinstance(value, list):
+            for item in value:
+                child = ET.SubElement(parent, tag)
+                _append_value(item, child)
+            continue
+        child = ET.SubElement(parent, tag)
+        _append_value(value, child)
+
+
+def _append_value(value: Any, parent: ET.Element) -> None:
+    if isinstance(value, Mapping):
+        _append_mapping(value, parent)
+        return
+    if isinstance(value, list):
+        for item in value:
+            child = ET.SubElement(parent, "item")
+            _append_value(item, child)
+        return
+    if value is None:
+        return
+    parent.text = str(value)
+
+
+def _element_payload(element: ET.Element) -> dict[str, Any]:
+    payload: dict[str, Any] = {}
+    for name, value in element.attrib.items():
+        payload[f"@{name}"] = value
+
+    for child in list(element):
+        child_value = _child_value(child)
+        if child.tag in payload:
+            existing = payload[child.tag]
+            if not isinstance(existing, list):
+                payload[child.tag] = [existing]
+            payload[child.tag].append(child_value)
+        else:
+            payload[child.tag] = child_value
+
+    text = element.text.strip() if element.text and element.text.strip() else None
+    if text:
+        payload["#text"] = text
+    return payload
+
+
+def _child_value(element: ET.Element) -> Any:
+    payload = _element_payload(element)
+    if not element.attrib and not list(element):
+        return payload.get("#text", "")
+    return payload

lupaxa_data_converter-0.1.0/src/lupaxa/data_converter/yaml_codec.py

@@ -0,0 +1,33 @@
+"""YAML load and dump helpers."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+import yaml
+from yaml import YAMLError
+
+from .exceptions import DataConverterError
+
+
+def dumps(data: Mapping[str, Any]) -> str:
+    try:
+        return yaml.safe_dump(
+            dict(data),
+            default_flow_style=False,
+            allow_unicode=True,
+            sort_keys=False,
+        )
+    except YAMLError as exc:
+        raise DataConverterError("Cannot encode value as YAML.") from exc
+
+
+def loads(text: str) -> dict[str, Any]:
+    try:
+        parsed = yaml.safe_load(text)
+    except YAMLError as exc:
+        raise DataConverterError("Invalid YAML.") from exc
+    if not isinstance(parsed, dict):
+        raise DataConverterError("YAML document must be a mapping.")
+    return parsed