urban-json-db 0.1.0__tar.gz

urban_json_db-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_db-0.1.0/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: urban-json-db
+Version: 0.1.0
+Summary: Plugin urban-json : lecture en base de données SQL (connectsql / readsql).
+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,sql,database,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 :: Database
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: urban-json
+Provides-Extra: postgresql
+Requires-Dist: psycopg[binary]>=3; extra == "postgresql"
+Provides-Extra: mysql
+Requires-Dist: PyMySQL>=1; extra == "mysql"
+Dynamic: license-file
+
+# urban-json-db
+
+Plugin [urban-json](https://github.com/gaelgael5/Jslt) : lecture en **base de données
+SQL** depuis les templates. Port de `Bb.Jslt.Services.Sql.ServicesSql` (.NET).
+
+## Installation
+
+```bash
+pip install urban-json-db                 # SQLite inclus (stdlib), aucune dépendance en plus
+pip install "urban-json-db[postgresql]"   # + connecteur PostgreSQL (psycopg)
+pip install "urban-json-db[mysql]"        # + connecteur MySQL (PyMySQL)
+```
+
+`urban-json` découvre le plugin automatiquement via les entry points (`urban_json.functions`).
+
+## Utilisation
+
+```python
+from urban_json import JsltTemplate
+
+tpl = JsltTemplate.parse('''
+{
+  "cx:": connectsql("sqlite", "app.db"),
+  "users": [ { "$source": readsql(cx:, "SELECT id, name FROM users"), "id": $.id, "n": $.name } ]
+}
+''')
+tpl.transform({})
+# -> {"users": [{"id": 1, "n": "Alice"}, ...]}
+```
+
+- `connectsql(client, connection)` → descripteur `{client, connection}` (à stocker
+  dans une variable).
+- `readsql(connection, sql)` → tableau de lignes ; chaque ligne est un objet
+  `{"$_line": n, <colonnes...>}` (noms de colonnes assainis, comme en .NET).
+
+## Clients
+
+| Client | Chaîne de connexion | Fourni par |
+|---|---|---|
+| `sqlite` | chemin du fichier `.db` | stdlib (toujours disponible) |
+| `postgresql` | DSN psycopg | extra `postgresql` (à enregistrer) |
+| `mysql` | DSN PyMySQL | extra `mysql` (à enregistrer) |
+
+Ajouter un SGBD (connecteur DB-API 2.0) :
+
+```python
+import psycopg
+from urban_json_db import register_client
+register_client("postgresql", psycopg.connect)
+```
+
+## Sécurité
+
+`readsql` exécute la requête **telle quelle**. Ne construisez pas le SQL par
+concaténation de données non fiables (risque d'injection) : le contenu de `sql`
+relève de l'auteur du template.
+
+## Licence
+
+Apache-2.0.

urban_json_db-0.1.0/README.md

@@ -0,0 +1,60 @@
+# urban-json-db
+
+Plugin [urban-json](https://github.com/gaelgael5/Jslt) : lecture en **base de données
+SQL** depuis les templates. Port de `Bb.Jslt.Services.Sql.ServicesSql` (.NET).
+
+## Installation
+
+```bash
+pip install urban-json-db                 # SQLite inclus (stdlib), aucune dépendance en plus
+pip install "urban-json-db[postgresql]"   # + connecteur PostgreSQL (psycopg)
+pip install "urban-json-db[mysql]"        # + connecteur MySQL (PyMySQL)
+```
+
+`urban-json` découvre le plugin automatiquement via les entry points (`urban_json.functions`).
+
+## Utilisation
+
+```python
+from urban_json import JsltTemplate
+
+tpl = JsltTemplate.parse('''
+{
+  "cx:": connectsql("sqlite", "app.db"),
+  "users": [ { "$source": readsql(cx:, "SELECT id, name FROM users"), "id": $.id, "n": $.name } ]
+}
+''')
+tpl.transform({})
+# -> {"users": [{"id": 1, "n": "Alice"}, ...]}
+```
+
+- `connectsql(client, connection)` → descripteur `{client, connection}` (à stocker
+  dans une variable).
+- `readsql(connection, sql)` → tableau de lignes ; chaque ligne est un objet
+  `{"$_line": n, <colonnes...>}` (noms de colonnes assainis, comme en .NET).
+
+## Clients
+
+| Client | Chaîne de connexion | Fourni par |
+|---|---|---|
+| `sqlite` | chemin du fichier `.db` | stdlib (toujours disponible) |
+| `postgresql` | DSN psycopg | extra `postgresql` (à enregistrer) |
+| `mysql` | DSN PyMySQL | extra `mysql` (à enregistrer) |
+
+Ajouter un SGBD (connecteur DB-API 2.0) :
+
+```python
+import psycopg
+from urban_json_db import register_client
+register_client("postgresql", psycopg.connect)
+```
+
+## Sécurité
+
+`readsql` exécute la requête **telle quelle**. Ne construisez pas le SQL par
+concaténation de données non fiables (risque d'injection) : le contenu de `sql`
+relève de l'auteur du template.
+
+## Licence
+
+Apache-2.0.

urban_json_db-0.1.0/pyproject.toml

@@ -0,0 +1,63 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "urban-json-db"
+dynamic = ["version"]
+description = "Plugin urban-json : lecture en base de données SQL (connectsql / readsql)."
+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", "sql", "database", "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 :: Database",
+    "Typing :: Typed",
+]
+# SQLite est fourni par la stdlib : aucune dépendance au-delà du cœur.
+dependencies = [
+    "urban-json",
+]
+
+# SGBD additionnels en extras (connecteurs DB-API 2.0 à enregistrer via
+# register_client). Ex. : pip install urban-json-db[postgresql]
+[project.optional-dependencies]
+postgresql = ["psycopg[binary]>=3"]
+mysql = ["PyMySQL>=1"]
+
+[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 les fonctions.
+[project.entry-points."urban_json.functions"]
+db = "urban_json_db:register"
+
+[tool.setuptools.dynamic]
+version = { attr = "urban_json_db.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+urban_json_db = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[tool.ruff]
+line-length = 100
+src = ["src", "tests"]

urban_json_db-0.1.0/setup.cfg

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

urban_json_db-0.1.0/src/urban_json_db/__init__.py

@@ -0,0 +1,145 @@
+"""Plugin jslt : lecture en base de données SQL (``connectsql`` / ``readsql``).
+
+Port de ``Bb.Jslt.Services.Sql.ServicesSql`` (.NET), déjà un assembly séparé côté
+.NET. Deux fonctions de template :
+
+* ``connectsql(client, connection)`` → descripteur de connexion
+  ``{"client": ..., "connection": ...}`` (à stocker dans une variable) ;
+* ``readsql(connection, sql)`` → exécute la requête et renvoie un tableau de
+  lignes ; chaque ligne est un objet ``{"$_line": n, <colonnes...>}`` (noms de
+  colonnes assainis, comme en .NET).
+
+Le .NET s'appuie sur ``DbProviderFactory`` (clé ``client``). Le portage utilise un
+**registre de clients DB-API 2.0** : ``sqlite`` est fourni (stdlib, sans
+dépendance). D'autres SGBD s'ajoutent via :func:`register_client` ou en extras
+(PostgreSQL, MySQL…).
+
+Sécurité : ``readsql`` exécute la requête SQL **telle quelle**. Ne construis pas la
+requête par concaténation de données non fiables (risque d'injection) ; le contenu
+de ``sql`` est sous la responsabilité de l'auteur du template.
+
+Découvert automatiquement par ``jslt`` via l'entry point ``urban_json.functions``.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+import unicodedata
+from collections.abc import Callable
+from typing import Any
+
+__version__ = "0.1.0"
+
+__all__ = ["execute_connectsql", "execute_readsql", "register", "register_client"]
+
+#: Connexion DB-API 2.0 : une callable ``(connection_string) -> connection``.
+DbConnector = Callable[[str], Any]
+
+#: Registre des clients SQL (clé insensible à la casse) -> connecteur DB-API.
+_CLIENTS: dict[str, DbConnector] = {}
+
+
+def register_client(name: str, connector: DbConnector) -> None:
+    """Enregistre un client SQL (ex. ``register_client("postgresql", psycopg.connect)``).
+
+    ``connector`` reçoit la chaîne de connexion et renvoie une connexion DB-API 2.0.
+    """
+    _CLIENTS[name.lower()] = connector
+
+
+# Client intégré : SQLite (stdlib). Alias usuels, dont la forme « .NET-like ».
+register_client("sqlite", sqlite3.connect)
+register_client("sqlite3", sqlite3.connect)
+register_client("system.data.sqlite", sqlite3.connect)
+
+
+def _sanitize(name: str) -> str:
+    """Assainit un nom de colonne (même logique que urban-json-csv / ``ServiceCsv.GetLabel``)."""
+    decomposed = unicodedata.normalize("NFKD", name)
+    out: list[str] = []
+    for char in decomposed:
+        if unicodedata.combining(char):
+            continue
+        if char.isascii() and char.isalnum():
+            out.append(char)
+        elif char in (" ", "'", '"'):
+            out.append("_")
+    label = "".join(out)
+    while "___" in label:
+        label = label.replace("___", "_")
+    return label.replace("__", "_")
+
+
+def execute_connectsql(
+    ctx: Any, client: str | None = None, connection: str | None = None
+) -> dict:
+    """Crée un descripteur de connexion SQL (port de ``connectsql``).
+
+    Args:
+        client: clé du client SQL (``sqlite``, ou un client enregistré).
+        connection: chaîne de connexion (pour SQLite : chemin du fichier ``.db``).
+
+    Returns:
+        Un descripteur ``{"client": client, "connection": connection}`` à passer à
+        :func:`execute_readsql` (typiquement via une variable de template).
+    """
+    if not client:
+        raise ValueError("connectsql: client est requis")
+    if client.lower() not in _CLIENTS:
+        raise ValueError(
+            f"connectsql: client '{client}' inconnu. Clients disponibles : "
+            f"{', '.join(sorted(_CLIENTS))}"
+        )
+    return {"client": client, "connection": connection}
+
+
+def execute_readsql(ctx: Any, connection: Any = None, sql: str | None = None) -> list:
+    """Exécute une requête SQL et renvoie les lignes (port de ``readsql``).
+
+    Args:
+        connection: descripteur issu de :func:`execute_connectsql`.
+        sql: requête SQL à exécuter.
+
+    Returns:
+        La liste des lignes, chacune ``{"$_line": n, <colonne>: <valeur>, ...}``.
+    """
+    if not isinstance(connection, dict) or "client" not in connection:
+        raise ValueError("readsql: connection doit être le descripteur de connectsql")
+    if not sql:
+        raise ValueError("readsql: sql est requis")
+
+    client = connection["client"]
+    connector = _CLIENTS.get(str(client).lower())
+    if connector is None:
+        raise ValueError(f"readsql: client '{client}' inconnu")
+
+    conn = connector(connection.get("connection"))
+    try:
+        cursor = conn.cursor()
+        cursor.execute(sql)
+        if cursor.description is None:  # requête sans jeu de résultats
+            return []
+        columns = [_sanitize(col[0]) for col in cursor.description]
+        rows: list[dict] = []
+        for line, record in enumerate(cursor.fetchall(), start=1):
+            obj: dict[str, Any] = {"$_line": line}
+            for name, value in zip(columns, record):
+                obj[name] = value
+            rows.append(obj)
+        return rows
+    finally:
+        conn.close()
+
+
+def register(registry: Any) -> None:
+    """Enregistre les fonctions du plugin dans un registre jslt (entry point)."""
+    registry.register(
+        "connectsql",
+        execute_connectsql,
+        description="Crée un descripteur de connexion SQL (client + chaîne de connexion).",
+    )
+    registry.register(
+        "readsql",
+        execute_readsql,
+        description="Exécute une requête SQL et renvoie les lignes (tableau d'objets).",
+    )

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

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: urban-json-db
+Version: 0.1.0
+Summary: Plugin urban-json : lecture en base de données SQL (connectsql / readsql).
+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,sql,database,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 :: Database
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: urban-json
+Provides-Extra: postgresql
+Requires-Dist: psycopg[binary]>=3; extra == "postgresql"
+Provides-Extra: mysql
+Requires-Dist: PyMySQL>=1; extra == "mysql"
+Dynamic: license-file
+
+# urban-json-db
+
+Plugin [urban-json](https://github.com/gaelgael5/Jslt) : lecture en **base de données
+SQL** depuis les templates. Port de `Bb.Jslt.Services.Sql.ServicesSql` (.NET).
+
+## Installation
+
+```bash
+pip install urban-json-db                 # SQLite inclus (stdlib), aucune dépendance en plus
+pip install "urban-json-db[postgresql]"   # + connecteur PostgreSQL (psycopg)
+pip install "urban-json-db[mysql]"        # + connecteur MySQL (PyMySQL)
+```
+
+`urban-json` découvre le plugin automatiquement via les entry points (`urban_json.functions`).
+
+## Utilisation
+
+```python
+from urban_json import JsltTemplate
+
+tpl = JsltTemplate.parse('''
+{
+  "cx:": connectsql("sqlite", "app.db"),
+  "users": [ { "$source": readsql(cx:, "SELECT id, name FROM users"), "id": $.id, "n": $.name } ]
+}
+''')
+tpl.transform({})
+# -> {"users": [{"id": 1, "n": "Alice"}, ...]}
+```
+
+- `connectsql(client, connection)` → descripteur `{client, connection}` (à stocker
+  dans une variable).
+- `readsql(connection, sql)` → tableau de lignes ; chaque ligne est un objet
+  `{"$_line": n, <colonnes...>}` (noms de colonnes assainis, comme en .NET).
+
+## Clients
+
+| Client | Chaîne de connexion | Fourni par |
+|---|---|---|
+| `sqlite` | chemin du fichier `.db` | stdlib (toujours disponible) |
+| `postgresql` | DSN psycopg | extra `postgresql` (à enregistrer) |
+| `mysql` | DSN PyMySQL | extra `mysql` (à enregistrer) |
+
+Ajouter un SGBD (connecteur DB-API 2.0) :
+
+```python
+import psycopg
+from urban_json_db import register_client
+register_client("postgresql", psycopg.connect)
+```
+
+## Sécurité
+
+`readsql` exécute la requête **telle quelle**. Ne construisez pas le SQL par
+concaténation de données non fiables (risque d'injection) : le contenu de `sql`
+relève de l'auteur du template.
+
+## Licence
+
+Apache-2.0.

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

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

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[urban_json.functions]
+db = urban_json_db:register

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

@@ -0,0 +1,7 @@
+urban-json
+
+[mysql]
+PyMySQL>=1
+
+[postgresql]
+psycopg[binary]>=3

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

@@ -0,0 +1 @@
+urban_json_db

urban_json_db-0.1.0/tests/test_readsql.py

@@ -0,0 +1,85 @@
+"""Tests du plugin urban-json-db (``connectsql`` / ``readsql``) avec SQLite.
+
+Couvre : descripteur de connexion, lecture + ``$_line``, assainissement des noms
+de colonnes, client inconnu, découverte via entry point, usage en template.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+from pathlib import Path
+
+import pytest
+from urban_json import FunctionRegistry, JsltTemplate
+
+from urban_json_db import execute_connectsql, execute_readsql, register
+
+
+def _make_db(tmp_path: Path) -> str:
+    path = tmp_path / "app.db"
+    conn = sqlite3.connect(path)
+    conn.execute("CREATE TABLE users (id INTEGER, name TEXT, active INTEGER)")
+    conn.executemany(
+        "INSERT INTO users VALUES (?, ?, ?)",
+        [(1, "Alice", 1), (2, "Bob", 0)],
+    )
+    conn.commit()
+    conn.close()
+    return str(path)
+
+
+def test_connectsql_descriptor() -> None:
+    cx = execute_connectsql(None, "sqlite", "/tmp/x.db")
+    assert cx == {"client": "sqlite", "connection": "/tmp/x.db"}
+
+
+def test_connectsql_unknown_client() -> None:
+    with pytest.raises(ValueError, match="inconnu"):
+        execute_connectsql(None, "oracle", "x")
+
+
+def test_readsql_rows_and_line(tmp_path: Path) -> None:
+    cx = execute_connectsql(None, "sqlite", _make_db(tmp_path))
+    rows = execute_readsql(None, cx, "SELECT id, name FROM users ORDER BY id")
+    assert rows == [
+        {"$_line": 1, "id": 1, "name": "Alice"},
+        {"$_line": 2, "name": "Bob", "id": 2},
+    ]
+
+
+def test_readsql_column_name_sanitized(tmp_path: Path) -> None:
+    cx = execute_connectsql(None, "sqlite", _make_db(tmp_path))
+    rows = execute_readsql(None, cx, 'SELECT name AS "Full Name" FROM users WHERE id = 1')
+    assert rows == [{"$_line": 1, "Full_Name": "Alice"}]
+
+
+def test_readsql_requires_descriptor() -> None:
+    with pytest.raises(ValueError, match="descripteur"):
+        execute_readsql(None, "not-a-descriptor", "SELECT 1")
+
+
+def test_register_into_custom_registry() -> None:
+    reg = FunctionRegistry()
+    register(reg)
+    assert "connectsql" in reg and "readsql" in reg
+
+
+def test_discovered_via_entry_point() -> None:
+    from urban_json import default_registry, load_plugins
+
+    load_plugins(default_registry)
+    assert "connectsql" in default_registry and "readsql" in default_registry
+
+
+def test_in_template(tmp_path: Path) -> None:
+    db = _make_db(tmp_path)
+    template = (
+        "{"
+        f'  "cx:": connectsql("sqlite", "{db}"),'
+        '  "rows": [ { "$source": readsql(cx:, "SELECT id, name FROM users ORDER BY id"),'
+        '             "id": $.id, "n": $.name } ]'
+        "}"
+    )
+    assert JsltTemplate.parse(template).transform({}) == {
+        "rows": [{"id": 1, "n": "Alice"}, {"id": 2, "n": "Bob"}]
+    }