urban-json-http 0.1.0__py3-none-any.whl

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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,8 @@
+urban_json_http/__init__.py,sha256=XAsD13Lw7WfY88-HMRRi7px8OS0RTs8MswVhmN5SYGI,4120
+urban_json_http/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+urban_json_http-0.1.0.dist-info/licenses/LICENSE,sha256=LdXMQzg0w6hrGI_vhgHsmOLKcHTkyF5PyUXkP9fV7mA,1068
+urban_json_http-0.1.0.dist-info/METADATA,sha256=I_KEA7tQR0Lr1_na7EieqBAjHMXIPdfc9Wev7_1ykiE,2558
+urban_json_http-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+urban_json_http-0.1.0.dist-info/entry_points.txt,sha256=FtPwpBt_RqFqBtdR1pe69cwwGKNxNGEzn3_anrvxkxs,55
+urban_json_http-0.1.0.dist-info/top_level.txt,sha256=mI3L1HVhgq2wJ00KK-xN_3GBscx1jhc9gc43HkCWVJI,16
+urban_json_http-0.1.0.dist-info/RECORD,,

urban_json_http-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

urban_json_http-0.1.0.dist-info/entry_points.txt

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

urban_json_http-0.1.0.dist-info/licenses/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.dist-info/top_level.txt

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