urban-workflow-playground 0.1.0__tar.gz

urban_workflow_playground-0.1.0/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: urban-workflow-playground
+Version: 0.1.0
+Summary: Playground web du DSL urban-workflow : éditeur avec intellisense, paramétrage des règles métier, diagnostics positionnés et simulation d'événements.
+Author-email: Gael Beard <gaelgael5@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/gaelgael5/urban-workflow
+Project-URL: Issues, https://github.com/gaelgael5/urban-workflow/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Environment :: Web Environment
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: urban-workflow>=0.1.0
+Requires-Dist: fastapi>=0.110
+Requires-Dist: uvicorn>=0.27
+
+# urban-workflow-playground
+
+Site web local pour écrire et tester des scripts de workflow
+[urban-workflow](https://pypi.org/project/urban-workflow/) :
+
+- **éditeur** avec coloration du DSL et **intellisense contextuelle**
+  (`Ctrl+Espace` ou automatique) : événements après `ON EVENT`, états
+  après `SWITCH`, règles après `WHEN`/`AND`/`OR`/`NOT`, actions après
+  `EXECUTE`, chemins après `@`, constantes après `=` — alimentée en
+  continu par l'analyse **réelle** du script (parseur ANTLR + visiteur) ;
+- **diagnostics positionnés** (syntaxe et validation sémantique),
+  soulignés dans l'éditeur et cliquables ;
+- **paramétrage** : déclaration des règles métier disponibles (nom,
+  paramètres typés, résultat simulé), persistée dans le navigateur —
+  c'est contre ces signatures que les appels `WHEN` sont validés ;
+- **structure** : vue arborescente de la configuration compilée
+  (initialiseurs, états, transitions) ;
+- **simulation** : une liste JSON d'événements rejoués dans l'ordre sur
+  le vrai moteur en mémoire — états atteints, actions poussées
+  (messages inclus), journal fonctionnel des règles.
+
+## Lancement
+
+```bash
+pip install urban-workflow-playground
+urban-workflow-playground            # http://127.0.0.1:8777
+```
+
+ou `python -m urban_workflow_playground`. Variables : `PLAYGROUND_HOST`
+(défaut `127.0.0.1`), `PLAYGROUND_PORT` (défaut `8777`).
+
+Depuis un clone du dépôt : `pip install -e ./playground`.
+
+## Notes
+
+- Outil de **développement local** : aucune authentification, ne pas
+  exposer publiquement.
+- Les règles simulées retournent le booléen configuré (le moteur et la
+  validation sont réels ; seule la logique interne des règles est
+  remplacée).
+- Le visiteur s'arrête à la première erreur sémantique : les erreurs
+  se corrigent donc une par une (la syntaxe, elle, est remontée en bloc).
+- `urban_workflow_playground/static/vendor/` : CodeMirror 5.65.18
+  (licence MIT), embarqué pour fonctionner hors ligne.

urban_workflow_playground-0.1.0/README.md

@@ -0,0 +1,44 @@
+# urban-workflow-playground
+
+Site web local pour écrire et tester des scripts de workflow
+[urban-workflow](https://pypi.org/project/urban-workflow/) :
+
+- **éditeur** avec coloration du DSL et **intellisense contextuelle**
+  (`Ctrl+Espace` ou automatique) : événements après `ON EVENT`, états
+  après `SWITCH`, règles après `WHEN`/`AND`/`OR`/`NOT`, actions après
+  `EXECUTE`, chemins après `@`, constantes après `=` — alimentée en
+  continu par l'analyse **réelle** du script (parseur ANTLR + visiteur) ;
+- **diagnostics positionnés** (syntaxe et validation sémantique),
+  soulignés dans l'éditeur et cliquables ;
+- **paramétrage** : déclaration des règles métier disponibles (nom,
+  paramètres typés, résultat simulé), persistée dans le navigateur —
+  c'est contre ces signatures que les appels `WHEN` sont validés ;
+- **structure** : vue arborescente de la configuration compilée
+  (initialiseurs, états, transitions) ;
+- **simulation** : une liste JSON d'événements rejoués dans l'ordre sur
+  le vrai moteur en mémoire — états atteints, actions poussées
+  (messages inclus), journal fonctionnel des règles.
+
+## Lancement
+
+```bash
+pip install urban-workflow-playground
+urban-workflow-playground            # http://127.0.0.1:8777
+```
+
+ou `python -m urban_workflow_playground`. Variables : `PLAYGROUND_HOST`
+(défaut `127.0.0.1`), `PLAYGROUND_PORT` (défaut `8777`).
+
+Depuis un clone du dépôt : `pip install -e ./playground`.
+
+## Notes
+
+- Outil de **développement local** : aucune authentification, ne pas
+  exposer publiquement.
+- Les règles simulées retournent le booléen configuré (le moteur et la
+  validation sont réels ; seule la logique interne des règles est
+  remplacée).
+- Le visiteur s'arrête à la première erreur sémantique : les erreurs
+  se corrigent donc une par une (la syntaxe, elle, est remontée en bloc).
+- `urban_workflow_playground/static/vendor/` : CodeMirror 5.65.18
+  (licence MIT), embarqué pour fonctionner hors ligne.

urban_workflow_playground-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "urban-workflow-playground"
+version = "0.1.0"
+description = "Playground web du DSL urban-workflow : éditeur avec intellisense, paramétrage des règles métier, diagnostics positionnés et simulation d'événements."
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "Gael Beard", email = "gaelgael5@gmail.com" }]
+requires-python = ">=3.10"
+dependencies = [
+    "urban-workflow>=0.1.0",
+    "fastapi>=0.110",
+    "uvicorn>=0.27",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Libraries",
+    "Environment :: Web Environment",
+]
+
+[project.urls]
+Homepage = "https://github.com/gaelgael5/urban-workflow"
+Issues = "https://github.com/gaelgael5/urban-workflow/issues"
+
+[project.scripts]
+urban-workflow-playground = "urban_workflow_playground.__main__:main"
+
+[tool.setuptools.packages.find]
+include = ["urban_workflow_playground*"]
+
+[tool.setuptools.package-data]
+urban_workflow_playground = ["static/*", "static/vendor/*"]

urban_workflow_playground-0.1.0/setup.cfg

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

urban_workflow_playground-0.1.0/urban_workflow_playground/__init__.py

@@ -0,0 +1,13 @@
+"""Playground web du DSL urban-workflow.
+
+Éditeur avec intellisense, diagnostics positionnés, paramétrage des
+règles métier et simulation d'événements sur le vrai moteur.
+
+Lancement ::
+
+    pip install urban-workflow-playground
+    urban-workflow-playground               # http://127.0.0.1:8777
+    # ou : python -m urban_workflow_playground
+"""
+
+__version__ = "0.1.0"

urban_workflow_playground-0.1.0/urban_workflow_playground/__main__.py

@@ -0,0 +1,18 @@
+"""``python -m urban_workflow_playground`` — démarre le serveur du playground."""
+
+import os
+
+import uvicorn
+
+
+def main() -> None:
+    uvicorn.run(
+        "urban_workflow_playground.app:app",
+        host=os.environ.get("PLAYGROUND_HOST", "127.0.0.1"),
+        port=int(os.environ.get("PLAYGROUND_PORT", "8777")),
+        reload=False,
+    )
+
+
+if __name__ == "__main__":
+    main()

urban_workflow_playground-0.1.0/urban_workflow_playground/app.py

@@ -0,0 +1,344 @@
+"""API du playground : analyse (diagnostics + symboles) et simulation.
+
+Deux endpoints :
+
+- ``POST /api/analyze`` — analyse un script avec les règles paramétrées ;
+  retourne les erreurs **positionnées** (syntaxe et sémantique), les
+  symboles pour l'intellisense (événements, règles, actions, constantes,
+  états) et un résumé structurel de la configuration ;
+- ``POST /api/simulate`` — rejoue une suite d'événements sur le script
+  (moteur complet en mémoire) et retourne états, actions poussées et
+  journal fonctionnel.
+
+Les règles métier n'existant pas côté navigateur, le panneau de
+paramétrage les déclare (nom, paramètres typés, résultat simulé) ; le
+serveur fabrique des callables à la signature exacte pour que la
+validation des appels ``WHEN`` soit la vraie.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+from fastapi import FastAPI
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel, Field
+
+from urban_workflow import (
+    FunctionRegistry,
+    MemoryStorage,
+    Workflow,
+    WorkflowEngine,
+    WorkflowFactory,
+    WorkflowProcessor,
+    WorkflowsConfig,
+)
+from urban_workflow.dsl import WorkflowConfigVisitor, WorkflowScriptParser
+from urban_workflow.exceptions import DslSyntaxError, WorkflowError
+from urban_workflow.outputs import default_memory_output
+from urban_workflow.templating.context import json_safe
+
+STATIC_DIR = Path(__file__).parent / "static"
+
+_IDENTIFIER = re.compile(r"^[A-Za-z][A-Za-z0-9_$#]*$")
+_POSITIONED = re.compile(r"^(?:[^:\n]*:)?(\d+):(\d+):\s*(.*)$", re.DOTALL)
+
+app = FastAPI(title="urban-workflow playground")
+
+
+# ----------------------------------------------------------------------
+# Modèles d'échange
+# ----------------------------------------------------------------------
+
+
+class RuleParam(BaseModel):
+    name: str
+    type: str = "TEXT"  # TEXT | INTEGER | DECIMAL
+
+
+class RuleSetting(BaseModel):
+    """Une règle métier paramétrée dans le panneau."""
+
+    name: str
+    params: list[RuleParam] = Field(default_factory=list)
+    result: bool = True  # résultat simulé
+
+
+class AnalyzeRequest(BaseModel):
+    script: str
+    rules: list[RuleSetting] = Field(default_factory=list)
+
+
+class SimulateRequest(BaseModel):
+    script: str
+    rules: list[RuleSetting] = Field(default_factory=list)
+    events: list[dict[str, Any]] = Field(default_factory=list)
+
+
+# ----------------------------------------------------------------------
+# Règles simulées
+# ----------------------------------------------------------------------
+
+
+def _build_registry(settings: list[RuleSetting]) -> FunctionRegistry:
+    """Fabrique des callables à la signature exacte des règles paramétrées."""
+    registry = FunctionRegistry("rule")
+    for setting in settings:
+        if not _IDENTIFIER.match(setting.name):
+            continue
+        params = [p.name for p in setting.params if _IDENTIFIER.match(p.name)]
+        signature = ", ".join(["ctx", *params])
+        namespace: dict[str, Any] = {}
+        exec(
+            f"def _rule({signature}):\n    return {bool(setting.result)}",
+            namespace,
+        )
+        if setting.name not in registry:
+            registry.add(setting.name, namespace["_rule"])
+    return registry
+
+
+# ----------------------------------------------------------------------
+# Extraction de symboles (repli regex quand le script ne compile pas)
+# ----------------------------------------------------------------------
+
+_RE_EVENT = re.compile(r"\bDEFINE\s+EVENT\s+(\w+)", re.IGNORECASE)
+_RE_RULE = re.compile(r"\bDEFINE\s+RULE\s+(\w+)\s*\(([^)]*)\)", re.IGNORECASE)
+_RE_ACTION = re.compile(r"\bDEFINE\s+ACTION\s+(\w+)\s*\(([^)]*)\)", re.IGNORECASE)
+_RE_CONST = re.compile(r"\bDEFINE\s+CONST\s+(\w+)", re.IGNORECASE)
+_RE_STATE = re.compile(r"\bDEFINE\s+STATE\s+(\w+)", re.IGNORECASE)
+_RE_PARAM = re.compile(r"(TEXT|INTEGER|DECIMAL)\s+(\w+)", re.IGNORECASE)
+
+
+def _params_from_text(text: str) -> list[dict[str, str]]:
+    return [
+        {"name": name, "type": kind.upper()}
+        for kind, name in _RE_PARAM.findall(text or "")
+    ]
+
+
+def _symbols_from_text(script: str) -> dict[str, Any]:
+    return {
+        "events": sorted(set(_RE_EVENT.findall(script))),
+        "rules": [
+            {"name": name, "params": _params_from_text(params)}
+            for name, params in _RE_RULE.findall(script)
+        ],
+        "actions": [
+            {"name": name, "params": _params_from_text(params)}
+            for name, params in _RE_ACTION.findall(script)
+        ],
+        "constants": sorted(set(_RE_CONST.findall(script))),
+        "states": sorted(set(_RE_STATE.findall(script))),
+    }
+
+
+_DSL_TYPE_NAMES = {str: "TEXT", int: "INTEGER", float: "DECIMAL"}
+
+
+def _symbols_from_visitor(visitor: WorkflowConfigVisitor, config) -> dict[str, Any]:
+    def declared(kind: str) -> list[dict[str, Any]]:
+        return [
+            {
+                "name": d.name,
+                "params": [
+                    {"name": n, "type": _DSL_TYPE_NAMES.get(t, t.__name__.upper())}
+                    for n, t in d.parameters.items()
+                ],
+                "comment": d.comment,
+            }
+            for d in visitor.declarations.values()
+            if d.kind == kind
+        ]
+
+    return {
+        "events": sorted(config.declared_events),
+        "rules": declared("rule"),
+        "actions": declared("action"),
+        "constants": [
+            {"name": c.key, "value": c.value, "comment": c.comment}
+            for c in visitor.constants.values()
+        ],
+        "states": sorted(config.states),
+    }
+
+
+# ----------------------------------------------------------------------
+# Erreurs positionnées
+# ----------------------------------------------------------------------
+
+
+def _error_entry(message: str, line: int = 1, column: int = 0) -> dict[str, Any]:
+    return {"line": line, "column": column, "message": message, "severity": "error"}
+
+
+def _positioned(exc: WorkflowError) -> dict[str, Any]:
+    """Retrouve ``ligne:colonne`` dans le message des erreurs du visiteur."""
+    match = _POSITIONED.match(str(exc))
+    if match:
+        return _error_entry(match.group(3), int(match.group(1)), int(match.group(2)))
+    return _error_entry(str(exc))
+
+
+def _summary(config) -> dict[str, Any]:
+    return {
+        "name": config.name,
+        "version": config.version,
+        "concurrency": config.concurrency,
+        "label": config.label,
+        "filters": dict(config.filters),
+        "initializers": [
+            {
+                "event": init.event_name,
+                "recursive": init.recursive,
+                "switchs": [
+                    {"target": s.target_state_name, "when": s.when_rule_text}
+                    for s in init.switchs
+                ],
+            }
+            for init in config.initializers.values()
+        ],
+        "states": [
+            {
+                "name": state.name,
+                "label": state.label,
+                "events": [
+                    {
+                        "name": event.name,
+                        "transitions": [
+                            {"target": t.target_state_name, "when": t.when_rule_text}
+                            for t in event.transitions
+                        ],
+                    }
+                    for event in state.events.values()
+                ],
+            }
+            for state in config.states.values()
+        ],
+    }
+
+
+# ----------------------------------------------------------------------
+# Endpoints
+# ----------------------------------------------------------------------
+
+
+@app.post("/api/analyze")
+def analyze(request: AnalyzeRequest) -> dict[str, Any]:
+    errors: list[dict[str, Any]] = []
+    summary: dict[str, Any] | None = None
+    symbols = _symbols_from_text(request.script)
+
+    parser = WorkflowScriptParser.parse_string(request.script, filename="playground")
+    for error in parser.errors:
+        errors.append(_error_entry(error.message, error.line, error.column))
+
+    if not errors:
+        visitor = WorkflowConfigVisitor(
+            rules=_build_registry(request.rules), filename="playground"
+        )
+        try:
+            config = parser.visit(visitor)
+            if not parser.is_fragment:
+                summary = _summary(config)
+            symbols = _symbols_from_visitor(visitor, config)
+        except DslSyntaxError as exc:
+            errors.extend(
+                _error_entry(e.message, e.line, e.column) for e in exc.errors
+            )
+        except WorkflowError as exc:
+            errors.append(_positioned(exc))
+
+    return {
+        "ok": not errors,
+        "is_fragment": parser.is_fragment,
+        "errors": errors,
+        "symbols": symbols,
+        "summary": summary,
+    }
+
+
+@app.post("/api/simulate")
+def simulate(request: SimulateRequest) -> dict[str, Any]:
+    registry = _build_registry(request.rules)
+
+    parser = WorkflowScriptParser.parse_string(request.script, filename="playground")
+    try:
+        parser.check()
+        config = parser.visit(WorkflowConfigVisitor(rules=registry, filename="playground"))
+    except WorkflowError as exc:
+        return {"ok": False, "error": str(exc), "steps": []}
+
+    storage = MemoryStorage()
+    processor = WorkflowProcessor(
+        WorkflowsConfig().add_document(config), WorkflowFactory()
+    )
+    processor.load_existing_workflows_by_external_id = lambda key: storage.get_by(
+        Workflow, key, "external_id"
+    )
+    processor.output_actions = default_memory_output(storage)
+    engine = WorkflowEngine(processor)
+
+    steps: list[dict[str, Any]] = []
+    for payload in request.events:
+        step: dict[str, Any] = {"event": payload.get("Name", "?")}
+        try:
+            contexts = engine.evaluate_event(payload)
+        except Exception as exc:  # erreur de payload ou de règle : on la montre
+            step["error"] = f"{type(exc).__name__}: {exc}"
+            steps.append(step)
+            continue
+
+        step["impacted"] = [
+            {
+                "workflow": ctx.workflow.workflow_name,
+                "external_id": ctx.workflow.external_id,
+                "from_state": ctx.event.from_state,
+                "to_state": ctx.event.to_state,
+                "actions": [
+                    {
+                        "name": pushed.name,
+                        "kind": pushed.kind,
+                        "message": json_safe(pushed.execute_message),
+                    }
+                    for pushed in ctx.event.actions
+                ],
+                "log": list(ctx.functional_log),
+            }
+            for ctx in contexts
+        ]
+        steps.append(step)
+
+    return {
+        "ok": True,
+        "steps": steps,
+        "workflows": [
+            {
+                "workflow": w.workflow_name,
+                "external_id": w.external_id,
+                "state": w.current_state,
+                "extended_datas": json_safe(w.extended_datas),
+                "events": [
+                    {"name": e.name, "from": e.from_state, "to": e.to_state}
+                    for e in w.events
+                ],
+            }
+            for w in storage.get_all(Workflow)
+        ],
+    }
+
+
+# ----------------------------------------------------------------------
+# Fichiers statiques
+# ----------------------------------------------------------------------
+
+
+@app.get("/")
+def index() -> FileResponse:
+    return FileResponse(STATIC_DIR / "index.html")
+
+
+app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")