urban-json-excel 0.1.0__tar.gz

urban_json_excel-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_excel-0.1.0/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: urban-json-excel
+Version: 0.1.0
+Summary: Plugin urban-json : lecture de classeurs Excel (loadxls, loadxlssheet).
+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,excel,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
+Requires-Dist: openpyxl>=3.1
+Provides-Extra: xls
+Requires-Dist: xlrd>=2.0; extra == "xls"
+Dynamic: license-file
+
+# urban-json-excel
+
+Plugin [urban-json](https://github.com/gaelgael5/Jslt) : **classeurs Excel** dans les
+templates (port de `ServicesXls` / `ExcelReader`, .NET).
+
+```bash
+pip install urban-json-excel          # .xlsx (openpyxl)
+pip install "urban-json-excel[xls]"   # + anciens .xls (xlrd)
+```
+
+- `loadxls(classeur, "config.json")` — configuration lue dans un fichier JSON ;
+- `loadxlssheet(classeur, { … })` — configuration passée en objet.
+
+```json
+{ "FirstRowHasColumnName": true, "HeaderLine": 0, "Tablename": "Feuil1",
+  "AddRowNumber": true, "ByPassEmptyObject": true,
+  "Columns": [ { "Index": 0, "Name": "id", "Type": "integer", "Trimmed": true, "BypassEmptyValue": true } ] }
+```
+
+Chaque ligne devient un objet (`"$row"` = rang de la ligne de données si
+`AddRowNumber`). Sans `Columns`, toutes les colonnes sont lues, noms assainis
+(`"Nom complet"` → `Nom_complet`) et colonnes entièrement entières typées `integer`.
+Si `Tablename` est vide, la feuille unique du classeur est prise.

urban_json_excel-0.1.0/README.md

@@ -0,0 +1,23 @@
+# urban-json-excel
+
+Plugin [urban-json](https://github.com/gaelgael5/Jslt) : **classeurs Excel** dans les
+templates (port de `ServicesXls` / `ExcelReader`, .NET).
+
+```bash
+pip install urban-json-excel          # .xlsx (openpyxl)
+pip install "urban-json-excel[xls]"   # + anciens .xls (xlrd)
+```
+
+- `loadxls(classeur, "config.json")` — configuration lue dans un fichier JSON ;
+- `loadxlssheet(classeur, { … })` — configuration passée en objet.
+
+```json
+{ "FirstRowHasColumnName": true, "HeaderLine": 0, "Tablename": "Feuil1",
+  "AddRowNumber": true, "ByPassEmptyObject": true,
+  "Columns": [ { "Index": 0, "Name": "id", "Type": "integer", "Trimmed": true, "BypassEmptyValue": true } ] }
+```
+
+Chaque ligne devient un objet (`"$row"` = rang de la ligne de données si
+`AddRowNumber`). Sans `Columns`, toutes les colonnes sont lues, noms assainis
+(`"Nom complet"` → `Nom_complet`) et colonnes entièrement entières typées `integer`.
+Si `Tablename` est vide, la feuille unique du classeur est prise.

urban_json_excel-0.1.0/pyproject.toml

@@ -0,0 +1,62 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "urban-json-excel"
+dynamic = ["version"]
+description = "Plugin urban-json : lecture de classeurs Excel (loadxls, loadxlssheet)."
+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", "excel", "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 = [
+    "urban-json",
+    # Classeurs .xlsx (ExcelDataReader côté .NET).
+    "openpyxl>=3.1",
+]
+
+[project.optional-dependencies]
+# Anciens classeurs .xls (format binaire Excel 97-2003).
+xls = ["xlrd>=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"]
+excel = "urban_json_excel:register"
+
+[tool.setuptools.dynamic]
+version = { attr = "urban_json_excel.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+urban_json_excel = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[tool.ruff]
+line-length = 100
+src = ["src", "tests"]

urban_json_excel-0.1.0/setup.cfg

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

urban_json_excel-0.1.0/src/urban_json_excel/__init__.py

@@ -0,0 +1,299 @@
+"""Plugin urban-json : lecture de classeurs Excel (``loadxls``, ``loadxlssheet``).
+
+Port de ``ServicesXls`` + ``ExcelReader`` (.NET, ExcelDataReader). ``.xlsx`` via
+openpyxl ; ``.xls`` (Excel 97-2003) via xlrd, avec l'extra ``urban-json-excel[xls]``.
+
+* ``loadxls(fichier, fichier_de_configuration)`` — configuration lue dans un
+  fichier JSON ;
+* ``loadxlssheet(fichier, configuration)`` — configuration passée en objet.
+
+Configuration (clés insensibles à la casse, comme la désérialisation .NET) ::
+
+    { "FirstRowHasColumnName": true,  // 1re ligne = noms de colonnes
+      "HeaderLine": 0,                // > 0 : ligne d'en-tête (données après elle)
+      "Tablename": "Feuil1",          // feuille ; vide = l'unique feuille
+      "AddRowNumber": true,           // ajoute "$row" (rang de la ligne de données)
+      "ByPassEmptyObject": true,      // omet les lignes sans aucune valeur
+      "Columns": [ { "Index": 0, "Name": "id", "Type": "integer",
+                     "Trimmed": true, "BypassEmptyValue": true } ] }
+
+Sans ``Columns`` : toutes les colonnes, noms assainis (accents retirés, espaces ->
+``_``, doublons suffixés ``_renamed_<index>``), colonne numérique entièrement
+entière typée ``integer``. Avec ``Columns`` : seules ces colonnes, typées.
+
+Écarts volontaires vs .NET : feuille unique prise quand ``Tablename`` est vide (le
+.NET échouait toujours, son test « table manquante » précédant ce cas) ; dates en
+ISO 8601 ; erreurs explicites (``JsltError``). Chemins relatifs au répertoire
+courant (pas de ``ResolveFile``).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import unicodedata
+from dataclasses import dataclass
+from datetime import date, datetime, time
+from typing import Any
+
+from urban_json import JsltError
+
+__version__ = "0.1.0"
+
+__all__ = ["execute_loadxls", "execute_loadxlssheet", "register"]
+
+
+# --- configuration ------------------------------------------------------------------
+
+
+def _get(config: dict, key: str, default: Any = None) -> Any:
+    lowered = key.lower()
+    for name, value in config.items():
+        if str(name).lower() == lowered:
+            return value
+    return default
+
+
+@dataclass
+class _Column:
+    index: int
+    name: str
+    type: str = "string"
+    trimmed: bool = True
+    bypass_empty: bool = True
+
+
+_TYPE_ALIASES = {
+    "string": "string", "system.string": "string", "text": "string",
+    "integer": "integer", "int": "integer", "long": "integer", "int32": "integer", "int64": "integer",
+    "system.int32": "integer", "system.int64": "integer",
+    "decimal": "number", "double": "number", "float": "number", "number": "number",
+    "system.double": "number", "system.decimal": "number", "system.single": "number",
+    "boolean": "boolean", "bool": "boolean", "system.boolean": "boolean",
+    "datetime": "datetime", "date": "datetime", "system.datetime": "datetime",
+    "auto": "auto",
+}
+
+
+def _columns_from_config(config: dict) -> list[_Column] | None:
+    raw = _get(config, "Columns")
+    if not raw:
+        return None
+    columns = []
+    for item in raw:
+        if not isinstance(item, dict) or _get(item, "Index") is None or not _get(item, "Name"):
+            raise JsltError(f"loadxls : colonne de configuration invalide {item!r} (Index et Name requis)")
+        type_name = str(_get(item, "Type", "string")).strip().lower()
+        if type_name not in _TYPE_ALIASES:
+            raise JsltError(f"loadxls : type de colonne inconnu {type_name!r}")
+        columns.append(_Column(
+            index=int(_get(item, "Index")),
+            name=str(_get(item, "Name")),
+            type=_TYPE_ALIASES[type_name],
+            trimmed=bool(_get(item, "Trimmed", True)),
+            bypass_empty=bool(_get(item, "BypassEmptyValue", True)),
+        ))
+    return columns
+
+
+# --- lecture du classeur ---------------------------------------------------------------
+
+
+def _read_sheets(path: str) -> dict[str, list[tuple]]:
+    if path.lower().endswith(".xls"):
+        try:
+            import xlrd
+        except ImportError as exc:
+            raise JsltError("loadxls : les fichiers .xls exigent l'extra urban-json-excel[xls] (xlrd)") from exc
+        book = xlrd.open_workbook(path)
+        sheets = {}
+        for sheet in book.sheets():
+            rows = []
+            for r in range(sheet.nrows):
+                row = []
+                for c in range(sheet.ncols):
+                    cell = sheet.cell(r, c)
+                    if cell.ctype == xlrd.XL_CELL_DATE:
+                        row.append(xlrd.xldate.xldate_as_datetime(cell.value, book.datemode))
+                    elif cell.ctype in (xlrd.XL_CELL_EMPTY, xlrd.XL_CELL_BLANK):
+                        row.append(None)
+                    elif cell.ctype == xlrd.XL_CELL_BOOLEAN:
+                        row.append(bool(cell.value))
+                    else:
+                        row.append(cell.value)
+                rows.append(tuple(row))
+            sheets[sheet.name] = rows
+        return sheets
+    import openpyxl
+
+    workbook = openpyxl.load_workbook(path, read_only=True, data_only=True)
+    try:
+        return {ws.title: [tuple(row) for row in ws.iter_rows(values_only=True)] for ws in workbook.worksheets}
+    finally:
+        workbook.close()
+
+
+def _label(name: str) -> str:
+    """Assainit un nom de colonne (``ExcelReader.GetLabel``, comme ``loadcsv``)."""
+    decomposed = unicodedata.normalize("NFKD", name)
+    out = []
+    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
+
+
+def _is_integral(value: Any) -> bool:
+    if isinstance(value, bool):
+        return False
+    if isinstance(value, int):
+        return True
+    return isinstance(value, float) and value.is_integer()
+
+
+def _auto_columns(header: list[Any], data: list[tuple], header_line: int) -> list[_Column]:
+    columns: list[_Column] = []
+    width = max([len(header)] + [len(r) for r in data]) if (header or data) else 0
+    if header_line > 0:
+        names = data[header_line] if header_line < len(data) else ()
+        for index in range(width):
+            name = names[index] if index < len(names) else None
+            if isinstance(name, str):
+                text = name.strip(" \t\r\n")
+                label = _label(text) if text else f"renamed_{len(columns)}"
+            elif name is not None:
+                label = f"renamed_{len(columns)}"
+            else:
+                continue  # colonne sans en-tête : ignorée, comme le .NET
+            columns.append(_Column(index, label, "auto"))
+        return columns
+    seen: set[str] = set()
+    for index in range(width):
+        raw = header[index] if index < len(header) and header[index] not in (None, "") else f"Column{index}"
+        name = _label(str(raw)) or f"Column{index}"
+        if name in seen:
+            name += f"_renamed_{index}"
+        seen.add(name)
+        values = [r[index] for r in data if index < len(r) and r[index] is not None]
+        kind = "integer" if values and all(_is_integral(v) for v in values) else "auto"
+        columns.append(_Column(index, name, kind))
+    return columns
+
+
+def _iso(value: Any) -> Any:
+    if isinstance(value, (datetime, date, time)):
+        return value.isoformat()
+    return value
+
+
+def _convert(value: Any, column: _Column) -> Any:
+    """Valeur typée d'une cellule, ou ``_SKIP`` pour l'omettre."""
+    if value is None:
+        return _SKIP
+    # Colonne automatique contenant du texte : traitée comme une colonne texte (le
+    # .NET lui attribue le type string, donc nettoyage et valeurs vides omises).
+    if column.type == "string" or (column.type == "auto" and isinstance(value, str)):
+        text = value if isinstance(value, str) else str(_iso(value))
+        if column.trimmed:
+            text = text.strip()
+        return _SKIP if column.bypass_empty and text == "" else text
+    if isinstance(value, str) and value.strip() == "":
+        return _SKIP
+    try:
+        if column.type == "integer":
+            return int(float(value)) if not isinstance(value, bool) else int(value)
+        if column.type == "number":
+            return float(value)
+        if column.type == "boolean":
+            return value if isinstance(value, bool) else str(value).strip().lower() in ("true", "1", "vrai", "yes")
+    except (TypeError, ValueError):
+        return _iso(value)  # conversion impossible : valeur d'origine, comme le .NET
+    if column.type == "datetime" and isinstance(value, str):
+        return value
+    return _iso(value)
+
+
+_SKIP = object()
+
+
+def _read(path: str, config: dict) -> list[dict]:
+    if not os.path.isfile(path):
+        raise JsltError(f"loadxls : classeur introuvable {path!r}")
+    sheets = _read_sheets(path)
+    table = _get(config, "Tablename") or ""
+    if table:
+        if table not in sheets:
+            raise JsltError(f"loadxls : feuille {table!r} introuvable (feuilles : {', '.join(sheets)})")
+    elif len(sheets) == 1:
+        table = next(iter(sheets))
+    else:
+        raise JsltError("loadxls : Tablename non précisé alors que le classeur a plusieurs feuilles")
+
+    rows = sheets[table]
+    first_row_names = bool(_get(config, "FirstRowHasColumnName", False))
+    header = list(rows[0]) if first_row_names and rows else []
+    data = rows[1:] if first_row_names else rows
+    header_line = int(_get(config, "HeaderLine", 0) or 0)
+    add_row_number = bool(_get(config, "AddRowNumber", True))
+    bypass_empty_object = bool(_get(config, "ByPassEmptyObject", True))
+    columns = _columns_from_config(config) or _auto_columns(header, data, header_line)
+
+    result = []
+    for row_line, row in enumerate(data):
+        if header_line and row_line <= header_line:
+            continue
+        obj: dict[str, Any] = {}
+        for column in columns:
+            value = row[column.index] if column.index < len(row) else None
+            converted = _convert(value, column)
+            if converted is not _SKIP:
+                obj[column.name] = converted
+        if obj or not bypass_empty_object:
+            if add_row_number:
+                obj["$row"] = row_line
+            result.append(obj)
+    return result
+
+
+def execute_loadxlssheet(ctx: Any, source_path: Any = None, config: Any = None) -> list:
+    if not source_path:
+        raise JsltError("loadxlssheet : le chemin du classeur est requis")
+    if config is None:
+        config = {}
+    if not isinstance(config, dict):
+        raise JsltError("loadxlssheet : la configuration doit être un objet JSON")
+    return _read(str(source_path), config)
+
+
+def execute_loadxls(ctx: Any, source_path: Any = None, config_path: Any = None) -> list:
+    if not source_path:
+        raise JsltError("loadxls : le chemin du classeur est requis")
+    if not config_path or not os.path.isfile(str(config_path)):
+        raise JsltError(f"loadxls : fichier de configuration introuvable {config_path!r}")
+    try:
+        with open(str(config_path), encoding="utf-8-sig") as handle:
+            config = json.load(handle)
+    except json.JSONDecodeError as exc:
+        raise JsltError(f"loadxls : fichier de configuration JSON invalide ({exc})") from exc
+    if not isinstance(config, dict):
+        raise JsltError("loadxls : la configuration doit être un objet JSON")
+    return _read(str(source_path), config)
+
+
+def register(registry: Any) -> None:
+    """Enregistre ``loadxls`` et ``loadxlssheet``."""
+    registry.register(
+        "loadxls", execute_loadxls,
+        description="Lit une feuille Excel en tableau d'objets, selon un fichier de configuration JSON",
+    )
+    registry.register(
+        "loadxlssheet", execute_loadxlssheet,
+        description="Lit une feuille Excel en tableau d'objets, selon un objet de configuration",
+    )

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

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: urban-json-excel
+Version: 0.1.0
+Summary: Plugin urban-json : lecture de classeurs Excel (loadxls, loadxlssheet).
+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,excel,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
+Requires-Dist: openpyxl>=3.1
+Provides-Extra: xls
+Requires-Dist: xlrd>=2.0; extra == "xls"
+Dynamic: license-file
+
+# urban-json-excel
+
+Plugin [urban-json](https://github.com/gaelgael5/Jslt) : **classeurs Excel** dans les
+templates (port de `ServicesXls` / `ExcelReader`, .NET).
+
+```bash
+pip install urban-json-excel          # .xlsx (openpyxl)
+pip install "urban-json-excel[xls]"   # + anciens .xls (xlrd)
+```
+
+- `loadxls(classeur, "config.json")` — configuration lue dans un fichier JSON ;
+- `loadxlssheet(classeur, { … })` — configuration passée en objet.
+
+```json
+{ "FirstRowHasColumnName": true, "HeaderLine": 0, "Tablename": "Feuil1",
+  "AddRowNumber": true, "ByPassEmptyObject": true,
+  "Columns": [ { "Index": 0, "Name": "id", "Type": "integer", "Trimmed": true, "BypassEmptyValue": true } ] }
+```
+
+Chaque ligne devient un objet (`"$row"` = rang de la ligne de données si
+`AddRowNumber`). Sans `Columns`, toutes les colonnes sont lues, noms assainis
+(`"Nom complet"` → `Nom_complet`) et colonnes entièrement entières typées `integer`.
+Si `Tablename` est vide, la feuille unique du classeur est prise.

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

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

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[urban_json.functions]
+excel = urban_json_excel:register

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

@@ -0,0 +1,5 @@
+urban-json
+openpyxl>=3.1
+
+[xls]
+xlrd>=2.0

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

@@ -0,0 +1 @@
+urban_json_excel

urban_json_excel-0.1.0/tests/test_excel.py

@@ -0,0 +1,197 @@
+"""loadxls / loadxlssheet — port de ServicesXls + ExcelReader (.NET)."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from pathlib import Path
+
+import openpyxl
+import pytest
+from urban_json import FunctionRegistry, JsltError, JsltTemplate
+
+from urban_json_excel import register
+
+
+@pytest.fixture(scope="module")
+def registry() -> FunctionRegistry:
+    reg = FunctionRegistry()
+    register(reg)
+    return reg
+
+
+def _book(tmp_path: Path, sheets: dict[str, list[list]]) -> str:
+    workbook = openpyxl.Workbook()
+    workbook.remove(workbook.active)
+    for name, rows in sheets.items():
+        sheet = workbook.create_sheet(name)
+        for row in rows:
+            sheet.append(row)
+    path = tmp_path / "book.xlsx"
+    workbook.save(path)
+    return str(path)
+
+
+def sheet(registry, path: str, config: dict):
+    template = JsltTemplate.parse('{ "r": loadxlssheet($.p, $.c) }')
+    return template.transform({"p": path, "c": config}, functions=registry)["r"]
+
+
+# Excel ne stocke pas de fuseau : date « naïve » volontaire.
+PEOPLE = [["Nom complet", "Âge", "Inscrit le"], ["  Ana ", 30, datetime(2026, 1, 2)], ["Bob", 41, None]]  # noqa: DTZ001
+
+
+def test_en_tete_premiere_ligne(registry, tmp_path) -> None:
+    path = _book(tmp_path, {"Gens": PEOPLE})
+    out = sheet(registry, path, {"FirstRowHasColumnName": True})
+    assert out == [
+        {"Nom_complet": "Ana", "Age": 30, "Inscrit_le": "2026-01-02T00:00:00", "$row": 0},
+        {"Nom_complet": "Bob", "Age": 41, "$row": 1},
+    ]
+
+
+def test_sans_en_tete_noms_column_n(registry, tmp_path) -> None:
+    path = _book(tmp_path, {"S": [["a", 1], ["b", 2]]})
+    out = sheet(registry, path, {"AddRowNumber": False})
+    assert out == [{"Column0": "a", "Column1": 1}, {"Column0": "b", "Column1": 2}]
+
+
+def test_colonne_decimale_reste_decimale(registry, tmp_path) -> None:
+    path = _book(tmp_path, {"S": [["v"], [1.5], [2]]})
+    assert [r["v"] for r in sheet(registry, path, {"FirstRowHasColumnName": True})] == [1.5, 2.0]
+
+
+def test_header_line(registry, tmp_path) -> None:
+    rows = [["titre du rapport"], [None], ["Code", "Libellé"], ["A1", "Un"], ["B2", "Deux"]]
+    path = _book(tmp_path, {"S": rows})
+    out = sheet(registry, path, {"HeaderLine": 2, "AddRowNumber": False})
+    assert out == [{"Code": "A1", "Libelle": "Un"}, {"Code": "B2", "Libelle": "Deux"}]
+
+
+def test_colonnes_explicites_types_et_filtre(registry, tmp_path) -> None:
+    path = _book(tmp_path, {"S": [["id", "montant", "note"], ["7", "12.5", " x "], ["8", "3", ""]]})
+    config = {
+        "FirstRowHasColumnName": True, "AddRowNumber": False,
+        "Columns": [
+            {"Index": 0, "Name": "id", "Type": "integer"},
+            {"Index": 1, "Name": "montant", "Type": "decimal"},
+            {"Index": 2, "Name": "note", "Trimmed": False},
+        ],
+    }
+    assert sheet(registry, path, config) == [
+        {"id": 7, "montant": 12.5, "note": " x "},
+        {"id": 8, "montant": 3.0},  # valeur vide omise (BypassEmptyValue par défaut)
+    ]
+
+
+def test_lignes_vides_omises_ou_gardees(registry, tmp_path) -> None:
+    path = _book(tmp_path, {"S": [["a"], ["x"], [None], ["y"]]})
+    kept = sheet(registry, path, {"FirstRowHasColumnName": True, "ByPassEmptyObject": False})
+    assert kept == [{"a": "x", "$row": 0}, {"$row": 1}, {"a": "y", "$row": 2}]
+    skipped = sheet(registry, path, {"FirstRowHasColumnName": True})
+    assert [r["$row"] for r in skipped] == [0, 2]
+
+
+def test_noms_de_colonnes_en_double(registry, tmp_path) -> None:
+    path = _book(tmp_path, {"S": [["a", "a"], [1, 2]]})
+    assert sheet(registry, path, {"FirstRowHasColumnName": True, "AddRowNumber": False}) == [{"a": 1, "a_renamed_1": 2}]
+
+
+def test_choix_de_la_feuille(registry, tmp_path) -> None:
+    path = _book(tmp_path, {"Un": [["v"], [1]], "Deux": [["v"], [2]]})
+    assert sheet(registry, path, {"Tablename": "Deux", "FirstRowHasColumnName": True})[0]["v"] == 2
+    with pytest.raises(JsltError, match="plusieurs feuilles"):
+        sheet(registry, path, {"FirstRowHasColumnName": True})
+    with pytest.raises(JsltError, match="feuille"):
+        sheet(registry, path, {"Tablename": "Trois"})
+
+
+def test_feuille_unique_sans_nom(registry, tmp_path) -> None:
+    # Le .NET échouait toujours ici (bug) : la feuille unique est prise.
+    path = _book(tmp_path, {"Seule": [["v"], [1]]})
+    assert sheet(registry, path, {"FirstRowHasColumnName": True})[0]["v"] == 1
+
+
+def test_cles_de_configuration_insensibles_a_la_casse(registry, tmp_path) -> None:
+    path = _book(tmp_path, {"S": [["v"], [1]]})
+    assert sheet(registry, path, {"firstRowHasColumnName": True, "addrownumber": False}) == [{"v": 1}]
+
+
+def test_loadxls_avec_fichier_de_configuration(registry, tmp_path) -> None:
+    path = _book(tmp_path, {"S": [["v"], [1]]})
+    config = tmp_path / "conf.json"
+    config.write_text(json.dumps({"FirstRowHasColumnName": True, "AddRowNumber": False}), encoding="utf-8")
+    template = JsltTemplate.parse('{ "r": loadxls($.p, $.c) }')
+    assert template.transform({"p": path, "c": str(config)}, functions=registry)["r"] == [{"v": 1}]
+
+
+@pytest.mark.parametrize(
+    ("expression", "message"),
+    [
+        ('loadxls($.p, "/absent/conf.json")', "configuration"),
+        ('loadxlssheet("/absent/book.xlsx", {})', "introuvable"),
+        ("loadxlssheet($.p, 3)", "configuration"),
+    ],
+)
+def test_erreurs(registry, tmp_path, expression, message) -> None:
+    path = _book(tmp_path, {"S": [["v"], [1]]})
+    template = JsltTemplate.parse(f'{{ "r": {expression} }}')
+    with pytest.raises(JsltError, match=message):
+        template.transform({"p": path}, functions=registry)
+
+
+def test_catalogue_et_decouverte(registry) -> None:
+    from urban_json import default_registry, load_plugins
+
+    assert {e["name"] for e in registry.catalog()} == {"loadxls", "loadxlssheet"}
+    assert all(len(e["description"]) >= 15 for e in registry.catalog())
+    load_plugins()
+    assert "loadxlssheet" in default_registry
+
+
+# --- .xls (Excel 97-2003, BIFF8) ------------------------------------------------------
+
+# tests/data/sample.xls : vrai classeur BIFF8 produit avec xlwt, même contenu que XLS_ROWS.
+XLS_SAMPLE = str(Path(__file__).parent / "data" / "sample.xls")
+XLS_ROWS = [
+    ["Nom", "Age", "Taille", "Actif", "Naissance", "Note"],
+    ["  Alice ", 30, 1.68, True, datetime(1994, 5, 17), "ok"],  # noqa: DTZ001
+    [None, None, None, None, None, None],
+    ["Bob", 42, 1.8, False, datetime(1982, 1, 2), None],  # noqa: DTZ001
+]
+
+
+@pytest.mark.parametrize(
+    "config",
+    [
+        pytest.param({"FirstRowHasColumnName": True}, id="colonnes-auto"),
+        pytest.param({"FirstRowHasColumnName": True, "ByPassEmptyObject": False}, id="ligne-vide-gardee"),
+        pytest.param(
+            {
+                "FirstRowHasColumnName": True,
+                "Columns": [
+                    {"Index": 0, "Name": "nom", "Type": "string"},
+                    {"Index": 1, "Name": "age", "Type": "integer"},
+                    {"Index": 2, "Name": "taille", "Type": "decimal"},
+                    {"Index": 3, "Name": "actif", "Type": "boolean"},
+                    {"Index": 4, "Name": "naissance", "Type": "datetime"},
+                ],
+            },
+            id="colonnes-typees",
+        ),
+    ],
+)
+def test_xls_identique_au_xlsx(registry, tmp_path, config) -> None:
+    pytest.importorskip("xlrd")
+    expected = sheet(registry, _book(tmp_path, {"Feuil1": XLS_ROWS}), config)
+    assert sheet(registry, XLS_SAMPLE, config) == expected
+
+
+def test_xls_valeurs(registry) -> None:
+    pytest.importorskip("xlrd")
+    out = sheet(registry, XLS_SAMPLE, {"FirstRowHasColumnName": True})
+    assert out == [
+        {"Nom": "Alice", "Age": 30, "Taille": 1.68, "Actif": True, "Naissance": "1994-05-17T00:00:00",
+         "Note": "ok", "$row": 0},
+        {"Nom": "Bob", "Age": 42, "Taille": 1.8, "Actif": False, "Naissance": "1982-01-02T00:00:00", "$row": 2},
+    ]