urban-json-xml 0.1.0__tar.gz

urban_json_xml-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 black beard
+
+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.

urban_json_xml-0.1.0/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: urban-json-xml
+Version: 0.1.0
+Summary: Plugin urban-json : lecture de fichiers XML (fonction de template loadxml).
+Author-email: Gael Beard <gaelgael5@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/gaelgael5/Jslt
+Project-URL: Repository, https://github.com/gaelgael5/Jslt
+Keywords: json,transform,template,jslt,xml,plugin
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Markup
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: urban-json
+Requires-Dist: defusedxml>=0.7
+Dynamic: license-file
+
+# urban-json-xml
+
+Plugin [urban-json](https://github.com/gaelgael5/Jslt) : lecture de fichiers **XML**
+dans les templates, via la fonction `loadxml`. Suit les conventions XML↔JSON du
+`XmlNodeConverter` (.NET/Newtonsoft).
+
+## Installation
+
+```bash
+pip install urban-json-xml      # tire urban-json et defusedxml en dépendances
+```
+
+`urban-json` découvre le plugin automatiquement via les entry points (`urban_json.functions`) :
+`loadxml` devient utilisable dans les templates.
+
+## Utilisation
+
+```python
+from urban_json import JsltTemplate
+
+# catalog.xml :
+#   <catalog>
+#     <book id="1"><title>A</title></book>
+#     <book id="2"><title>B</title></book>
+#   </catalog>
+tpl = JsltTemplate.parse('[ { "$source": select(loadxml("catalog.xml"), $.catalog.book), "t": $.title } ]')
+tpl.transform({})
+# -> [{'t': 'A'}, {'t': 'B'}]
+```
+
+`loadxml` renvoie un objet ; on navigue dedans avec `select`/`selectmany` (fonctions
+du cœur) avant d'alimenter une boucle `$source`, un filtre `?(...)`, etc.
+
+## Conventions de conversion (Newtonsoft)
+
+| XML | JSON |
+|---|---|
+| `<a>v</a>` | `{"a": "v"}` |
+| `<a x="1">v</a>` | `{"a": {"@x": "1", "#text": "v"}}` |
+| `<a/>` | `{"a": null}` |
+| `<a><b>1</b><b>2</b></a>` | `{"a": {"b": ["1", "2"]}}` (frères homonymes → tableau) |
+
+- Attributs → propriétés préfixées par `@`.
+- Texte d'un élément mixte → clé `#text`.
+- Les valeurs restent des **chaînes** (comme Newtonsoft, pas de coercition).
+
+## Signature
+
+```
+loadxml(source_path, attribute_prefix="@", text_key="#text", strip_namespaces=true)
+```
+
+| Paramètre | Rôle |
+|---|---|
+| `source_path` | chemin du fichier XML |
+| `attribute_prefix` | préfixe des propriétés issues d'attributs (défaut `@`) |
+| `text_key` | clé portant le texte d'un élément mixte (défaut `#text`) |
+| `strip_namespaces` | réduit `{uri}local` au nom local (défaut `true`) |
+
+## Sécurité
+
+Le XML est analysé avec [`defusedxml`](https://pypi.org/project/defusedxml/) :
+entités externes et expansion d'entités désactivées (protection XXE /
+« billion laughs »).
+
+## Licence
+
+Apache-2.0.

urban_json_xml-0.1.0/README.md

@@ -0,0 +1,68 @@
+# urban-json-xml
+
+Plugin [urban-json](https://github.com/gaelgael5/Jslt) : lecture de fichiers **XML**
+dans les templates, via la fonction `loadxml`. Suit les conventions XML↔JSON du
+`XmlNodeConverter` (.NET/Newtonsoft).
+
+## Installation
+
+```bash
+pip install urban-json-xml      # tire urban-json et defusedxml en dépendances
+```
+
+`urban-json` découvre le plugin automatiquement via les entry points (`urban_json.functions`) :
+`loadxml` devient utilisable dans les templates.
+
+## Utilisation
+
+```python
+from urban_json import JsltTemplate
+
+# catalog.xml :
+#   <catalog>
+#     <book id="1"><title>A</title></book>
+#     <book id="2"><title>B</title></book>
+#   </catalog>
+tpl = JsltTemplate.parse('[ { "$source": select(loadxml("catalog.xml"), $.catalog.book), "t": $.title } ]')
+tpl.transform({})
+# -> [{'t': 'A'}, {'t': 'B'}]
+```
+
+`loadxml` renvoie un objet ; on navigue dedans avec `select`/`selectmany` (fonctions
+du cœur) avant d'alimenter une boucle `$source`, un filtre `?(...)`, etc.
+
+## Conventions de conversion (Newtonsoft)
+
+| XML | JSON |
+|---|---|
+| `<a>v</a>` | `{"a": "v"}` |
+| `<a x="1">v</a>` | `{"a": {"@x": "1", "#text": "v"}}` |
+| `<a/>` | `{"a": null}` |
+| `<a><b>1</b><b>2</b></a>` | `{"a": {"b": ["1", "2"]}}` (frères homonymes → tableau) |
+
+- Attributs → propriétés préfixées par `@`.
+- Texte d'un élément mixte → clé `#text`.
+- Les valeurs restent des **chaînes** (comme Newtonsoft, pas de coercition).
+
+## Signature
+
+```
+loadxml(source_path, attribute_prefix="@", text_key="#text", strip_namespaces=true)
+```
+
+| Paramètre | Rôle |
+|---|---|
+| `source_path` | chemin du fichier XML |
+| `attribute_prefix` | préfixe des propriétés issues d'attributs (défaut `@`) |
+| `text_key` | clé portant le texte d'un élément mixte (défaut `#text`) |
+| `strip_namespaces` | réduit `{uri}local` au nom local (défaut `true`) |
+
+## Sécurité
+
+Le XML est analysé avec [`defusedxml`](https://pypi.org/project/defusedxml/) :
+entités externes et expansion d'entités désactivées (protection XXE /
+« billion laughs »).
+
+## Licence
+
+Apache-2.0.

urban_json_xml-0.1.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "urban-json-xml"
+dynamic = ["version"]
+description = "Plugin urban-json : lecture de fichiers XML (fonction de template loadxml)."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+authors = [{ name = "Gael Beard", email = "gaelgael5@gmail.com" }]
+keywords = ["json", "transform", "template", "jslt", "xml", "plugin"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Text Processing :: Markup",
+    "Typing :: Typed",
+]
+dependencies = [
+    "urban-json",
+    "defusedxml>=0.7",
+]
+
+[project.urls]
+Homepage = "https://github.com/gaelgael5/Jslt"
+Repository = "https://github.com/gaelgael5/Jslt"
+
+# Découverte automatique par urban-json : installer ce paquet suffit à exposer `loadxml`.
+[project.entry-points."urban_json.functions"]
+xml = "urban_json_xml:register"
+
+[tool.setuptools.dynamic]
+version = { attr = "urban_json_xml.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+urban_json_xml = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[tool.ruff]
+line-length = 100
+src = ["src", "tests"]

urban_json_xml-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

urban_json_xml-0.1.0/src/urban_json_xml/__init__.py

@@ -0,0 +1,116 @@
+"""Plugin jslt : lecture de fichiers XML (``loadxml``).
+
+Le moteur .NET n'expose pas de fonction de template ``loadxml`` mais convertit
+XML ↔ JSON via le ``XmlNodeConverter`` (conventions Newtonsoft). Ce plugin porte
+ces **mêmes conventions** sous forme d'une fonction ``loadxml`` :
+
+* un élément devient un objet ;
+* un attribut devient une propriété préfixée par ``@`` ;
+* le texte d'un élément (s'il a aussi des attributs/enfants) va dans ``#text`` ;
+  un élément qui n'a que du texte prend directement cette valeur (chaîne) ;
+* des éléments frères de même nom deviennent un tableau ;
+* l'élément racine est enveloppé : ``<root>…</root>`` → ``{"root": {…}}``.
+
+Les valeurs restent des **chaînes** (comme Newtonsoft : pas de coercition de type).
+
+Sécurité : le XML est analysé avec ``defusedxml`` (entités externes et expansion
+d'entités désactivées — protection XXE / « billion laughs »).
+
+Découvert automatiquement par ``jslt`` via l'entry point ``urban_json.functions``.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from defusedxml.ElementTree import parse as _parse
+
+__version__ = "0.1.0"
+
+__all__ = ["execute_loadxml", "register"]
+
+# Clés spéciales, fidèles au XmlNodeConverter (.NET/Newtonsoft).
+_TEXT_KEY = "#text"
+_ATTR_PREFIX = "@"
+
+
+def _local_name(tag: str, strip_namespaces: bool) -> str:
+    """Nom local d'une balise/attribut ``{uri}local`` -> ``local`` (si demandé)."""
+    if strip_namespaces and tag.startswith("{"):
+        return tag.rsplit("}", 1)[-1]
+    return tag
+
+
+def _element_to_obj(
+    element: Any, attribute_prefix: str, text_key: str, strip_namespaces: bool
+) -> Any:
+    """Convertit un élément ElementTree en structure JSON (conventions Newtonsoft)."""
+    children = list(element)
+    attributes = element.attrib
+    text = (element.text or "").strip()
+
+    # Feuille sans attribut ni enfant : la valeur texte directe (ou None si vide).
+    if not children and not attributes:
+        return text if text else None
+
+    obj: dict[str, Any] = {}
+
+    for name, value in attributes.items():
+        obj[attribute_prefix + _local_name(name, strip_namespaces)] = value
+
+    # Regroupe les enfants par nom : les frères homonymes forment un tableau.
+    groups: dict[str, list[Any]] = {}
+    order: list[str] = []
+    for child in children:
+        key = _local_name(child.tag, strip_namespaces)
+        if key not in groups:
+            groups[key] = []
+            order.append(key)
+        groups[key].append(_element_to_obj(child, attribute_prefix, text_key, strip_namespaces))
+    for key in order:
+        values = groups[key]
+        obj[key] = values[0] if len(values) == 1 else values
+
+    if text:
+        obj[text_key] = text
+
+    return obj
+
+
+def execute_loadxml(
+    ctx: Any,
+    source_path: str | None = None,
+    attribute_prefix: str = _ATTR_PREFIX,
+    text_key: str = _TEXT_KEY,
+    strip_namespaces: bool = True,
+) -> dict:
+    """Lit un fichier XML et le convertit en JSON (conventions Newtonsoft).
+
+    Args:
+        source_path: chemin du fichier XML (absolu ou relatif au répertoire courant).
+        attribute_prefix: préfixe des propriétés issues d'attributs (défaut ``@``).
+        text_key: clé portant le texte d'un élément mixte (défaut ``#text``).
+        strip_namespaces: réduit ``{uri}local`` au nom local (défaut ``True``).
+
+    Returns:
+        Un objet ``{nom_racine: contenu}`` reflétant l'arbre XML.
+    """
+    if not source_path:
+        raise ValueError("loadxml: source_path est requis")
+
+    tree = _parse(source_path)
+    root = tree.getroot()
+    return {
+        _local_name(root.tag, strip_namespaces): _element_to_obj(
+            root, attribute_prefix, text_key, strip_namespaces
+        )
+    }
+
+
+def register(registry: Any) -> None:
+    """Enregistre les fonctions du plugin dans un registre jslt (entry point)."""
+    registry.register(
+        "loadxml",
+        execute_loadxml,
+        description="Lit un fichier XML et le convertit en JSON (conventions Newtonsoft).",
+    )

urban_json_xml-0.1.0/src/urban_json_xml.egg-info/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: urban-json-xml
+Version: 0.1.0
+Summary: Plugin urban-json : lecture de fichiers XML (fonction de template loadxml).
+Author-email: Gael Beard <gaelgael5@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/gaelgael5/Jslt
+Project-URL: Repository, https://github.com/gaelgael5/Jslt
+Keywords: json,transform,template,jslt,xml,plugin
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Markup
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: urban-json
+Requires-Dist: defusedxml>=0.7
+Dynamic: license-file
+
+# urban-json-xml
+
+Plugin [urban-json](https://github.com/gaelgael5/Jslt) : lecture de fichiers **XML**
+dans les templates, via la fonction `loadxml`. Suit les conventions XML↔JSON du
+`XmlNodeConverter` (.NET/Newtonsoft).
+
+## Installation
+
+```bash
+pip install urban-json-xml      # tire urban-json et defusedxml en dépendances
+```
+
+`urban-json` découvre le plugin automatiquement via les entry points (`urban_json.functions`) :
+`loadxml` devient utilisable dans les templates.
+
+## Utilisation
+
+```python
+from urban_json import JsltTemplate
+
+# catalog.xml :
+#   <catalog>
+#     <book id="1"><title>A</title></book>
+#     <book id="2"><title>B</title></book>
+#   </catalog>
+tpl = JsltTemplate.parse('[ { "$source": select(loadxml("catalog.xml"), $.catalog.book), "t": $.title } ]')
+tpl.transform({})
+# -> [{'t': 'A'}, {'t': 'B'}]
+```
+
+`loadxml` renvoie un objet ; on navigue dedans avec `select`/`selectmany` (fonctions
+du cœur) avant d'alimenter une boucle `$source`, un filtre `?(...)`, etc.
+
+## Conventions de conversion (Newtonsoft)
+
+| XML | JSON |
+|---|---|
+| `<a>v</a>` | `{"a": "v"}` |
+| `<a x="1">v</a>` | `{"a": {"@x": "1", "#text": "v"}}` |
+| `<a/>` | `{"a": null}` |
+| `<a><b>1</b><b>2</b></a>` | `{"a": {"b": ["1", "2"]}}` (frères homonymes → tableau) |
+
+- Attributs → propriétés préfixées par `@`.
+- Texte d'un élément mixte → clé `#text`.
+- Les valeurs restent des **chaînes** (comme Newtonsoft, pas de coercition).
+
+## Signature
+
+```
+loadxml(source_path, attribute_prefix="@", text_key="#text", strip_namespaces=true)
+```
+
+| Paramètre | Rôle |
+|---|---|
+| `source_path` | chemin du fichier XML |
+| `attribute_prefix` | préfixe des propriétés issues d'attributs (défaut `@`) |
+| `text_key` | clé portant le texte d'un élément mixte (défaut `#text`) |
+| `strip_namespaces` | réduit `{uri}local` au nom local (défaut `true`) |
+
+## Sécurité
+
+Le XML est analysé avec [`defusedxml`](https://pypi.org/project/defusedxml/) :
+entités externes et expansion d'entités désactivées (protection XXE /
+« billion laughs »).
+
+## Licence
+
+Apache-2.0.

urban_json_xml-0.1.0/src/urban_json_xml.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/urban_json_xml/__init__.py
+src/urban_json_xml/py.typed
+src/urban_json_xml.egg-info/PKG-INFO
+src/urban_json_xml.egg-info/SOURCES.txt
+src/urban_json_xml.egg-info/dependency_links.txt
+src/urban_json_xml.egg-info/entry_points.txt
+src/urban_json_xml.egg-info/requires.txt
+src/urban_json_xml.egg-info/top_level.txt
+tests/test_loadxml.py

urban_json_xml-0.1.0/src/urban_json_xml.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

urban_json_xml-0.1.0/src/urban_json_xml.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[urban_json.functions]
+xml = urban_json_xml:register

urban_json_xml-0.1.0/src/urban_json_xml.egg-info/requires.txt

@@ -0,0 +1,2 @@
+urban-json
+defusedxml>=0.7

urban_json_xml-0.1.0/src/urban_json_xml.egg-info/top_level.txt

@@ -0,0 +1 @@
+urban_json_xml

urban_json_xml-0.1.0/tests/test_loadxml.py

@@ -0,0 +1,121 @@
+"""Tests du plugin urban-json-xml (fonction ``loadxml``).
+
+Couvre : conventions de conversion (attributs ``@``, texte ``#text``, frères
+homonymes → tableau, élément vide → null), namespaces, découverte via entry point,
+usage en template, et sécurité (XXE / entités désactivées via defusedxml).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+from defusedxml.common import EntitiesForbidden
+from urban_json import FunctionRegistry, JsltTemplate
+
+from urban_json_xml import execute_loadxml, register
+
+
+def _write(tmp_path: Path, name: str, content: str) -> str:
+    path = tmp_path / name
+    path.write_text(content, encoding="utf-8")
+    return str(path)
+
+
+def test_text_only_element(tmp_path: Path) -> None:
+    path = _write(tmp_path, "a.xml", "<a>v</a>")
+    assert execute_loadxml(None, path) == {"a": "v"}
+
+
+def test_attributes_and_text(tmp_path: Path) -> None:
+    path = _write(tmp_path, "a.xml", '<a x="1">v</a>')
+    assert execute_loadxml(None, path) == {"a": {"@x": "1", "#text": "v"}}
+
+
+def test_empty_element_is_null(tmp_path: Path) -> None:
+    path = _write(tmp_path, "a.xml", "<a/>")
+    assert execute_loadxml(None, path) == {"a": None}
+
+
+def test_repeated_siblings_become_array(tmp_path: Path) -> None:
+    path = _write(tmp_path, "a.xml", "<a><b>1</b><b>2</b></a>")
+    assert execute_loadxml(None, path) == {"a": {"b": ["1", "2"]}}
+
+
+def test_single_child_is_not_array(tmp_path: Path) -> None:
+    path = _write(tmp_path, "a.xml", "<a><b>1</b></a>")
+    assert execute_loadxml(None, path) == {"a": {"b": "1"}}
+
+
+def test_nested_structure(tmp_path: Path) -> None:
+    xml = '<catalog><book id="1"><title>A</title></book><book id="2"><title>B</title></book></catalog>'
+    path = _write(tmp_path, "c.xml", xml)
+    assert execute_loadxml(None, path) == {
+        "catalog": {
+            "book": [
+                {"@id": "1", "title": "A"},
+                {"@id": "2", "title": "B"},
+            ]
+        }
+    }
+
+
+def test_values_stay_strings(tmp_path: Path) -> None:
+    # Fidèle à Newtonsoft : pas de coercition de type (10 reste "10").
+    path = _write(tmp_path, "a.xml", "<a><n>10</n><b>true</b></a>")
+    assert execute_loadxml(None, path) == {"a": {"n": "10", "b": "true"}}
+
+
+def test_strip_namespaces_default(tmp_path: Path) -> None:
+    xml = '<root xmlns:ns="http://ex"><ns:item>v</ns:item></root>'
+    path = _write(tmp_path, "ns.xml", xml)
+    assert execute_loadxml(None, path) == {"root": {"item": "v"}}
+
+
+def test_keep_namespaces_when_disabled(tmp_path: Path) -> None:
+    xml = '<root xmlns:ns="http://ex"><ns:item>v</ns:item></root>'
+    path = _write(tmp_path, "ns.xml", xml)
+    result = execute_loadxml(None, path, strip_namespaces=False)
+    assert result == {"root": {"{http://ex}item": "v"}}
+
+
+def test_custom_prefix_and_text_key(tmp_path: Path) -> None:
+    path = _write(tmp_path, "a.xml", '<a x="1">v</a>')
+    result = execute_loadxml(None, path, attribute_prefix="_", text_key="value")
+    assert result == {"a": {"_x": "1", "value": "v"}}
+
+
+def test_register_into_custom_registry() -> None:
+    reg = FunctionRegistry()
+    register(reg)
+    assert "loadxml" in reg
+    assert reg.describe("loadxml").description
+
+
+def test_discovered_via_entry_point() -> None:
+    from urban_json import default_registry, load_plugins
+
+    load_plugins(default_registry)
+    assert "loadxml" in default_registry
+
+
+def test_loadxml_in_template(tmp_path: Path) -> None:
+    xml = "<catalog><book><title>A</title></book><book><title>B</title></book></catalog>"
+    path = _write(tmp_path, "c.xml", xml)
+    template = (
+        f'[ {{ "$source": select(loadxml("{path}"), $.catalog.book), "t": $.title }} ]'
+    )
+    assert JsltTemplate.parse(template).transform({}) == [{"t": "A"}, {"t": "B"}]
+
+
+def test_xxe_external_entity_is_blocked(tmp_path: Path) -> None:
+    secret = _write(tmp_path, "secret.txt", "TOP SECRET")
+    xml = (
+        '<?xml version="1.0"?>'
+        f'<!DOCTYPE r [<!ENTITY xxe SYSTEM "file://{secret}">]>'
+        "<r>&xxe;</r>"
+    )
+    path = _write(tmp_path, "evil.xml", xml)
+    # defusedxml doit refuser l'entité (pas d'exfiltration du secret).
+    with pytest.raises(EntitiesForbidden):
+        execute_loadxml(None, path)