websemantic 0.2.5__tar.gz

websemantic-0.2.5/LICENSE

@@ -0,0 +1,135 @@
+# PolyForm Noncommercial License 1.0.0
+
+<https://polyformproject.org/licenses/noncommercial/1.0.0>
+
+## Acceptance
+
+In order to get any license under these terms, you must agree
+to them as both strict obligations and conditions to all
+your licenses.
+
+## Copyright License
+
+The licensor grants you a copyright license for the
+software to do everything you might do with the software
+that would otherwise infringe the licensor's copyright
+in it for any permitted purpose.  However, you may
+only distribute the software according to [Distribution
+License](#distribution-license) and make changes or new works
+based on the software according to [Changes and New Works
+License](#changes-and-new-works-license).
+
+## Distribution License
+
+The licensor grants you an additional copyright license
+to distribute copies of the software.  Your license
+to distribute covers distributing the software with
+changes and new works permitted by [Changes and New Works
+License](#changes-and-new-works-license).
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of
+the software from you also gets a copy of these terms or the
+URL for them above, as well as copies of any plain-text lines
+beginning with `Required Notice:` that the licensor provided
+with the software.  For example:
+
+> Required Notice: Copyright Yoyodyne, Inc. (http://example.com)
+
+## Changes and New Works License
+
+The licensor grants you an additional copyright license to
+make changes and new works based on the software for any
+permitted purpose.
+
+## Patent License
+
+The licensor grants you a patent license for the software that
+covers patent claims the licensor can license, or becomes able
+to license, that you would infringe by using the software.
+
+## Noncommercial Purposes
+
+Any noncommercial purpose is a permitted purpose.
+
+## Personal Uses
+
+Personal use for research, experiment, and testing for
+the benefit of public knowledge, personal study, private
+entertainment, hobby projects, amateur pursuits, or religious
+observance, without any anticipated commercial application,
+is use for a permitted purpose.
+
+## Noncommercial Organizations
+
+Use by any charitable organization, educational institution,
+public research organization, public safety or health
+organization, environmental protection organization,
+or government institution is use for a permitted purpose
+regardless of the source of funding or obligations resulting
+from the funding.
+
+## Fair Use
+
+You may have "fair use" rights for the software under the
+law. These terms do not limit them.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of
+your licenses to anyone else, or prevent the licensor from
+granting licenses to anyone else.  These terms do not imply
+any other licenses.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or
+contributes to infringement of any patent, your patent license
+for the software granted under these terms ends immediately. If
+your company makes such a claim, your patent license ends
+immediately for work on behalf of your company.
+
+## Violations
+
+The first time you are notified in writing that you have
+violated any of these terms, or done anything with the software
+not covered by your licenses, your licenses can nonetheless
+continue if you come into full compliance with these terms,
+and take practical steps to correct past violations, within
+32 days of receiving notice.  Otherwise, all your licenses
+end immediately.
+
+## No Liability
+
+***As far as the law allows, the software comes as is, without
+any warranty or condition, and the licensor will not be liable
+to you for any damages arising out of these terms or the use
+or nature of the software, under any kind of legal claim.***
+
+## Definitions
+
+The **licensor** is the individual or entity offering these
+terms, and the **software** is the software the licensor makes
+available under these terms.
+
+**You** refers to the individual or entity agreeing to these
+terms.
+
+**Your company** is any legal entity, sole proprietorship,
+or other kind of organization that you work for, plus all
+organizations that have control over, are under the control of,
+or are under common control with that organization.  **Control**
+means ownership of substantially all the assets of an entity,
+or the power to direct its management and policies by vote,
+contract, or otherwise.  Control can be direct or indirect.
+
+**Your licenses** are all the licenses granted to you for the
+software under these terms.
+
+**Use** means anything you do with the software requiring one
+of your licenses.
+
+
+Required Notice: Copyright (c) 2026 Cyril Voyant.
+Required Notice: WebSemantic_TLS — https://github.com/cyrilvoyant/websemantic

websemantic-0.2.5/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: websemantic
+Version: 0.2.5
+Summary: Software-agnostic semantic layer from intent to qualified simulated data (research prototype)
+Author: Cyril Voyant
+License-Expression: PolyForm-Noncommercial-1.0.0
+Project-URL: Homepage, https://www.cyrilvoyant.com
+Project-URL: Repository, https://github.com/cyrilvoyant/websemantic
+Project-URL: Documentation, https://github.com/cyrilvoyant/websemantic#readme
+Project-URL: Ontology, https://w3id.org/websemantic/ns
+Project-URL: DOI, https://doi.org/10.5281/zenodo.23238902
+Keywords: semantic web,scientific software,large language models,ontology,SHACL,provenance,FAIR
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.6
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rdflib>=7.0
+Requires-Dist: pyshacl>=0.26
+Requires-Dist: packaging>=24
+Provides-Extra: tls
+Requires-Dist: numpy>=1.24; extra == "tls"
+Requires-Dist: pandas>=2.0; extra == "tls"
+Provides-Extra: backends
+Requires-Dist: numpy>=1.24; extra == "backends"
+Requires-Dist: pandas>=2.0; extra == "backends"
+Provides-Extra: atmosphere
+Requires-Dist: numpy; extra == "atmosphere"
+Requires-Dist: scipy; extra == "atmosphere"
+Requires-Dist: pandas; extra == "atmosphere"
+Requires-Dist: polars; extra == "atmosphere"
+Requires-Dist: xarray; extra == "atmosphere"
+Requires-Dist: netcdf4; extra == "atmosphere"
+Requires-Dist: setuptools; extra == "atmosphere"
+Requires-Dist: jax==0.11.2; extra == "atmosphere"
+Requires-Dist: diffrax==0.7.2; extra == "atmosphere"
+Requires-Dist: equinox==0.13.8; extra == "atmosphere"
+Requires-Dist: optimistix==0.1.0; extra == "atmosphere"
+Provides-Extra: llm
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: jsonschema>=4.18; extra == "dev"
+Dynamic: license-file
+
+# WebSemantic
+
+Software-agnostic semantic layer for scientific codes (research prototype). One descriptor per code is compiled into
+three documents: a readable contract for language models, an ontology with SHACL rules, and FAIR metadata. A
+deterministic validator checks the scenario a model proposes (values, units, origins, acceptances) before the
+unchanged code runs, and the outputs are stored with quantity, unit, origin, provenance and validity limits.
+
+This package provides the Python layer: validation gate, adapters, semantic tools and command-line entry point. The
+descriptors, ontology, contracts and the pinned scientific codes (TLS, LQL-Equiv, pyrcel) live in the repository;
+full use requires a clone with its submodules.
+
+- Repository and documentation: https://github.com/cyrilvoyant/websemantic
+- Ontology (persistent namespace): https://w3id.org/websemantic/ns
+- Concept DOI (all versions): https://doi.org/10.5281/zenodo.23238902
+- Licence: PolyForm Noncommercial 1.0.0

websemantic-0.2.5/README.md

@@ -0,0 +1,65 @@
+# WebSemantic
+
+Préparer une simulation en phrases, examiner les hypothèses et obtenir des résultats avec leurs unités et leur provenance. Trois profils : TLS, LQL-Equiv (un cursus fictif) et pyrcel (un mode d’aérosol, ascendance constante).
+
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.23238902.svg)](https://doi.org/10.5281/zenodo.23238902) · ontologie : [w3id.org/websemantic/ns](https://w3id.org/websemantic/ns) · [Contribuer](CONTRIBUTING.md) · [Sécurité](SECURITY.md)
+
+## Avec un agent Python
+
+Lisez [les règles de réutilisation](llm.md), puis [le point d’entrée Python](agent/README.md). Il indique les fichiers, leurs empreintes et la commande commune aux trois modèles : `python agent/run.py tls|lql|pyrcel scenario.json` (choisir un modèle). Ce parcours utilise les fichiers sources, sans Git ni clé Gemini.
+
+## Utiliser
+
+Dans le package Windows, ouvrez `Installer.cmd` une fois, puis `WebSemantic.cmd` et choisissez 1 (TLS), 2 (LQL) ou 3 (pyrcel).
+
+> Étudie un tunnel fictif de 2 km, deux tubes et deux voies par tube, avec éclairage LED fixe et ventilation longitudinale. Propose les paramètres manquants.
+
+Demandez le tableau des paramètres ou les formules, précisez les choix, puis acceptez les hypothèses. Le calcul démarre lorsque la configuration est complète et validée. Une modification explicite recalcule l’étude. Le dossier des résultats est affiché à chaque calcul.
+
+Le [guide](packaging/windows/Guide.txt) propose quatre essais, dont une comparaison de deux tunnels et une exécution par un agent Python.
+
+## Installer depuis GitHub
+
+Python 3.12+ et Git sont nécessaires pour installer les trois profils depuis GitHub. Configurez `GEMINI_API_KEY` pour le dialogue.
+
+```powershell
+git clone --recurse-submodules https://github.com/cyrilvoyant/websemantic.git
+cd websemantic
+python -m venv .venv
+& .\.venv\Scripts\python.exe -m pip install -e ".[tls,atmosphere]"
+& .\.venv\Scripts\python.exe -m websemantic.cli chat
+```
+
+[Installation](docs/installation-windows.md) · [Dialogue et raccourcis](docs/terminal.md)
+
+## Autres profils
+
+LQL : « Étudie un schéma fictif rectum/prostate : 20 fractions de 3 Gy, référence 2 Gy. Propose les hypothèses manquantes. »
+
+pyrcel : « Simule une parcelle à 1 m/s, 283 K, 850 hPa et S0 = -0,02 ; un mode lognormal de 1000 particules/cm³, rayon sec médian 0,05 µm, sigma 2, kappa 0,54. Propose les réglages manquants. »
+
+Examinez les paramètres et leurs unités, puis acceptez les hypothèses. LQL sert à la recherche sur des schémas fictifs ; pyrcel simule une parcelle idéale.
+
+## Résultats
+
+TLS produit des données simulées. L’énergie totale couvre la période calculée ; l’énergie annualisée extrapole par `365/n_days`. Puissance : kW ; énergie : kWh ou MWh selon la table.
+
+Les CSV contiennent les trajectoires, les séries journalières, les profils et les indicateurs par réalisation. `manifest.json` décrit les paramètres, les sources, les unités et les agrégations ; `semantics.ttl` conserve la provenance. Une comparaison ajoute `scenario` aux CSV réunis et conserve les deux calculs individuels. `comparison.json` donne les écarts entre médianes.
+
+[Paramètres et sorties TLS](docs/tls-reference.md) · [Contrat JSON](ontology/tls-contract.json) · [Exécution depuis un agent](docs/agent-contract.md)
+
+## Développement
+
+Les définitions sont maintenues dans le [descripteur](descriptors/tls/descriptor.yaml). Le calcul utilise l’adaptateur et le backend TLS fixé, sans modifier ses sources.
+
+```powershell
+& .\.venv\Scripts\python.exe -m pip install -e ".[dev,tls]"
+& .\.venv\Scripts\python.exe -m pytest -q
+& .\.venv\Scripts\python.exe -m ruff check src tests tools
+```
+
+[Architecture](docs/architecture.md) · [Intégration](docs/integrating-models.md) · [Protocole](docs/protocol.md)
+
+## Licence
+
+[PolyForm Noncommercial 1.0.0](LICENSE). Les composants conservent leurs licences ; les révisions déjà publiées sous MIT conservent leurs permissions. Le dépôt public ne contient aucune clé. Les archives privées de validation restent privées.

websemantic-0.2.5/docs/pypi.md

@@ -0,0 +1,15 @@
+# WebSemantic
+
+Software-agnostic semantic layer for scientific codes (research prototype). One descriptor per code is compiled into
+three documents: a readable contract for language models, an ontology with SHACL rules, and FAIR metadata. A
+deterministic validator checks the scenario a model proposes (values, units, origins, acceptances) before the
+unchanged code runs, and the outputs are stored with quantity, unit, origin, provenance and validity limits.
+
+This package provides the Python layer: validation gate, adapters, semantic tools and command-line entry point. The
+descriptors, ontology, contracts and the pinned scientific codes (TLS, LQL-Equiv, pyrcel) live in the repository;
+full use requires a clone with its submodules.
+
+- Repository and documentation: https://github.com/cyrilvoyant/websemantic
+- Ontology (persistent namespace): https://w3id.org/websemantic/ns
+- Concept DOI (all versions): https://doi.org/10.5281/zenodo.23238902
+- Licence: PolyForm Noncommercial 1.0.0

websemantic-0.2.5/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "websemantic"
+version = "0.2.5"
+description = "Software-agnostic semantic layer from intent to qualified simulated data (research prototype)"
+readme = "docs/pypi.md"
+requires-python = ">=3.10"
+license = "PolyForm-Noncommercial-1.0.0"
+authors = [{ name = "Cyril Voyant" }]
+keywords = ["semantic web", "scientific software", "large language models", "ontology", "SHACL", "provenance", "FAIR"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Science/Research",
+  "Programming Language :: Python :: 3",
+  "Topic :: Scientific/Engineering",
+]
+dependencies = [
+  "pydantic>=2.6",
+  "pyyaml>=6.0",
+  "rdflib>=7.0",
+  "pyshacl>=0.26",
+  "packaging>=24",
+]
+
+[project.urls]
+Homepage = "https://www.cyrilvoyant.com"
+Repository = "https://github.com/cyrilvoyant/websemantic"
+Documentation = "https://github.com/cyrilvoyant/websemantic#readme"
+Ontology = "https://w3id.org/websemantic/ns"
+DOI = "https://doi.org/10.5281/zenodo.23238902"
+
+[project.optional-dependencies]
+tls = ["numpy>=1.24", "pandas>=2.0"]
+# Target simulators. TLS and LQL-Equiv are loaded from the pinned submodules in external/.
+backends = ["numpy>=1.24", "pandas>=2.0"]
+atmosphere = ["numpy", "scipy", "pandas", "polars", "xarray", "netcdf4", "setuptools", "jax==0.11.2", "diffrax==0.7.2", "equinox==0.13.8", "optimistix==0.1.0"]
+llm = []  # Gemini uses the Python standard library REST client.
+dev = ["pytest>=8", "ruff>=0.6", "jsonschema>=4.18"]
+
+[project.scripts]
+websemantic = "websemantic.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.setuptools.package-data]
+websemantic = ["environments.json"]
+
+[tool.ruff]
+extend-exclude = ["external"]

websemantic-0.2.5/setup.cfg

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

websemantic-0.2.5/src/websemantic/__init__.py

@@ -0,0 +1,3 @@
+"""Software-agnostic semantic layer from intent to qualified simulated data (research prototype)."""
+
+__version__ = "0.0.1"

websemantic-0.2.5/src/websemantic/adapters/__init__.py

@@ -0,0 +1 @@
+"""Thin per-software adapters. The only code allowed to call target simulator APIs."""

websemantic-0.2.5/src/websemantic/adapters/lql.py

@@ -0,0 +1,118 @@
+"""Read-only LQL-Equiv execution for one explicitly fictitious course."""
+
+import csv
+import hashlib
+import importlib.util
+import json
+import math
+import sys
+import uuid
+from dataclasses import asdict
+from datetime import datetime, timezone
+from pathlib import Path
+
+from websemantic.core.validation import validate
+from websemantic.semantics import export_semantics
+
+EXPECTED_COMMIT = "dfc9a338205b8864b8e3470c4ae245b019e88844"
+# Filled from the pinned backend; line endings do not change numerical sources.
+EXPECTED_FILES = {'__init__.py': '2685b5a34b0da98c8329928f1de533ec6619178c2e2e89e92d48e231ad7a9d82', 'data/__init__.py': 'c849ce7dc4c2cd921e57faf5ffa453f8772eeed07367af69f1f9d7288f1741dd', 'data/tissues.json': '63283344abdc8147da7e112e0a5d728d1dc0bc565ad9950e9e5adccd08027f61', 'model.py': '3e0638c077e2fd9a04fedf7520a8e0c008f88d61b6e28974abd9533d681e0800', 'schedule.py': '7cffecd6e82acf536521aab1c1f58ae997a6754d43185ae6d317752c057f7dfa', 'tissues.py': '9ef2ff4d9a93b040697e5199d6902ce0ca9888474591de56126accf826a05c15'}
+
+
+def _backend(workspace, descriptor):
+    if descriptor["software"]["commit"] != EXPECTED_COMMIT:
+        raise ValueError("Révision LQL-Equiv incompatible avec cet adaptateur.")
+    root = Path(workspace) / "external/LQL-Equiv-web/src/lqlequiv"
+    for relative, expected in EXPECTED_FILES.items():
+        digest = hashlib.sha256((root / relative).read_bytes().replace(b"\r\n", b"\n")).hexdigest()
+        if digest != expected:
+            raise ValueError(f"Empreinte LQL-Equiv incorrecte : {relative}.")
+    # The library uses importlib.resources on lqlequiv.data. Reject an unrelated
+    # installed package instead of silently executing it.
+    existing = sys.modules.get("lqlequiv")
+    if existing is not None:
+        if Path(existing.__file__).resolve() != (root / "__init__.py").resolve():
+            raise ValueError("Un autre module lqlequiv est déjà chargé ; redémarrez Python.")
+        return existing
+    spec = importlib.util.spec_from_file_location(
+        "lqlequiv", root / "__init__.py", submodule_search_locations=[str(root)]
+    )
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    try:
+        spec.loader.exec_module(module)
+    except Exception:
+        for key in list(sys.modules):
+            if key == "lqlequiv" or key.startswith("lqlequiv."):
+                del sys.modules[key]
+        raise
+    return module
+
+
+def run(scenario, descriptor, workspace, output_root=None):
+    """Return native qualified indicators; never recommend a clinical dose."""
+    gate = validate(scenario, descriptor)
+    if gate.decision != "execute":
+        raise ValueError("Scénario incomplet, non accepté ou hors du profil LQL fictif.")
+    config = {name: item.value for name, item in scenario.inputs.items()}
+    if scenario.experiment.get("scenario_scope").value != "fictitious":
+        raise ValueError("Le profil accepte uniquement des scénarios fictifs de recherche.")
+    module = _backend(workspace, descriptor)
+    library = module.load_library()
+    organ = library.organ(config["organ"])
+    tumour = library.tumour_site(config["tumour_site"])
+    course = module.Course(config["dose_per_fraction"], config["n_fractions"], config["gap_days"])
+    prescription = module.Prescription(
+        courses=(course,), reference_dose=config["reference_dose"],
+        bifractionated=config["bifractionated"] == "yes",
+    )
+    result = module.compute(organ, tumour, prescription, options=module.Options())
+    native = result.courses[0]
+    oar_ok = result.oar_total_valid and not native.oar_saturated
+    tumour_ok = result.tumour_total_valid and not native.tumour_saturated
+    values = {
+        "physical_dose_gy": course.total_dose,
+        "bed_oar": native.bed_oar if result.oar_total_valid else None,
+        "bed_tumour": native.bed_tumour if result.tumour_total_valid else None,
+        "eqd_oar_total": result.eqd_oar_total if oar_ok else None,
+        "eqd_tumour_total": result.eqd_tumour_total if tumour_ok else None,
+        "ntcp_percent": result.ntcp_percent if oar_ok else None,
+        "tcp_percent": result.tcp_percent if tumour_ok else None,
+        "cancer_risk": result.cancer_risk if oar_ok else None,
+        "overall_days_oar": native.overall_days_oar,
+        "overall_days_tumour": native.overall_days_tumour,
+    }
+    if any(value is not None and not math.isfinite(value) for value in values.values()):
+        raise ValueError("Sortie LQL-Equiv non finie ; résultat refusé.")
+    flags = {
+        "oar_total_valid": result.oar_total_valid, "tumour_total_valid": result.tumour_total_valid,
+        "oar_saturated": native.oar_saturated, "tumour_saturated": native.tumour_saturated,
+    }
+    target = (Path(output_root) if output_root else Path(workspace) / "runs") / (
+        datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ") + "-" + uuid.uuid4().hex[:8]
+    )
+    target.mkdir(parents=True)
+    row = {**values, **flags}
+    with (target / "indicators.csv").open("w", newline="", encoding="utf-8") as handle:
+        writer = csv.DictWriter(handle, fieldnames=list(row))
+        writer.writeheader()
+        writer.writerow(row)
+    qualification = {"tables": {"indicators": {
+        "file": "indicators.csv", "aggregation": "Un calcul déterministe, un seul cursus fictif.",
+        "columns": {name: {"unit": spec.get("display_unit"), "meaning": spec["definition"]}
+                    for name, spec in descriptor["outputs"].items()},
+    }}}
+    manifest = {
+        "software": descriptor["software"], "scenario": asdict(scenario),
+        "nature": descriptor["nature"], "validity_notes": descriptor["validity_notes"],
+        "source_verification": {"method": "sha256_lf", "commit": EXPECTED_COMMIT,
+                                "files": EXPECTED_FILES},
+        "backend_options": asdict(result.options), "tissues": {"organ": asdict(organ), "tumour": asdict(tumour)},
+        "flags": flags, "output_qualification": qualification,
+        "null_policy": "EQD et probabilités dépendantes supprimées si invalides ou à la borne ; coefficient absent = null.",
+    }
+    (target / "manifest.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=2,
+                                                      allow_nan=False), encoding="utf-8")
+    (target / "scenario.json").write_text(json.dumps(asdict(scenario), ensure_ascii=False, indent=2), encoding="utf-8")
+    export_semantics(scenario, qualification, target, descriptor)
+    return target, values

websemantic-0.2.5/src/websemantic/adapters/pyrcel.py

@@ -0,0 +1,104 @@
+"""Read-only pyrcel 2.0.0 adapter: constant updraft, one lognormal mode."""
+import hashlib
+import importlib.metadata
+import json
+import os
+import sys
+import uuid
+from dataclasses import asdict
+from datetime import datetime, timezone
+from pathlib import Path
+
+from websemantic.core.validation import validate
+from websemantic.semantics import export_semantics
+
+COMMIT = "977e9094644ec4a17d658d657094651928591c89"
+SOURCE_HASHES = {'pyrcel/aerosol.py': 'd7fc5c1d055a5d6868aae53430a7d1c0797ff4c8f73caff387aef5900fcfc9c4', 'pyrcel/console_report.py': '2f64b98e0bda566582e46a6938c142d1aed361f9f3503f17864b5f153a98bf6e', 'pyrcel/constants.py': '7d75523d46874bb1faeaff3191f7effe27dc8e6e7866976dd72dc7b6d5df52d8', 'pyrcel/distributions.py': '712f41b5e72f54c3cb243d6e7708f8cb014c9f897f97a322ffac1ba832f1eb2e', 'pyrcel/ensemble.py': '856d97c73873061dfeae77c69db5da23d3b15019864808a9180ec6dd66e2641c', 'pyrcel/equilibrate.py': 'c85e21765e25589279d438f405b92bffabeac9115b290bfb76a3f3037cc0ffe7', 'pyrcel/integrator.py': 'd08876ea45151dd0fc2119aec2d4964dc0028087a904da4d7d006723b3e85992', 'pyrcel/model.py': '6c4cf795c682e4acb4b6531b4cd1fc3bf6b0689df9d046625862f0b8ef1ad5f0', 'pyrcel/model_output.py': '7214480542a6248ee914cd0e5709fd5223faf65f022bee3d6eea147ec0f64a3d', 'pyrcel/output.py': 'd7e543ed4d73fd853421f7106b0503dd3991c93a90082adfb180d2935514c472', 'pyrcel/parcel_aux.py': '07d56e3854d16acf309666d1444136fb1c52d5652d29442482a2047eadc91735', 'pyrcel/thermo.py': '779d453484e25b708afda3517f9d8f1303dd40c5ee1ead77c9ac01119cdccd80', 'pyrcel/updraft.py': 'f299171a7da17bbf206fe82b8a15a137e84265c2268b5489d32570e0f5a499ba', 'pyrcel/util.py': '7a1e64350e830870a5582822d2c93518cf18638e723fdc3333299855760db352', 'pyrcel/_types.py': '8e72187aa2c824f7adc4c784dcad676fc082b0487a422809a4619236eeb4561a', 'pyrcel/__init__.py': 'e4a30cbc78b63ef61c5a32f852a27362096c60a97f82c075b290a85acf050639', 'pyrcel/activation/_arg2000.py': 'e107a9c8ac418b09a9e6717bf14d108280ed02c2fc0ac159403cfb45d15f2ead', 'pyrcel/activation/_common.py': '383585cd6c00f2a9a7b940e3b7fa539132aba0981ac67db5f8ad061ec374514c', 'pyrcel/activation/_mbn2014.py': 'dd96adaa9c0282324b072dcf9f51dcac72507c75c0bb85d3cb7ee3f7a9f1a79d', 'pyrcel/activation/_scheme.py': 'f3976646eba72b0b81c4538be92c92fed60c39e4ec7a05bab6e204b9174254c7', 'pyrcel/activation/__init__.py': '9dd0d8a8e2246f6cc8e7aba01bc493c2cad47c9144752908f9a1e251a207cfd2', 'pyrcel/legacy/activation.py': 'f1e283f36d95ae373f705245f46d9beffebaed071a2e4e5ea8af1b81c8b4145d', 'pyrcel/legacy/postprocess.py': '4b763e13f904cd5c0662fbd43dc52e77acbedee61a6aaf9e7d19962216653dbc', 'pyrcel/legacy/thermo.py': '94e21fd06e573ebbadcf7e0ff5b2831f4e06b08f8e02ae185aeaae89e2c61a32', 'pyrcel/legacy/vis.py': '932c8ded03dcf9daeea05a6f9a5c8021841204d92afa32e1dcf85042e9b58a0d', 'pyrcel/legacy/__init__.py': '21ec0430ebb1bfdeef5e73bdf1f4227c23d83bc4d460b94a4f658f23bd45d34a', 'pyrcel/scripts/run_parcel.py': 'd8a45a5f535f469cd8ec6d9bfbc645bd3d28bc1dfc0cdc1f4496a1ccd5d40f4d', 'pyrcel/scripts/__init__.py': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'pyrcel/test/generate_data.py': '5fcb1e9f4840c56e4834bbdfa8b3bf25dcd1fe09990f5e24998f3fa3a86165a7', 'pyrcel/test/pm_test.py': 'f0733f17aadccb1620e7c453c46647f9588c39bd7d2f5e79c165ad6671934ad8', 'pyrcel/test/test_thermo.py': '3f6f0bcb7ccec593246c5578fde57c3bcacc63729b3b1bc859da453c2f3b54d3', 'pyrcel/test/__init__.py': 'aedf1b7eccb3cfb02226205f82309a1290079ce31ed5204325781ee2bf368fc7'}
+
+
+def verify_source(backend):
+    """Verify every Python module in the reviewed package, without requiring Git."""
+    actual = {str(p.relative_to(backend)).replace("\\", "/") for p in (backend / "pyrcel").rglob("*.py")}
+    if actual != set(SOURCE_HASHES):
+        raise ValueError("Modules pyrcel inattendus ou manquants; relancez Installer.")
+    for name, expected in SOURCE_HASHES.items():
+        digest = hashlib.sha256((backend / name).read_bytes().replace(b"\r\n", b"\n")).hexdigest()
+        if digest != expected:
+            raise ValueError("Code pyrcel modifié : " + name)
+    return {"method": "sha256_lf", "commit": COMMIT, "files": SOURCE_HASHES}
+
+
+def run(scenario, descriptor, workspace, output_root=None):
+    gate = validate(scenario, descriptor)
+    if gate.decision != "execute":
+        raise ValueError("Paramètres incomplets ou hypothèses non acceptées : " + "; ".join(i.field + ": " + i.code for i in gate.issues))
+    if descriptor["software"]["commit"] != COMMIT:
+        raise ValueError("Révision pyrcel incorrecte.")
+    params = {k: v.value for k, v in scenario.inputs.items()}
+    experiment = {k: v.value for k, v in scenario.experiment.items()}
+    if experiment["output_dt"] > experiment["t_end"] or experiment["t_end"] / experiment["output_dt"] > 100000:
+        raise ValueError("Pas de sortie incompatible avec la durée ou expérience trop volumineuse.")
+    workspace = Path(workspace)
+    backend = workspace / "external/pyrcel"
+    if not backend.is_dir():
+        backend = workspace / "work/candidates/pyrcel"
+    verification = verify_source(backend)
+    # Must configure before importing JAX; refuse a previously initialised incompatible runtime.
+    os.environ["JAX_ENABLE_X64"] = "true"
+    os.environ["JAX_PLATFORMS"] = "cpu"
+    try:
+        import jax
+        importlib.import_module("diffrax")  # required solver; checked before source import
+    except ImportError as exc:
+        raise ValueError("Composants pyrcel manquants; lancez Installer.cmd pour installer le profil atmosphérique.") from exc
+    jax.config.update("jax_enable_x64", True)
+    if any(device.platform != "cpu" for device in jax.devices()):
+        raise ValueError("Ce profil nécessite JAX CPU.")
+    sys.path.insert(0, str(backend))
+    try:
+        import pyrcel as pm
+        if Path(pm.__file__).resolve() != (backend / "pyrcel/__init__.py").resolve():
+            raise ValueError("Un autre module pyrcel est déjà chargé; ouvrez une nouvelle session.")
+        import numpy as np
+        aerosol = pm.AerosolSpecies("mode1", pm.Lognorm(mu=params["mu"], sigma=params["sigma"], N=params["N"]), kappa=params["kappa"], bins=params["bins"])
+        model = pm.ParcelModel([aerosol], V=params["V"], T0=params["T0"], P0=params["P0"], S0=params["S0"], accom=params["accom"], console=False)
+        output = model.run(experiment["t_end"], output_dt=experiment["output_dt"], terminate=experiment["terminate"] == "yes", terminate_depth=experiment["terminate_depth"])
+    except ImportError as exc:
+        raise ValueError("Composants pyrcel manquants; lancez Installer.cmd pour installer le profil atmosphérique.") from exc
+    finally:
+        sys.path.remove(str(backend))
+    if not np.isfinite(output.state).all() or not np.isfinite(output.time).all():
+        raise ValueError("Sortie pyrcel non finie; résultat refusé.")
+    if len(output.time) < 2 or np.any(np.diff(output.time) <= 0):
+        raise ValueError("Support temporel invalide.")
+    frame, aerosol_frames = output.to_pandas()
+    frame = frame.reset_index()
+    frame.rename(columns={frame.columns[0]: "time_s"}, inplace=True)
+    if not np.array_equal(frame["time_s"].to_numpy(), output.time):
+        raise ValueError("Le support temporel natif n’a pas été conservé.")
+    metrics = {"maximum_supersaturation_percent": float(output.summary["S_max"]) * 100, "activated_number_cm3": float(output.Nd) / 1e6, "activated_fraction": float(output.nd_frac), "actual_end_time_s": float(output.time[-1])}
+    if not all(np.isfinite(v) for v in metrics.values()):
+        raise ValueError("Indicateurs pyrcel non finis.")
+    target = (Path(output_root) if output_root else workspace / "runs") / (datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ") + "-" + uuid.uuid4().hex[:8])
+    target.mkdir(parents=True)
+    frame.to_csv(target / "trajectory.csv", index=False)
+    wet = aerosol_frames["mode1"].reset_index()
+    wet.rename(columns={wet.columns[0]: "time_s"}, inplace=True)
+    wet.to_csv(target / "wet_radii.csv", index=False)
+    import pandas as pd
+    pd.DataFrame([metrics]).to_csv(target / "kpis.csv", index=False)
+    qualification = {"trajectory": {"units": {"time_s": "s", "z": "m", "P": "Pa", "T": "K", "wv": "kg/kg", "wc": "kg/kg", "wi": "kg/kg", "S": "1"}, "temporal_support": "Exact native timestamps; nominal output_dt; final interval may be irregular"}, "wet_radii": {"time_unit": "s", "all_radius_columns_unit": "m", "definition": "Wet particle radius per size bin; not dry diameter"}, "kpis": {"maximum_supersaturation_percent": {"unit": "%", "definition": "Native solver peak locator; may differ from sampled CSV maximum"}, "activated_number_cm3": {"unit": "cm^-3", "definition": "Native hard-activation count at actual final output time"}, "activated_fraction": {"unit": "1", "definition": "Native activation fraction at actual final time"}, "actual_end_time_s": {"unit": "s", "definition": "Actual end; t_end is a maximum"}}}
+    qualification['tables'] = {
+        'trajectory': {'file': 'trajectory.csv', 'aggregation': 'Pas natif exact, dernier intervalle potentiellement irrégulier.',
+            'columns': {name: {'unit': unit, 'meaning': name + ' : sortie native de la parcelle idéale.'} for name, unit in qualification['trajectory']['units'].items()}},
+        'wet_radii': {'file': 'wet_radii.csv', 'aggregation': 'Rayons humides par classe aux instants natifs.',
+            'columns': {name: {'unit': 's' if name == 'time_s' else 'm', 'meaning': 'Temps natif' if name == 'time_s' else 'Rayon humide, pas diamètre sec'} for name in wet.columns}},
+        'kpis': {'file': 'kpis.csv', 'aggregation': 'Indicateurs natifs ; activation à la fin effective.',
+            'columns': {name: {'unit': spec['unit'], 'meaning': spec['definition']} for name, spec in qualification['kpis'].items()}}
+    }
+    export_semantics(scenario, qualification, target, descriptor)
+    versions = {name: importlib.metadata.version(name) for name in ("jax", "jaxlib", "diffrax", "equinox", "optimistix", "numpy", "pandas", "scipy")}
+    manifest = {"software": descriptor["software"], "source_verification": verification, "scenario": asdict(scenario), "nature": descriptor["nature"], "validity_notes": descriptor["validity_notes"], "output_qualification": qualification, "execution": {"python": sys.version, "versions": versions, "jax_backend": "cpu", "jax_enable_x64": bool(jax.config.jax_enable_x64), "requested_maximum_duration_s": experiment["t_end"], "actual_duration_s": metrics["actual_end_time_s"]}}
+    (target / "manifest.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=2, allow_nan=False), encoding="utf8")
+    (target / "scenario.json").write_text(json.dumps(asdict(scenario), ensure_ascii=False, indent=2, allow_nan=False), encoding="utf8")
+    return target, metrics