urban-json-http 0.1.0__tar.gz

urban_json_http-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_http-0.1.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: urban-json-http
+Version: 0.1.0
+Summary: Plugin urban-json : appels HTTP depuis les templates (http / httpget).
+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,http,rest,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 :: Internet :: WWW/HTTP
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: urban-json
+Requires-Dist: httpx>=0.24
+Dynamic: license-file
+
+# urban-json-http
+
+Plugin [urban-json](https://github.com/gaelgael5/Jslt) : appels **HTTP** depuis les
+templates. L'appel est formalisé comme un objet **Fetch / `RequestInit`** (le
+vocabulaire HTTP-en-JSON standard).
+
+## Installation
+
+```bash
+pip install urban-json-http      # tire urban-json et httpx
+```
+
+`urban-json` découvre le plugin automatiquement via les entry points (`urban_json.functions`).
+
+## Utilisation
+
+```python
+from urban_json import JsltTemplate
+
+tpl = JsltTemplate.parse('''
+{
+  "r:": http({
+    "method": "GET",
+    "url": "https://api.example.com/users",
+    "headers": { "Authorization": $.token },
+    "query": { "page": 1 }
+  }),
+  "code": r:$.status,
+  "users": r:$.body.items
+}
+''')
+tpl.transform({"token": "Bearer xyz"})
+```
+
+- `http(request)` — `request` : `{ method, url, headers, query, body, timeout }`.
+  Renvoie `{ status, headers, body }` ; `body` est le JSON parsé si la réponse est
+  du JSON, sinon le texte.
+- `httpget(url, headers)` — convenance GET renvoyant directement le `body`.
+
+Le corps (`body`) de la requête est envoyé en **JSON** si c'est un objet ou un
+tableau, sinon tel quel. Verbe par défaut : `GET`. Timeout par défaut : 30 s
+(surchargeable via `"timeout"`).
+
+## Sécurité
+
+`http` réalise de **vraies requêtes réseau**. Méfiez-vous des URL construites à
+partir de données non fiables (SSRF). Un timeout par défaut est appliqué.
+
+## Licence
+
+Apache-2.0.

urban_json_http-0.1.0/README.md

@@ -0,0 +1,51 @@
+# urban-json-http
+
+Plugin [urban-json](https://github.com/gaelgael5/Jslt) : appels **HTTP** depuis les
+templates. L'appel est formalisé comme un objet **Fetch / `RequestInit`** (le
+vocabulaire HTTP-en-JSON standard).
+
+## Installation
+
+```bash
+pip install urban-json-http      # tire urban-json et httpx
+```
+
+`urban-json` découvre le plugin automatiquement via les entry points (`urban_json.functions`).
+
+## Utilisation
+
+```python
+from urban_json import JsltTemplate
+
+tpl = JsltTemplate.parse('''
+{
+  "r:": http({
+    "method": "GET",
+    "url": "https://api.example.com/users",
+    "headers": { "Authorization": $.token },
+    "query": { "page": 1 }
+  }),
+  "code": r:$.status,
+  "users": r:$.body.items
+}
+''')
+tpl.transform({"token": "Bearer xyz"})
+```
+
+- `http(request)` — `request` : `{ method, url, headers, query, body, timeout }`.
+  Renvoie `{ status, headers, body }` ; `body` est le JSON parsé si la réponse est
+  du JSON, sinon le texte.
+- `httpget(url, headers)` — convenance GET renvoyant directement le `body`.
+
+Le corps (`body`) de la requête est envoyé en **JSON** si c'est un objet ou un
+tableau, sinon tel quel. Verbe par défaut : `GET`. Timeout par défaut : 30 s
+(surchargeable via `"timeout"`).
+
+## Sécurité
+
+`http` réalise de **vraies requêtes réseau**. Méfiez-vous des URL construites à
+partir de données non fiables (SSRF). Un timeout par défaut est appliqué.
+
+## Licence
+
+Apache-2.0.

urban_json_http-0.1.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "urban-json-http"
+dynamic = ["version"]
+description = "Plugin urban-json : appels HTTP depuis les templates (http / httpget)."
+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", "http", "rest", "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 :: Internet :: WWW/HTTP",
+    "Typing :: Typed",
+]
+dependencies = [
+    "urban-json",
+    "httpx>=0.24",
+]
+
+[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 http/httpget.
+[project.entry-points."urban_json.functions"]
+http = "urban_json_http:register"
+
+[tool.setuptools.dynamic]
+version = { attr = "urban_json_http.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+urban_json_http = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[tool.ruff]
+line-length = 100
+src = ["src", "tests"]

urban_json_http-0.1.0/setup.cfg

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

urban_json_http-0.1.0/src/urban_json_http/__init__.py

@@ -0,0 +1,110 @@
+"""Plugin jslt : appels HTTP depuis les templates (``http`` / ``httpget``).
+
+Le moteur .NET n'offre qu'un GET minimal (``loadhttpgetJson``). Ce plugin le
+remplace par une formalisation **déclarative** de l'appel, suivant la convention
+Fetch / ``RequestInit`` (le vocabulaire HTTP-en-JSON standard) :
+
+* ``http(request)`` — ``request`` est un objet
+  ``{method, url, headers, query, body, timeout}`` ; renvoie un objet réponse
+  ``{status, headers, body}`` (``body`` = JSON parsé si la réponse est du JSON,
+  sinon le texte brut).
+* ``httpget(url, headers)`` — convenance GET renvoyant directement le ``body``.
+
+Client HTTP : `httpx`. Le corps (``body``) est envoyé en JSON si c'est un objet ou
+un tableau, sinon tel quel.
+
+Sécurité : ``http`` réalise de **vraies requêtes réseau** vers l'URL fournie.
+Attention aux URL issues de données non fiables (SSRF). Un ``timeout`` par défaut
+(30 s) est appliqué et surchargeable par requête.
+
+Découvert automatiquement par ``jslt`` via l'entry point ``urban_json.functions``.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+__version__ = "0.1.0"
+
+__all__ = ["execute_http", "execute_httpget", "register"]
+
+#: Timeout par défaut (secondes) si la requête n'en précise pas.
+DEFAULT_TIMEOUT = 30.0
+
+
+def _build_client(timeout: float) -> httpx.Client:
+    """Fabrique le client HTTP. Point d'injection pour les tests (transport mocké)."""
+    return httpx.Client(timeout=timeout)
+
+
+def _parse_body(response: httpx.Response) -> Any:
+    """Corps de réponse : JSON parsé si le content-type est JSON, sinon texte."""
+    content_type = response.headers.get("content-type", "")
+    if "json" in content_type.lower():
+        try:
+            return response.json()
+        except ValueError:
+            return response.text
+    return response.text
+
+
+def execute_http(ctx: Any, request: Any = None) -> dict:
+    """Effectue un appel HTTP décrit par un objet Fetch/``RequestInit``.
+
+    Args:
+        request: objet ``{method, url, headers, query, body, timeout}``.
+            ``method`` défaut ``GET`` ; ``headers``/``query`` sont des objets ;
+            ``body`` est envoyé en JSON si objet/tableau, sinon tel quel.
+
+    Returns:
+        ``{"status": int, "headers": {...}, "body": <json|texte>}``.
+    """
+    if not isinstance(request, dict):
+        # ValueError (et non TypeError) : contrat « mauvais argument » uniforme.
+        raise ValueError("http: request doit être un objet {method, url, ...}")  # noqa: TRY004
+    url = request.get("url")
+    if not url:
+        raise ValueError("http: 'url' est requis")
+
+    method = str(request.get("method") or "GET").upper()
+    headers = {str(k): str(v) for k, v in (request.get("headers") or {}).items()}
+    params = request.get("query") or {}
+    body = request.get("body")
+    timeout = request.get("timeout", DEFAULT_TIMEOUT)
+
+    kwargs: dict[str, Any] = {"headers": headers, "params": params}
+    if isinstance(body, (dict, list)):
+        kwargs["json"] = body
+    elif body is not None:
+        kwargs["content"] = body if isinstance(body, (str, bytes)) else str(body)
+
+    with _build_client(timeout) as client:
+        response = client.request(method, url, **kwargs)
+
+    return {
+        "status": response.status_code,
+        "headers": dict(response.headers),
+        "body": _parse_body(response),
+    }
+
+
+def execute_httpget(ctx: Any, url: str | None = None, headers: Any = None) -> Any:
+    """GET de convenance : renvoie directement le corps (port « amélioré » du .NET)."""
+    response = execute_http(ctx, {"method": "GET", "url": url, "headers": headers or {}})
+    return response["body"]
+
+
+def register(registry: Any) -> None:
+    """Enregistre les fonctions du plugin dans un registre jslt (entry point)."""
+    registry.register(
+        "http",
+        execute_http,
+        description="Appel HTTP (objet Fetch {method,url,headers,query,body}) -> {status,headers,body}.",
+    )
+    registry.register(
+        "httpget",
+        execute_httpget,
+        description="GET HTTP renvoyant directement le corps (JSON parsé ou texte).",
+    )

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

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: urban-json-http
+Version: 0.1.0
+Summary: Plugin urban-json : appels HTTP depuis les templates (http / httpget).
+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,http,rest,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 :: Internet :: WWW/HTTP
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: urban-json
+Requires-Dist: httpx>=0.24
+Dynamic: license-file
+
+# urban-json-http
+
+Plugin [urban-json](https://github.com/gaelgael5/Jslt) : appels **HTTP** depuis les
+templates. L'appel est formalisé comme un objet **Fetch / `RequestInit`** (le
+vocabulaire HTTP-en-JSON standard).
+
+## Installation
+
+```bash
+pip install urban-json-http      # tire urban-json et httpx
+```
+
+`urban-json` découvre le plugin automatiquement via les entry points (`urban_json.functions`).
+
+## Utilisation
+
+```python
+from urban_json import JsltTemplate
+
+tpl = JsltTemplate.parse('''
+{
+  "r:": http({
+    "method": "GET",
+    "url": "https://api.example.com/users",
+    "headers": { "Authorization": $.token },
+    "query": { "page": 1 }
+  }),
+  "code": r:$.status,
+  "users": r:$.body.items
+}
+''')
+tpl.transform({"token": "Bearer xyz"})
+```
+
+- `http(request)` — `request` : `{ method, url, headers, query, body, timeout }`.
+  Renvoie `{ status, headers, body }` ; `body` est le JSON parsé si la réponse est
+  du JSON, sinon le texte.
+- `httpget(url, headers)` — convenance GET renvoyant directement le `body`.
+
+Le corps (`body`) de la requête est envoyé en **JSON** si c'est un objet ou un
+tableau, sinon tel quel. Verbe par défaut : `GET`. Timeout par défaut : 30 s
+(surchargeable via `"timeout"`).
+
+## Sécurité
+
+`http` réalise de **vraies requêtes réseau**. Méfiez-vous des URL construites à
+partir de données non fiables (SSRF). Un timeout par défaut est appliqué.
+
+## Licence
+
+Apache-2.0.

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

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

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[urban_json.functions]
+http = urban_json_http:register

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

@@ -0,0 +1,2 @@
+urban-json
+httpx>=0.24

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

@@ -0,0 +1 @@
+urban_json_http

urban_json_http-0.1.0/tests/test_http.py

@@ -0,0 +1,115 @@
+"""Tests du plugin urban-json-http (``http`` / ``httpget``).
+
+Aucune requête réseau réelle : on injecte un ``httpx.MockTransport`` via le point
+d'injection ``_build_client``. Couvre : GET/POST, en-têtes, query, corps JSON,
+réponse texte, convenance httpget, erreurs, découverte entry point, template.
+"""
+
+from __future__ import annotations
+
+import json
+
+import httpx
+import pytest
+from urban_json import FunctionRegistry, JsltTemplate
+
+import urban_json_http
+from urban_json_http import execute_http, execute_httpget, register
+
+
+@pytest.fixture
+def mock_http(monkeypatch):
+    """Installe un transport mocké ; renvoie la liste des requêtes capturées."""
+    captured = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        captured.append(request)
+        if request.url.path == "/text":
+            return httpx.Response(200, text="plain", headers={"content-type": "text/plain"})
+        if request.url.path == "/boom":
+            return httpx.Response(500, json={"error": "nope"})
+        return httpx.Response(
+            200,
+            json={"ok": True, "path": request.url.path},
+            headers={"x-demo": "1"},
+        )
+
+    transport = httpx.MockTransport(handler)
+    monkeypatch.setattr(
+        urban_json_http, "_build_client", lambda timeout: httpx.Client(transport=transport, timeout=timeout)
+    )
+    return captured
+
+
+def test_get_returns_structured_response(mock_http) -> None:
+    r = execute_http(None, {"method": "GET", "url": "https://api/x"})
+    assert r["status"] == 200
+    assert r["body"] == {"ok": True, "path": "/x"}
+    assert r["headers"]["x-demo"] == "1"
+
+
+def test_default_method_is_get(mock_http) -> None:
+    execute_http(None, {"url": "https://api/x"})
+    assert mock_http[0].method == "GET"
+
+
+def test_headers_and_query_are_sent(mock_http) -> None:
+    execute_http(
+        None,
+        {"url": "https://api/x", "headers": {"Authorization": "Bearer z"}, "query": {"page": 1}},
+    )
+    req = mock_http[0]
+    assert req.headers["authorization"] == "Bearer z"
+    assert req.url.params.get("page") == "1"
+
+
+def test_post_sends_json_body(mock_http) -> None:
+    execute_http(None, {"method": "POST", "url": "https://api/x", "body": {"a": 1}})
+    req = mock_http[0]
+    assert req.method == "POST"
+    assert json.loads(req.content) == {"a": 1}
+    assert "application/json" in req.headers["content-type"]
+
+
+def test_text_response_body(mock_http) -> None:
+    r = execute_http(None, {"url": "https://api/text"})
+    assert r["body"] == "plain"
+
+
+def test_httpget_returns_body(mock_http) -> None:
+    body = execute_httpget(None, "https://api/users")
+    assert body == {"ok": True, "path": "/users"}
+
+
+def test_error_status_still_returned(mock_http) -> None:
+    r = execute_http(None, {"url": "https://api/boom"})
+    assert r["status"] == 500
+    assert r["body"] == {"error": "nope"}
+
+
+def test_request_must_be_object() -> None:
+    with pytest.raises(ValueError, match="objet"):
+        execute_http(None, "not-an-object")
+
+
+def test_url_required() -> None:
+    with pytest.raises(ValueError, match="url"):
+        execute_http(None, {"method": "GET"})
+
+
+def test_register_into_custom_registry() -> None:
+    reg = FunctionRegistry()
+    register(reg)
+    assert "http" in reg and "httpget" in reg
+
+
+def test_discovered_via_entry_point() -> None:
+    from urban_json import default_registry, load_plugins
+
+    load_plugins(default_registry)
+    assert "http" in default_registry and "httpget" in default_registry
+
+
+def test_in_template(mock_http) -> None:
+    template = '{ "r:": http({ "url": "https://api/items" }), "code": r:$.status, "ok": r:$.body.ok }'
+    assert JsltTemplate.parse(template).transform({}) == {"code": 200, "ok": True}