urban-json-files 0.1.0__tar.gz

urban_json_files-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_files-0.1.0/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: urban-json-files
+Version: 0.1.0
+Summary: Plugin urban-json : fichiers JSON (loadjson, iteratejsonfile) et chemins (concatpath).
+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,files,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>=0.2.0
+Dynamic: license-file
+
+# urban-json-files
+
+Plugin [urban-json](https://github.com/gaelgael5/Jslt) : **fichiers JSON et chemins**
+dans les templates (port des fonctions .NET `loadjson`, `IterateJsonFile`, `concatpath`).
+
+```bash
+pip install urban-json-files
+```
+
+| Fonction | Rôle |
+|---|---|
+| `loadjson(chemin)` | Contenu d'un fichier JSON (`null` si le fichier n'existe pas). |
+| `iteratejsonfile(chemin, "$.chemin")` | Éléments d'un fichier JSON sélectionnés par un JSONPath (compilé ou en chaîne). |
+| `concatpath(["dossier", "fichier.json"])` | Chemin de fichier assemblé (`null` ignorés ; un segment absolu repart de la racine). |
+
+```python
+from urban_json import JsltTemplate
+
+tpl = JsltTemplate.parse('{ "ids": iteratejsonfile("data.json", "$.items[*].id") }')
+tpl.transform({})
+```
+
+Les chemins relatifs le sont au répertoire courant. Ces fonctions lisent le disque :
+elles ne sont pas disponibles dans le playground (bac à sable du cœur).

urban_json_files-0.1.0/README.md

@@ -0,0 +1,24 @@
+# urban-json-files
+
+Plugin [urban-json](https://github.com/gaelgael5/Jslt) : **fichiers JSON et chemins**
+dans les templates (port des fonctions .NET `loadjson`, `IterateJsonFile`, `concatpath`).
+
+```bash
+pip install urban-json-files
+```
+
+| Fonction | Rôle |
+|---|---|
+| `loadjson(chemin)` | Contenu d'un fichier JSON (`null` si le fichier n'existe pas). |
+| `iteratejsonfile(chemin, "$.chemin")` | Éléments d'un fichier JSON sélectionnés par un JSONPath (compilé ou en chaîne). |
+| `concatpath(["dossier", "fichier.json"])` | Chemin de fichier assemblé (`null` ignorés ; un segment absolu repart de la racine). |
+
+```python
+from urban_json import JsltTemplate
+
+tpl = JsltTemplate.parse('{ "ids": iteratejsonfile("data.json", "$.items[*].id") }')
+tpl.transform({})
+```
+
+Les chemins relatifs le sont au répertoire courant. Ces fonctions lisent le disque :
+elles ne sont pas disponibles dans le playground (bac à sable du cœur).

urban_json_files-0.1.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "urban-json-files"
+dynamic = ["version"]
+description = "Plugin urban-json : fichiers JSON (loadjson, iteratejsonfile) et chemins (concatpath)."
+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", "files", "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 = [
+    # 0.2.0 : chemins JSONPath acceptés en chaîne (as_json_path), utilisés ici.
+    "urban-json>=0.2.0",
+]
+
+[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 ses fonctions.
+[project.entry-points."urban_json.functions"]
+files = "urban_json_files:register"
+
+[tool.setuptools.dynamic]
+version = { attr = "urban_json_files.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+urban_json_files = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[tool.ruff]
+line-length = 100
+src = ["src", "tests"]

urban_json_files-0.1.0/setup.cfg

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

urban_json_files-0.1.0/src/urban_json_files/__init__.py

@@ -0,0 +1,87 @@
+"""Plugin urban-json : fichiers JSON et chemins (``loadjson``, ``iteratejsonfile``,
+``concatpath``).
+
+Port de ``Services.cs`` (``loadjson``, ``IterateJsonFile``) et
+``Services.paths.cs`` (``concatpath``) du .NET. Ces fonctions lisent le disque :
+elles restent hors du cœur, que le playground exécute en bac à sable.
+
+Découvert automatiquement via l'entry point ``urban_json.functions`` ; aussi
+enregistrable à la main : ``from urban_json_files import register``.
+
+Écarts volontaires vs .NET :
+
+* La résolution de chemin du .NET (``ctx.Configuration.ResolveFile``) n'existe pas
+  dans le portage : un chemin relatif l'est au répertoire courant (comme
+  ``loadcsv``). Le BOM éventuel est ignoré.
+* ``iteratejsonfile`` lit le fichier entier puis applique le chemin, au lieu du
+  lecteur en flux ``BigJsonReader`` : le .NET matérialisait de toute façon le
+  résultat complet (``new JArray(enumerator)``). Le chemin est accepté compilé
+  (``$.root.*``) ou en chaîne (``"$.root.*"``, forme du .NET).
+* Erreurs (JSON invalide, fichier manquant pour ``iteratejsonfile``) : ``JsltError``
+  explicite.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+
+from urban_json import JsltError
+from urban_json.functions._helpers import as_json_path, to_text
+
+__version__ = "0.1.0"
+
+__all__ = ["execute_concatpath", "execute_iteratejsonfile", "execute_loadjson", "register"]
+
+
+def _read_json(path: str, function: str) -> Any:
+    try:
+        with open(path, encoding="utf-8-sig") as handle:
+            return json.load(handle)
+    except json.JSONDecodeError as exc:
+        raise JsltError(f"{function} : JSON invalide dans {path!r} ({exc})") from exc
+
+
+def execute_loadjson(ctx: Any, source_path: Any = None) -> Any:
+    if not source_path:
+        raise JsltError("loadjson : le chemin du fichier est requis")
+    path = to_text(source_path)
+    if not os.path.isfile(path):
+        return None  # le .NET émettait un avertissement et rendait null
+    return _read_json(path, "loadjson")
+
+
+def execute_iteratejsonfile(ctx: Any, file_source: Any = None, slicer: Any = None) -> list:
+    if not file_source:
+        raise JsltError("iteratejsonfile : le chemin du fichier est requis")
+    if slicer is None:
+        raise JsltError("iteratejsonfile : le chemin JSONPath de découpe est requis")
+    path = to_text(file_source)
+    if not os.path.isfile(path):
+        raise JsltError(f"iteratejsonfile : fichier introuvable {path!r}")
+    return as_json_path(slicer).select_values(_read_json(path, "iteratejsonfile"))
+
+
+def execute_concatpath(ctx: Any, path: Any = None) -> Any:
+    if not isinstance(path, list):
+        return None
+    parts = [to_text(item) for item in path if item is not None]
+    # Path.Combine .NET = os.path.join : un segment absolu repart de la racine.
+    return os.path.join(*parts) if parts else ""
+
+
+def register(registry: Any) -> None:
+    """Enregistre ``loadjson``, ``iteratejsonfile`` et ``concatpath``."""
+    registry.register(
+        "loadjson", execute_loadjson,
+        description="Lit un fichier JSON et renvoie son contenu (null si le fichier n'existe pas)",
+    )
+    registry.register(
+        "iteratejsonfile", execute_iteratejsonfile, path_args=(1,),
+        description="Lit un fichier JSON et renvoie le tableau des éléments sélectionnés par un chemin JSONPath",
+    )
+    registry.register(
+        "concatpath", execute_concatpath,
+        description="Assemble un chemin de fichier à partir d'un tableau de segments (null ignorés)",
+    )

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

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: urban-json-files
+Version: 0.1.0
+Summary: Plugin urban-json : fichiers JSON (loadjson, iteratejsonfile) et chemins (concatpath).
+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,files,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>=0.2.0
+Dynamic: license-file
+
+# urban-json-files
+
+Plugin [urban-json](https://github.com/gaelgael5/Jslt) : **fichiers JSON et chemins**
+dans les templates (port des fonctions .NET `loadjson`, `IterateJsonFile`, `concatpath`).
+
+```bash
+pip install urban-json-files
+```
+
+| Fonction | Rôle |
+|---|---|
+| `loadjson(chemin)` | Contenu d'un fichier JSON (`null` si le fichier n'existe pas). |
+| `iteratejsonfile(chemin, "$.chemin")` | Éléments d'un fichier JSON sélectionnés par un JSONPath (compilé ou en chaîne). |
+| `concatpath(["dossier", "fichier.json"])` | Chemin de fichier assemblé (`null` ignorés ; un segment absolu repart de la racine). |
+
+```python
+from urban_json import JsltTemplate
+
+tpl = JsltTemplate.parse('{ "ids": iteratejsonfile("data.json", "$.items[*].id") }')
+tpl.transform({})
+```
+
+Les chemins relatifs le sont au répertoire courant. Ces fonctions lisent le disque :
+elles ne sont pas disponibles dans le playground (bac à sable du cœur).

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

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

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[urban_json.functions]
+files = urban_json_files:register

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

@@ -0,0 +1 @@
+urban-json>=0.2.0

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

@@ -0,0 +1 @@
+urban_json_files

urban_json_files-0.1.0/tests/test_files.py

@@ -0,0 +1,109 @@
+"""loadjson, iteratejsonfile, concatpath — port de Services.cs / Services.paths.cs."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+import pytest
+from urban_json import FunctionRegistry, JsltError, JsltTemplate
+
+from urban_json_files import register
+
+
+@pytest.fixture(scope="module")
+def registry() -> FunctionRegistry:
+    reg = FunctionRegistry()
+    register(reg)
+    return reg
+
+
+def run(registry, expression: str, source=None):
+    return JsltTemplate.parse(f'{{ "r": {expression} }}').transform(source or {}, functions=registry)["r"]
+
+
+def _write(tmp_path: Path, name: str, data, raw: str | None = None) -> str:
+    path = tmp_path / name
+    path.write_text(raw if raw is not None else json.dumps(data), encoding="utf-8")
+    return str(path)
+
+
+def test_loadjson(registry, tmp_path) -> None:
+    path = _write(tmp_path, "a.json", {"k": [1, 2], "s": "é"})
+    assert run(registry, "loadjson($.p)", {"p": path}) == {"k": [1, 2], "s": "é"}
+
+
+def test_loadjson_bom(registry, tmp_path) -> None:
+    path = _write(tmp_path, "bom.json", None, raw="[1]")
+    assert run(registry, "loadjson($.p)", {"p": path}) == [1]
+
+
+def test_loadjson_fichier_absent_donne_null(registry, tmp_path) -> None:
+    assert run(registry, "loadjson($.p)", {"p": str(tmp_path / "absent.json")}) is None
+
+
+def test_loadjson_json_invalide(registry, tmp_path) -> None:
+    path = _write(tmp_path, "bad.json", None, raw="{oops")
+    with pytest.raises(JsltError, match="JSON invalide"):
+        run(registry, "loadjson($.p)", {"p": path})
+
+
+def test_loadjson_chemin_manquant(registry) -> None:
+    with pytest.raises(JsltError, match="loadjson"):
+        run(registry, "loadjson($.p)", {"p": None})
+
+
+def test_iteratejsonfile(registry, tmp_path) -> None:
+    path = _write(tmp_path, "big.json", {"root": {"a": {"id": 1}, "b": {"id": 2}}})
+    assert run(registry, 'iteratejsonfile($.p, "$.root.*")', {"p": path}) == [{"id": 1}, {"id": 2}]
+
+
+def test_iteratejsonfile_chemin_compile(registry, tmp_path) -> None:
+    path = _write(tmp_path, "big.json", {"items": [{"id": 1}, {"id": 2}]})
+    assert run(registry, "iteratejsonfile($.p, $.items[*].id)", {"p": path}) == [1, 2]
+
+
+def test_iteratejsonfile_dans_une_boucle(registry, tmp_path) -> None:
+    # Usage du test .NET : la fonction alimente une projection par élément.
+    path = _write(tmp_path, "big.json", {"root": [{"n": "a"}, {"n": "b"}]})
+    template = JsltTemplate.parse('{ "r": [ { "$": iteratejsonfile($.p, "$.root[*]"), "nom": $.n } ] }')
+    assert template.transform({"p": path}, functions=registry)["r"] == [{"nom": "a"}, {"nom": "b"}]
+
+
+@pytest.mark.parametrize("expression", ['iteratejsonfile($.p, "$.x")', "iteratejsonfile(null, null)"])
+def test_iteratejsonfile_erreurs(registry, tmp_path, expression) -> None:
+    with pytest.raises(JsltError, match="iteratejsonfile"):
+        run(registry, expression, {"p": str(tmp_path / "absent.json")})
+
+
+def test_concatpath(registry) -> None:
+    assert run(registry, 'concatpath(["data", "2026", "file.json"])') == os.path.join("data", "2026", "file.json")
+
+
+def test_concatpath_ignore_null_et_convertit(registry) -> None:
+    assert run(registry, 'concatpath(["a", null, 3])') == os.path.join("a", "3")
+
+
+def test_concatpath_segment_absolu_repart_de_la_racine(registry) -> None:
+    root = os.path.abspath(os.sep)
+    out = run(registry, "concatpath($.p)", {"p": ["a", os.path.join(root, "etc"), "x"]})
+    assert out == os.path.join(root, "etc", "x")
+
+
+@pytest.mark.parametrize("value", [None, "abc", []])
+def test_concatpath_entrees_vides(registry, value) -> None:
+    assert run(registry, "concatpath($.p)", {"p": value}) in (None, "")
+
+
+def test_catalogue_documente(registry) -> None:
+    names = {e["name"]: e for e in registry.catalog()}
+    assert set(names) == {"loadjson", "iteratejsonfile", "concatpath"}
+    assert all(len(e["description"]) >= 15 for e in names.values())
+
+
+def test_decouverte_par_entry_point() -> None:
+    from urban_json import default_registry, load_plugins
+
+    load_plugins()
+    assert "loadjson" in default_registry