urban-json-random 0.1.0__tar.gz

urban_json_random-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_random-0.1.0/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: urban-json-random
+Version: 0.1.0
+Summary: Plugin urban-json : génération de données aléatoires (fonctions de template getrandom_*).
+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,random,fake-data,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 :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: urban-json
+Requires-Dist: faker>=20
+Requires-Dist: rstr>=3.2
+Dynamic: license-file
+
+# urban-json-random
+
+Plugin [urban-json](https://github.com/gaelgael5/Jslt) : **données aléatoires** dans
+les templates, via les 25 fonctions `getrandom_*` du moteur .NET d'origine (port de
+`Services.randoms.cs`). Utile pour produire des jeux de test réalistes.
+
+## Installation
+
+```bash
+pip install urban-json-random      # tire urban-json, Faker et rstr
+```
+
+Rien d'autre à faire : `urban-json` découvre le plugin automatiquement via les entry
+points (`urban_json.functions`).
+
+## Utilisation
+
+```python
+from urban_json import JsltTemplate
+
+tpl = JsltTemplate.parse("""{
+  "id": getrandom_integer(1, false, 1000, false),
+  "client": getrandom_fullname(),
+  "email": getrandom_email(),
+  "iban": getrandom_iban("FR"),
+  "ref": getrandom_string(0, 0, "^[A-Z]{3}-\\\\d{4}$")
+}""")
+tpl.transform({})
+# -> {'id': 417, 'client': 'Jane Doe', 'email': '…', 'iban': 'FR76…', 'ref': 'QZT-0381'}
+```
+
+## Fonctions
+
+| Famille | Fonctions |
+|---|---|
+| Nombres | `getrandom_integer`, `getrandom_long`, `getrandom_short`, `getrandom_byte`, `getrandom_double`, `getrandom_float` — `(minimum, exclusiveMinimum, maximum, exclusiveMaximum)` |
+| Texte | `getrandom_string(min_length, max_length, pattern)`, `getrandom_lipsum(paragraphs)`, `getrandom_password(token, length)`, `getrandom_naughtystrings()` |
+| Personnes | `getrandom_firstname`, `getrandom_lastname`, `getrandom_fullname`, `getrandom_email` |
+| Lieux | `getrandom_city`, `getrandom_country` |
+| Réseau | `getrandom_ipv4`, `getrandom_ipv6`, `getrandom_macaddress(minimum, maximum)` |
+| Banque | `getrandom_iban(pays, include_iban, include_bban)` |
+| Temps | `getrandom_datatime()` (nom d'origine conservé), `getrandom_timespan()` |
+| Divers | `getrandom_boolean()`, `getrandom_binary(min_length, max_length)`, `getrandom_in_list(items)` |
+
+## Écarts volontaires avec le .NET
+
+- `exclusiveMinimum` / `exclusiveMaximum` excluent la borne (sens JSON Schema) ; le
+  .NET élargissait au contraire l'intervalle.
+- Sans bornes : étendue du type (`integer` 0 à 2³¹−1, `double` dans [0, 1)…) ; le .NET
+  générait souvent toujours 0.
+- Intervalle impossible : erreur `JsltError` explicite.
+- `getrandom_boolean` et `getrandom_in_list` font un vrai tirage (le .NET prenait la
+  parité des millisecondes) ; liste vide → `null`.
+- `getrandom_password` utilise un générateur cryptographique (`secrets`).
+- Dates et durées en texte : ISO 8601 et `hh:mm:ss.fff`.

urban_json_random-0.1.0/README.md

@@ -0,0 +1,55 @@
+# urban-json-random
+
+Plugin [urban-json](https://github.com/gaelgael5/Jslt) : **données aléatoires** dans
+les templates, via les 25 fonctions `getrandom_*` du moteur .NET d'origine (port de
+`Services.randoms.cs`). Utile pour produire des jeux de test réalistes.
+
+## Installation
+
+```bash
+pip install urban-json-random      # tire urban-json, Faker et rstr
+```
+
+Rien d'autre à faire : `urban-json` découvre le plugin automatiquement via les entry
+points (`urban_json.functions`).
+
+## Utilisation
+
+```python
+from urban_json import JsltTemplate
+
+tpl = JsltTemplate.parse("""{
+  "id": getrandom_integer(1, false, 1000, false),
+  "client": getrandom_fullname(),
+  "email": getrandom_email(),
+  "iban": getrandom_iban("FR"),
+  "ref": getrandom_string(0, 0, "^[A-Z]{3}-\\\\d{4}$")
+}""")
+tpl.transform({})
+# -> {'id': 417, 'client': 'Jane Doe', 'email': '…', 'iban': 'FR76…', 'ref': 'QZT-0381'}
+```
+
+## Fonctions
+
+| Famille | Fonctions |
+|---|---|
+| Nombres | `getrandom_integer`, `getrandom_long`, `getrandom_short`, `getrandom_byte`, `getrandom_double`, `getrandom_float` — `(minimum, exclusiveMinimum, maximum, exclusiveMaximum)` |
+| Texte | `getrandom_string(min_length, max_length, pattern)`, `getrandom_lipsum(paragraphs)`, `getrandom_password(token, length)`, `getrandom_naughtystrings()` |
+| Personnes | `getrandom_firstname`, `getrandom_lastname`, `getrandom_fullname`, `getrandom_email` |
+| Lieux | `getrandom_city`, `getrandom_country` |
+| Réseau | `getrandom_ipv4`, `getrandom_ipv6`, `getrandom_macaddress(minimum, maximum)` |
+| Banque | `getrandom_iban(pays, include_iban, include_bban)` |
+| Temps | `getrandom_datatime()` (nom d'origine conservé), `getrandom_timespan()` |
+| Divers | `getrandom_boolean()`, `getrandom_binary(min_length, max_length)`, `getrandom_in_list(items)` |
+
+## Écarts volontaires avec le .NET
+
+- `exclusiveMinimum` / `exclusiveMaximum` excluent la borne (sens JSON Schema) ; le
+  .NET élargissait au contraire l'intervalle.
+- Sans bornes : étendue du type (`integer` 0 à 2³¹−1, `double` dans [0, 1)…) ; le .NET
+  générait souvent toujours 0.
+- Intervalle impossible : erreur `JsltError` explicite.
+- `getrandom_boolean` et `getrandom_in_list` font un vrai tirage (le .NET prenait la
+  parité des millisecondes) ; liste vide → `null`.
+- `getrandom_password` utilise un générateur cryptographique (`secrets`).
+- Dates et durées en texte : ISO 8601 et `hh:mm:ss.fff`.

urban_json_random-0.1.0/pyproject.toml

@@ -0,0 +1,62 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "urban-json-random"
+dynamic = ["version"]
+description = "Plugin urban-json : génération de données aléatoires (fonctions de template getrandom_*)."
+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", "random", "fake-data", "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 :: Software Development :: Testing",
+    "Typing :: Typed",
+]
+dependencies = [
+    "urban-json",
+    # Noms, villes, pays, e-mails, IBAN, adresses réseau, lorem ipsum (rôle tenu
+    # par RandomDataGenerator côté .NET). Borne basse large : Faker récent exige
+    # Python >= 3.10, pip choisit la version compatible avec chaque interpréteur.
+    "faker>=20",
+    # Chaîne aléatoire conforme à un motif regex (getrandom_string avec pattern).
+    "rstr>=3.2",
+]
+
+[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 getrandom_*.
+[project.entry-points."urban_json.functions"]
+random = "urban_json_random:register"
+
+[tool.setuptools.dynamic]
+version = { attr = "urban_json_random.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+urban_json_random = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[tool.ruff]
+line-length = 100
+src = ["src", "tests"]

urban_json_random-0.1.0/setup.cfg

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

urban_json_random-0.1.0/src/urban_json_random/__init__.py

@@ -0,0 +1,310 @@
+"""Plugin urban-json : génération de données aléatoires (``getrandom_*``).
+
+Port des 25 fonctions de ``Services.randoms.cs`` (.NET), qui s'appuyaient sur
+``RandomDataGenerator`` ; ici, Faker (noms, lieux, e-mails, IBAN, réseau,
+lorem ipsum) et rstr (chaîne conforme à un motif regex). Les noms d'origine sont
+conservés, y compris ``getrandom_datatime`` (faute de frappe du .NET), pour que
+les templates existants fonctionnent tels quels.
+
+Découvert automatiquement via l'entry point ``urban_json.functions`` ; aussi
+enregistrable à la main : ``from urban_json_random import register``.
+
+Écarts volontaires vs .NET (comportement voulu, pas les bugs) :
+
+* ``exclusiveMinimum`` / ``exclusiveMaximum`` suivent JSON Schema (borne
+  exclue). Le .NET faisait ``min--`` / ``max++`` : il *élargissait* l'intervalle.
+* Bornes absentes : étendue du type (``integer`` 0..2³¹−1, ``double`` [0, 1)…).
+  Le .NET générait souvent ``[0, 0]``, donc toujours 0.
+* Intervalle impossible (min > max) : ``JsltError`` au lieu d'une exception .NET.
+* ``getrandom_boolean`` / ``getrandom_in_list`` : vrai tirage aléatoire (le .NET
+  prenait la parité des millisecondes de l'horloge) ; liste vide -> ``null``.
+* ``getrandom_password`` : générateur cryptographique (``secrets``), même
+  alphabet que le .NET.
+* Dates et durées rendues en texte (le portage n'a pas de type date) :
+  ``getrandom_datatime`` en ISO 8601, ``getrandom_timespan`` en ``hh:mm:ss.fff``.
+"""
+
+from __future__ import annotations
+
+import base64
+import random
+import secrets
+import string
+from datetime import datetime, timedelta
+from functools import cache
+from typing import Any
+
+from urban_json import JsltError
+
+from ._naughty import NAUGHTY_STRINGS
+
+__version__ = "0.1.0"
+
+__all__ = ["NAUGHTY_STRINGS", "register"]
+
+_RNG = random.SystemRandom()
+
+# Étendue par défaut de chaque type entier (bornes .NET des types d'origine).
+_INT_RANGES = {
+    "getrandom_byte": (0, 255),
+    "getrandom_short": (-(2**15), 2**15 - 1),
+    "getrandom_integer": (-(2**31), 2**31 - 1),
+    "getrandom_long": (-(2**63), 2**63 - 1),
+}
+
+
+@cache
+def _faker(locale: str = "en_US") -> Any:
+    from faker import Faker  # import différé : Faker charge beaucoup de données
+
+    return Faker(locale)
+
+
+def _flag(value: Any) -> bool:
+    return value is True or (isinstance(value, str) and value.strip().lower() == "true")
+
+
+def _int_bounds(name: str, minimum: Any, exclusive_min: Any, maximum: Any, exclusive_max: Any) -> tuple[int, int]:
+    type_low, type_high = _INT_RANGES[name]
+    low = 0 if minimum is None else int(minimum)
+    high = type_high if maximum is None else int(maximum)
+    if _flag(exclusive_min):
+        low += 1
+    if _flag(exclusive_max):
+        high -= 1
+    if not (type_low <= low <= type_high and type_low <= high <= type_high):
+        raise JsltError(f"{name} : bornes hors de l'étendue du type [{type_low}, {type_high}]")
+    if low > high:
+        raise JsltError(f"{name} : intervalle vide (minimum {low} > maximum {high})")
+    return low, high
+
+
+def _make_int(name: str):
+    def generate(ctx: Any, minimum: Any = None, exclusive_minimum: Any = None,
+                 maximum: Any = None, exclusive_maximum: Any = None) -> int:
+        low, high = _int_bounds(name, minimum, exclusive_minimum, maximum, exclusive_maximum)
+        return _RNG.randint(low, high)
+
+    return generate
+
+
+def _make_real(name: str, single: bool):
+    def generate(ctx: Any, minimum: Any = None, exclusive_minimum: Any = None,
+                 maximum: Any = None, exclusive_maximum: Any = None) -> float:
+        low = 0.0 if minimum is None else float(minimum)
+        high = 1.0 if maximum is None else float(maximum)
+        excl_low, excl_high = _flag(exclusive_minimum), _flag(exclusive_maximum)
+        if low > high or (low == high and (excl_low or excl_high)):
+            raise JsltError(f"{name} : intervalle vide (minimum {low}, maximum {high})")
+        while True:
+            value = _RNG.uniform(low, high)
+            if single:
+                value = float(f"{value:.7g}")  # précision d'un float .NET (simple)
+            if (excl_low and value <= low) or (excl_high and value >= high):
+                continue
+            if low <= value <= high:
+                return value
+
+    return generate
+
+
+def getrandom_string(ctx: Any, min_length: Any = None, max_length: Any = None, pattern: Any = None) -> str:
+    if pattern:
+        import re
+
+        import rstr
+
+        try:
+            re.compile(pattern)
+        except re.error as exc:
+            raise JsltError(f"getrandom_string : motif regex invalide {pattern!r} : {exc}") from exc
+        # Les ancres ^ $ délimitent déjà la chaîne produite : on les retire avant de générer.
+        body = pattern.removeprefix("^")
+        if body.endswith("$") and not body.endswith("\\$"):
+            body = body[:-1]
+        return rstr.xeger(body)
+    low = 1 if not min_length else int(min_length)
+    high = low + 5 if not max_length else int(max_length)
+    if low > high:
+        raise JsltError(f"getrandom_string : intervalle de longueur vide ({low} > {high})")
+    alphabet = string.ascii_letters + string.digits + " "
+    length = _RNG.randint(low, high)
+    # Pas d'espace en tête ni en fin : le texte reste lisible et sa longueur exacte.
+    inner = "".join(_RNG.choice(alphabet) for _ in range(max(0, length - 2)))
+    edge = string.ascii_letters + string.digits
+    if length == 1:
+        return _RNG.choice(edge)
+    return _RNG.choice(edge) + inner + _RNG.choice(edge)
+
+
+def getrandom_datatime(ctx: Any) -> str:
+    # Sans fuseau, comme les dates « Unspecified » du .NET et `now()` du cœur.
+    start = datetime(1970, 1, 1)  # noqa: DTZ001
+    span = (datetime(2050, 12, 31, 23, 59, 59) - start).total_seconds()  # noqa: DTZ001
+    return (start + timedelta(seconds=_RNG.randint(0, int(span)))).isoformat()
+
+
+def getrandom_timespan(ctx: Any) -> str:
+    total_ms = _RNG.randint(0, 24 * 3600 * 1000 - 1)
+    seconds, ms = divmod(total_ms, 1000)
+    minutes, sec = divmod(seconds, 60)
+    hours, minute = divmod(minutes, 60)
+    return f"{hours:02d}:{minute:02d}:{sec:02d}.{ms:03d}"
+
+
+def getrandom_email(ctx: Any) -> str:
+    return _faker().email()
+
+
+def getrandom_ipv4(ctx: Any) -> str:
+    return _faker().ipv4()
+
+
+def getrandom_ipv6(ctx: Any) -> str:
+    return _faker().ipv6().upper()
+
+
+def getrandom_binary(ctx: Any, min_length: Any = None, max_length: Any = None) -> str:
+    low = 1 if min_length is None else int(min_length)
+    high = low + 5 if max_length is None else int(max_length)
+    if low > high or low < 0:
+        raise JsltError(f"getrandom_binary : intervalle de longueur invalide ({low}, {high})")
+    return base64.b64encode(secrets.token_bytes(_RNG.randint(low, high))).decode("ascii")
+
+
+def getrandom_boolean(ctx: Any) -> bool:
+    return _RNG.random() < 0.5
+
+
+def getrandom_city(ctx: Any) -> str:
+    return _faker().city()
+
+
+def getrandom_country(ctx: Any) -> str:
+    return _faker().country()
+
+
+def getrandom_lastname(ctx: Any) -> str:
+    return _faker().last_name()
+
+
+def getrandom_firstname(ctx: Any) -> str:
+    return _faker().first_name()
+
+
+def getrandom_fullname(ctx: Any) -> str:
+    fake = _faker()
+    return f"{fake.first_name()} {fake.last_name()}"
+
+
+# Pays ISO 3166-1 alpha-2 -> locale Faker qui sait produire son IBAN.
+_IBAN_LOCALES = {
+    "AT": "de_AT", "BE": "nl_BE", "CH": "de_CH", "CZ": "cs_CZ", "DE": "de_DE", "DK": "da_DK",
+    "ES": "es_ES", "FI": "fi_FI", "FR": "fr_FR", "GB": "en_GB", "GR": "el_GR", "IE": "en_IE",
+    "IT": "it_IT", "NL": "nl_NL", "NO": "no_NO", "PL": "pl_PL", "PT": "pt_PT", "SE": "sv_SE",
+}
+
+
+def getrandom_iban(ctx: Any, country_code_iso2: Any = None, include_iban: Any = None, include_bban: Any = None) -> str:
+    country = (str(country_code_iso2).strip().upper() if country_code_iso2 else "GB")
+    locale = _IBAN_LOCALES.get(country)
+    if locale is None:
+        raise JsltError(
+            f"getrandom_iban : pays non pris en charge {country_code_iso2!r} "
+            f"(codes : {', '.join(sorted(_IBAN_LOCALES))})"
+        )
+    fake = _faker(locale)
+    if _flag(include_bban):
+        # .NET : BBAN seul si l'IBAN est explicitement exclu, sinon l'un ou l'autre.
+        if include_iban is not None and not _flag(include_iban):
+            return fake.bban()
+        return fake.iban() if _RNG.random() < 0.5 else fake.bban()
+    return fake.iban()
+
+
+def _mac_int(text: Any, default: int) -> int:
+    if text is None or text == "":
+        return default
+    digits = str(text).replace(":", "").replace("-", "")
+    try:
+        value = int(digits, 16)
+    except ValueError as exc:
+        raise JsltError(f"getrandom_macaddress : adresse MAC invalide {text!r}") from exc
+    if len(digits) != 12:
+        raise JsltError(f"getrandom_macaddress : adresse MAC invalide {text!r}")
+    return value
+
+
+def getrandom_macaddress(ctx: Any, minimum: Any = None, maximum: Any = None) -> str:
+    low, high = _mac_int(minimum, 0), _mac_int(maximum, 2**48 - 1)
+    if low > high:
+        raise JsltError("getrandom_macaddress : intervalle vide (minimum > maximum)")
+    raw = f"{_RNG.randint(low, high):012X}"
+    return ":".join(raw[i:i + 2] for i in range(0, 12, 2))
+
+
+def getrandom_lipsum(ctx: Any, paragraphs: Any = None) -> str:
+    count = max(1, int(paragraphs or 0))
+    return "\n".join(_faker().paragraphs(nb=count))
+
+
+def getrandom_naughtystrings(ctx: Any) -> str:
+    return _RNG.choice(NAUGHTY_STRINGS)
+
+
+def getrandom_in_list(ctx: Any, items: Any = None) -> Any:
+    if not isinstance(items, list) or not items:
+        return None
+    return _RNG.choice(items)
+
+
+# Alphabet du .NET (Services.randoms.cs), conservé pour des mots de passe comparables.
+_PASSWORD_ALPHABET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890&é'(-è_çà)=$ù%*µ,?;:/.?'"
+
+
+def getrandom_password(ctx: Any, token: Any = None, length: Any = None) -> str:
+    # `token` est ignoré, comme en .NET : il est gardé pour la compatibilité des templates.
+    size = int(length or 0) or 12
+    return "".join(secrets.choice(_PASSWORD_ALPHABET) for _ in range(size))
+
+
+_RANGE = "(minimum, exclusiveMinimum, maximum, exclusiveMaximum ; bornes exclues si les drapeaux valent true)"
+
+_FUNCTIONS: list[tuple[str, Any, str]] = [
+    ("getrandom_integer", _make_int("getrandom_integer"), f"Entier aléatoire 32 bits {_RANGE}"),
+    ("getrandom_long", _make_int("getrandom_long"), f"Entier aléatoire 64 bits {_RANGE}"),
+    ("getrandom_short", _make_int("getrandom_short"), f"Entier aléatoire 16 bits {_RANGE}"),
+    ("getrandom_byte", _make_int("getrandom_byte"), f"Entier aléatoire de 0 à 255 {_RANGE}"),
+    ("getrandom_double", _make_real("getrandom_double", single=False), f"Décimal aléatoire, [0, 1) par défaut {_RANGE}"),
+    ("getrandom_float", _make_real("getrandom_float", single=True), f"Décimal aléatoire en simple précision {_RANGE}"),
+    ("getrandom_string", getrandom_string,
+     "Texte aléatoire (lettres, chiffres, espaces) de min_length à max_length caractères, ou conforme au motif regex"),
+    ("getrandom_datatime", getrandom_datatime, "Date et heure aléatoires entre 1970 et 2050, en ISO 8601"),
+    ("getrandom_timespan", getrandom_timespan, "Durée aléatoire de moins d'un jour, au format hh:mm:ss.fff"),
+    ("getrandom_email", getrandom_email, "Adresse e-mail aléatoire"),
+    ("getrandom_ipv4", getrandom_ipv4, "Adresse IPv4 aléatoire"),
+    ("getrandom_ipv6", getrandom_ipv6, "Adresse IPv6 aléatoire, en majuscules"),
+    ("getrandom_binary", getrandom_binary, "Octets aléatoires de min_length à max_length, encodés en Base64"),
+    ("getrandom_boolean", getrandom_boolean, "Booléen aléatoire, true ou false"),
+    ("getrandom_city", getrandom_city, "Nom de ville aléatoire"),
+    ("getrandom_country", getrandom_country, "Nom de pays aléatoire"),
+    ("getrandom_lastname", getrandom_lastname, "Nom de famille aléatoire"),
+    ("getrandom_firstname", getrandom_firstname, "Prénom aléatoire"),
+    ("getrandom_fullname", getrandom_fullname, "Prénom et nom aléatoires"),
+    ("getrandom_iban", getrandom_iban,
+     "IBAN valide aléatoire pour un pays ISO (FR, DE, GB…) ; BBAN si include_bban vaut true et include_iban false"),
+    ("getrandom_macaddress", getrandom_macaddress,
+     "Adresse MAC aléatoire (AA:BB:…), éventuellement entre deux adresses minimum et maximum"),
+    ("getrandom_lipsum", getrandom_lipsum, "Texte lorem ipsum de n paragraphes (1 par défaut)"),
+    ("getrandom_naughtystrings", getrandom_naughtystrings,
+     "Chaîne piégeuse pour les tests (Unicode, injection, formats limites)"),
+    ("getrandom_in_list", getrandom_in_list, "Élément tiré au hasard dans un tableau (null s'il est vide)"),
+    ("getrandom_password", getrandom_password,
+     "Mot de passe aléatoire de length caractères (12 par défaut) ; le 1er argument est ignoré"),
+]
+
+
+def register(registry: Any) -> None:
+    """Enregistre les 25 fonctions ``getrandom_*`` dans un registre jslt."""
+    for name, function, description in _FUNCTIONS:
+        registry.register(name, function, description=description)

urban_json_random-0.1.0/src/urban_json_random/_naughty.py

@@ -0,0 +1,66 @@
+"""Chaînes piégeuses pour éprouver un traitement de texte (``getrandom_naughtystrings``).
+
+Extrait de la « Big List of Naughty Strings » (Max Woolf, licence MIT,
+https://github.com/minimaxir/big-list-of-naughty-strings), la source qu'utilise
+``RandomDataGenerator`` côté .NET. Une entrée par famille de piège, pas la liste
+complète : l'objectif est la variété, pas l'exhaustivité.
+"""
+
+from __future__ import annotations
+
+NAUGHTY_STRINGS: tuple[str, ...] = (
+    # vides et réservés
+    "",
+    " ",
+    "undefined",
+    "null",
+    "NULL",
+    "nil",
+    "None",
+    "true",
+    "false",
+    "NaN",
+    "Infinity",
+    "-Infinity",
+    "0",
+    "-0",
+    "0.0",
+    "1E+02",
+    "0xffffffff",
+    "999999999999999999999",
+    "1/0",
+    # espaces et contrôles
+    "\t",
+    "\u00a0",
+    "\u200b",
+    "\ufeff",
+    "\u2028",
+    # Unicode
+    "Ω≈ç√∫˜µ≤≥÷",
+    "Œ„´‰ˇÁ¨ˆØ∏”’",
+    "田中さんにあげて下さい",
+    "社會科學院語學研究所",
+    "울란바토르",
+    "👾 🙇 💁 🙅 🙆 🙋 🙎 🙍",
+    "👨‍👩‍👦",
+    "ثم نفس سقطت وبالتحديد",
+    "בְּרֵאשִׁית, בָּרָא אֱלֹהִים",
+    "Ṱ̺̺̕o͞ ̷i̲̬͇̪͙n̝̗͕v̟̜̘̦͟o̶̙̰̠kè͚̮̺̪̹̱̤ ̖t̝͕̳̣̻̪͞h̼͓̲̦̳̘̲e͇̣̰̦̬͎ ̢̼̻̱̘h͚͎͙̜̣̲ͅi̦̲̣̰̤v̻͍e̺̭̳̪̰-m̢iͅn̖̺̞̲̯̰d̵̼̟͙̩̼̘̳",
+    "ﾟ･✿ヾ╲(｡◕‿◕｡)╱✿･ﾟ",
+    # injections et formats
+    "<script>alert(123)</script>",
+    "<img src=x onerror=alert(1)>",
+    "javascript:alert(1)",
+    "' OR '1'='1",
+    "1; DROP TABLE users",
+    "${7*7}",
+    "{{7*7}}",
+    "%s%s%s%s%s",
+    "../../../../../../etc/passwd",
+    "C:\\Windows\\System32",
+    "$HOME",
+    "`ls -la`",
+    "\\\\",
+    '"',
+    "'",
+)

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

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: urban-json-random
+Version: 0.1.0
+Summary: Plugin urban-json : génération de données aléatoires (fonctions de template getrandom_*).
+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,random,fake-data,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 :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: urban-json
+Requires-Dist: faker>=20
+Requires-Dist: rstr>=3.2
+Dynamic: license-file
+
+# urban-json-random
+
+Plugin [urban-json](https://github.com/gaelgael5/Jslt) : **données aléatoires** dans
+les templates, via les 25 fonctions `getrandom_*` du moteur .NET d'origine (port de
+`Services.randoms.cs`). Utile pour produire des jeux de test réalistes.
+
+## Installation
+
+```bash
+pip install urban-json-random      # tire urban-json, Faker et rstr
+```
+
+Rien d'autre à faire : `urban-json` découvre le plugin automatiquement via les entry
+points (`urban_json.functions`).
+
+## Utilisation
+
+```python
+from urban_json import JsltTemplate
+
+tpl = JsltTemplate.parse("""{
+  "id": getrandom_integer(1, false, 1000, false),
+  "client": getrandom_fullname(),
+  "email": getrandom_email(),
+  "iban": getrandom_iban("FR"),
+  "ref": getrandom_string(0, 0, "^[A-Z]{3}-\\\\d{4}$")
+}""")
+tpl.transform({})
+# -> {'id': 417, 'client': 'Jane Doe', 'email': '…', 'iban': 'FR76…', 'ref': 'QZT-0381'}
+```
+
+## Fonctions
+
+| Famille | Fonctions |
+|---|---|
+| Nombres | `getrandom_integer`, `getrandom_long`, `getrandom_short`, `getrandom_byte`, `getrandom_double`, `getrandom_float` — `(minimum, exclusiveMinimum, maximum, exclusiveMaximum)` |
+| Texte | `getrandom_string(min_length, max_length, pattern)`, `getrandom_lipsum(paragraphs)`, `getrandom_password(token, length)`, `getrandom_naughtystrings()` |
+| Personnes | `getrandom_firstname`, `getrandom_lastname`, `getrandom_fullname`, `getrandom_email` |
+| Lieux | `getrandom_city`, `getrandom_country` |
+| Réseau | `getrandom_ipv4`, `getrandom_ipv6`, `getrandom_macaddress(minimum, maximum)` |
+| Banque | `getrandom_iban(pays, include_iban, include_bban)` |
+| Temps | `getrandom_datatime()` (nom d'origine conservé), `getrandom_timespan()` |
+| Divers | `getrandom_boolean()`, `getrandom_binary(min_length, max_length)`, `getrandom_in_list(items)` |
+
+## Écarts volontaires avec le .NET
+
+- `exclusiveMinimum` / `exclusiveMaximum` excluent la borne (sens JSON Schema) ; le
+  .NET élargissait au contraire l'intervalle.
+- Sans bornes : étendue du type (`integer` 0 à 2³¹−1, `double` dans [0, 1)…) ; le .NET
+  générait souvent toujours 0.
+- Intervalle impossible : erreur `JsltError` explicite.
+- `getrandom_boolean` et `getrandom_in_list` font un vrai tirage (le .NET prenait la
+  parité des millisecondes) ; liste vide → `null`.
+- `getrandom_password` utilise un générateur cryptographique (`secrets`).
+- Dates et durées en texte : ISO 8601 et `hh:mm:ss.fff`.

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

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

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[urban_json.functions]
+random = urban_json_random:register

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

@@ -0,0 +1,3 @@
+urban-json
+faker>=20
+rstr>=3.2

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

@@ -0,0 +1 @@
+urban_json_random

urban_json_random-0.1.0/tests/test_random.py

@@ -0,0 +1,240 @@
+"""Fonctions getrandom_* : on vérifie formats, types et bornes (les valeurs sont
+aléatoires), sur plusieurs tirages pour rendre visibles les bornes fausses."""
+
+from __future__ import annotations
+
+import base64
+import ipaddress
+import re
+from datetime import datetime
+
+import pytest
+from urban_json import FunctionRegistry, JsltError, JsltTemplate
+
+from urban_json_random import NAUGHTY_STRINGS, register
+
+DRAWS = 200
+
+
+@pytest.fixture(scope="module")
+def registry() -> FunctionRegistry:
+    reg = FunctionRegistry()
+    register(reg)
+    return reg
+
+
+def run(registry, expression: str, source=None):
+    template = JsltTemplate.parse(f'{{ "r": {expression} }}')
+    return template.transform(source or {}, functions=registry)["r"]
+
+
+def draws(registry, expression: str, source=None, n: int = DRAWS) -> list:
+    return [run(registry, expression, source) for _ in range(n)]
+
+
+# --- nombres -----------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    ("expression", "low", "high", "kind"),
+    [
+        ("getrandom_integer(1, false, 6, false)", 1, 6, int),
+        ("getrandom_integer(1, true, 6, true)", 2, 5, int),  # bornes exclues (JSON Schema)
+        ("getrandom_long(-5, false, 5, false)", -5, 5, int),
+        ("getrandom_short(10, false, 12, false)", 10, 12, int),
+        ("getrandom_byte(250, false, 255, false)", 250, 255, int),
+        ("getrandom_double(0.5, false, 0.75, false)", 0.5, 0.75, float),
+        ("getrandom_float(-1, false, 1, false)", -1.0, 1.0, float),
+    ],
+)
+def test_nombres_dans_les_bornes(registry, expression, low, high, kind) -> None:
+    values = draws(registry, expression)
+    assert all(isinstance(v, kind) and not isinstance(v, bool) for v in values)
+    assert all(low <= v <= high for v in values)
+    if kind is int:
+        assert set(values) == set(range(low, high + 1)), "toutes les valeurs de l'intervalle doivent sortir"
+
+
+def test_double_bornes_exclues(registry) -> None:
+    values = draws(registry, "getrandom_double(0, true, 1, true)")
+    assert all(0 < v < 1 for v in values)
+
+
+@pytest.mark.parametrize(
+    ("expression", "low", "high"),
+    [
+        ("getrandom_integer()", 0, 2**31 - 1),
+        ("getrandom_long()", 0, 2**63 - 1),
+        ("getrandom_short()", 0, 2**15 - 1),
+        ("getrandom_byte()", 0, 255),
+        ("getrandom_double()", 0.0, 1.0),
+    ],
+)
+def test_bornes_par_defaut(registry, expression, low, high) -> None:
+    values = draws(registry, expression, n=50)
+    assert all(low <= v <= high for v in values)
+    assert len(set(values)) > 1, "sans bornes, le résultat ne doit pas être constant"
+
+
+@pytest.mark.parametrize(
+    "expression",
+    ["getrandom_integer(10, false, 1, false)", "getrandom_integer(3, true, 4, true)", "getrandom_byte(300)"],
+)
+def test_intervalle_impossible(registry, expression) -> None:
+    with pytest.raises(JsltError, match="getrandom"):
+        run(registry, expression)
+
+
+# --- texte ---------------------------------------------------------------------
+
+
+def test_string_longueur(registry) -> None:
+    values = draws(registry, "getrandom_string(3, 8)")
+    assert all(isinstance(v, str) and 3 <= len(v) <= 8 for v in values)
+    assert all(re.fullmatch(r"[A-Za-z0-9 ]+", v) for v in values)
+
+
+def test_string_longueur_par_defaut(registry) -> None:
+    values = draws(registry, "getrandom_string()")
+    assert all(1 <= len(v) <= 6 for v in values)  # min 1, max min + 5 (comme le .NET)
+
+
+def test_string_motif_regex(registry) -> None:
+    values = draws(registry, 'getrandom_string(0, 0, "^[A-Z]{3}-\\\\d{4}$")')
+    assert all(re.fullmatch(r"[A-Z]{3}-\d{4}", v) for v in values)
+
+
+def test_string_motif_invalide(registry) -> None:
+    with pytest.raises(JsltError, match="motif"):
+        run(registry, 'getrandom_string(1, 2, "(")')
+
+
+def test_lipsum(registry) -> None:
+    text = run(registry, "getrandom_lipsum(3)")
+    assert len([p for p in text.split("\n") if p.strip()]) == 3
+    assert len(run(registry, "getrandom_lipsum(0)").split("\n")) == 1  # 0 -> 1 paragraphe
+
+
+def test_password(registry) -> None:
+    values = draws(registry, 'getrandom_password(null, 20)', n=50)
+    assert all(len(v) == 20 for v in values)
+    assert len(set(values)) == 50
+    assert all(len(v) == 12 for v in draws(registry, "getrandom_password(null, 0)", n=10))  # 0 -> 12
+
+
+def test_naughtystrings(registry) -> None:
+    values = draws(registry, "getrandom_naughtystrings()")
+    assert all(v in NAUGHTY_STRINGS for v in values)
+    assert len(set(values)) > 5
+
+
+# --- personnes, lieux, réseau, banque --------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "name", ["getrandom_firstname", "getrandom_lastname", "getrandom_city", "getrandom_country"]
+)
+def test_textes_non_vides(registry, name) -> None:
+    values = draws(registry, f"{name}()", n=30)
+    assert all(isinstance(v, str) and v.strip() for v in values)
+    assert len(set(values)) > 3
+
+
+def test_fullname(registry) -> None:
+    assert all(len(v.split()) >= 2 for v in draws(registry, "getrandom_fullname()", n=30))
+
+
+def test_email(registry) -> None:
+    assert all(re.fullmatch(r"[^@\s]+@[^@\s]+\.[a-z]{2,}", v) for v in draws(registry, "getrandom_email()", n=30))
+
+
+def test_ip(registry) -> None:
+    for v in draws(registry, "getrandom_ipv4()", n=30):
+        assert isinstance(ipaddress.ip_address(v), ipaddress.IPv4Address)
+    for v in draws(registry, "getrandom_ipv6()", n=30):
+        assert isinstance(ipaddress.ip_address(v), ipaddress.IPv6Address)
+        assert v == v.upper()  # majuscules comme le .NET
+
+
+def test_macaddress(registry) -> None:
+    values = draws(registry, "getrandom_macaddress()")
+    assert all(re.fullmatch(r"([0-9A-F]{2}:){5}[0-9A-F]{2}", v) for v in values)
+
+
+def test_macaddress_bornes(registry) -> None:
+    values = draws(registry, 'getrandom_macaddress("00:00:00:00:00:10", "00:00:00:00:00:12")')
+    assert set(values) == {"00:00:00:00:00:10", "00:00:00:00:00:11", "00:00:00:00:00:12"}
+
+
+def _iban_valide(iban: str) -> bool:
+    raw = iban.replace(" ", "")
+    moved = raw[4:] + raw[:4]
+    digits = "".join(str(int(c, 36)) for c in moved)
+    return int(digits) % 97 == 1
+
+
+@pytest.mark.parametrize("country", ["FR", "DE", "GB", "ES", "IT", "NL", "BE"])
+def test_iban_par_pays(registry, country) -> None:
+    for v in draws(registry, f'getrandom_iban("{country}")', n=10):
+        assert v.startswith(country) and _iban_valide(v)
+
+
+def test_iban_bban_seul(registry) -> None:
+    values = draws(registry, 'getrandom_iban("FR", false, true)', n=10)
+    assert all(not v.startswith("FR") and v.isalnum() for v in values)
+
+
+def test_iban_pays_inconnu(registry) -> None:
+    with pytest.raises(JsltError, match="pays"):
+        run(registry, 'getrandom_iban("ZZ")')
+
+
+# --- dates, durées, binaire, booléen, liste -----------------------------------------
+
+
+def test_datatime(registry) -> None:
+    for v in draws(registry, "getrandom_datatime()", n=50):
+        moment = datetime.fromisoformat(v)
+        assert 1970 <= moment.year <= 2050
+
+
+def test_timespan(registry) -> None:
+    assert all(re.fullmatch(r"\d{2}:\d{2}:\d{2}\.\d{3}", v) for v in draws(registry, "getrandom_timespan()"))
+
+
+def test_binary(registry) -> None:
+    for v in draws(registry, "getrandom_binary(2, 4)"):
+        assert 2 <= len(base64.b64decode(v)) <= 4
+
+
+def test_boolean(registry) -> None:
+    assert set(draws(registry, "getrandom_boolean()")) == {True, False}
+
+
+def test_in_list(registry) -> None:
+    values = draws(registry, "getrandom_in_list($.l)", {"l": ["a", 1, {"k": 2}]})
+    assert all(v in ["a", 1, {"k": 2}] for v in values)
+    assert len({repr(v) for v in values}) == 3
+
+
+@pytest.mark.parametrize("source", [{"l": []}, {"l": None}, {"l": "abc"}])
+def test_in_list_vide_ou_invalide(registry, source) -> None:
+    assert run(registry, "getrandom_in_list($.l)", source) is None
+
+
+# --- intégration ------------------------------------------------------------------
+
+
+def test_toutes_les_fonctions_sont_documentees(registry) -> None:
+    catalog = registry.catalog()
+    assert len(catalog) == 25
+    for entry in catalog:
+        assert entry["name"].startswith("getrandom_")
+        assert len((entry["description"] or "").strip()) >= 15, entry["name"]
+
+
+def test_decouverte_par_entry_point() -> None:
+    from urban_json import default_registry, load_plugins
+
+    load_plugins()
+    assert "getrandom_email" in default_registry