normacare-sdk 2.0.0__tar.gz

normacare_sdk-2.0.0/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: normacare-sdk
+Version: 2.0.0
+Summary: SDK officiel pour développer, tester et publier des composants NormaCare.
+Author-email: FDevelopment LTD <sdk@fdevelopment.eu>
+License: Proprietary
+Project-URL: Homepage, https://normacare.app
+Project-URL: Store, https://store.normacare.app
+Project-URL: Documentation, https://docs.normacare.app/sdk
+Keywords: normacare,hl7,fhir,interoperability,healthcare,integration
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Healthcare Industry
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: protect
+Requires-Dist: pyarmor>=8; extra == "protect"
+
+# NormaCare SDK
+
+Le SDK officiel pour développer, tester et publier des **composants** d'intégration
+médicale, utilisables dans **NormaCare Studio** et exécutés par **NormaCare Engine**,
+et distribuables sur le **NormaCare Store**.
+
+## Installation
+
+```bash
+pip install normacare-sdk
+```
+
+Développement local (depuis ce dossier) :
+
+```bash
+pip install -e .
+```
+
+## Démarrage rapide (5 minutes)
+
+```bash
+normacare-sdk new mon_composant_hl7 --template hl7
+cd mon_composant_hl7
+normacare-sdk test .        # exécute test_mon_composant_hl7.py
+normacare-sdk validate .    # vérifie le manifest .cmp
+normacare-sdk build .       # produit mon_composant_hl7-1.0.0.ncpkg
+normacare-sdk login         # connexion au Store
+normacare-sdk publish . --price 0
+```
+
+## Templates
+
+| Template     | Description |
+|---|---|
+| `basic`      | Composant Python minimal |
+| `hl7`        | Composant HL7 v2.x (extraction de segments) |
+| `database`   | Composant avec accès base de données |
+| `javascript` | Composant JavaScript / Node.js |
+| `http`       | Composant appel API REST |
+
+## Écrire un composant
+
+```python
+from normacare_sdk import NormaCareComponent, ComponentInfo, run
+
+class Component(NormaCareComponent):
+    info = ComponentInfo(type="mon_comp", label="Mon Composant", author="Moi")
+
+    def process(self, data, vars, params):
+        # self._config = options du composant (définies dans le .cmp / le Studio)
+        seuil = self.get_option(self._config, "seuil", default=10)
+        self.log("Traitement en cours")
+        return {"result": data, "seuil": seuil}
+
+run(Component)
+```
+
+À l'exécution, l'Engine injecte le contexte du flux :
+
+| Variable | Contenu |
+|---|---|
+| `_inputs` | sorties des nœuds parents |
+| `_vars`   | variables globales du flux |
+| `_params` | paramètres du job Engine |
+| `_config` | options du composant (du manifest `.cmp`) |
+
+## Tester
+
+```python
+from normacare_sdk.testing import ComponentTester
+from mon_comp import Component
+
+t = ComponentTester(Component)
+t.run(data={"raw": "MSH|..."}, config={"seuil": 5})
+t.assert_success()
+t.assert_output_key("result")
+t.print_report()
+```
+
+## Structure d'un composant
+
+```
+mon_composant/
+├── mon_composant.cmp      Manifest JSON (métadonnées, options, prix)
+├── mon_composant.py       Script (votre logique)
+├── test_mon_composant.py  Tests locaux
+└── README.md              Documentation (affichée sur le Store)
+```
+
+## Niveaux de protection
+
+| Niveau | Protection |
+|---|---|
+| Open source | aucune |
+| `"protected": true` | obfuscation PyArmor (`pip install normacare-sdk[protect]`) |
+| Payant | jeton d'achat requis (abonnement Publisher) |
+
+## Support
+
+- Documentation : https://docs.normacare.app/sdk
+- Store : https://store.normacare.app
+- Email : sdk@fdevelopment.eu
+
+© FDevelopment LTD

normacare_sdk-2.0.0/README.md

@@ -0,0 +1,104 @@
+# NormaCare SDK
+
+Le SDK officiel pour développer, tester et publier des **composants** d'intégration
+médicale, utilisables dans **NormaCare Studio** et exécutés par **NormaCare Engine**,
+et distribuables sur le **NormaCare Store**.
+
+## Installation
+
+```bash
+pip install normacare-sdk
+```
+
+Développement local (depuis ce dossier) :
+
+```bash
+pip install -e .
+```
+
+## Démarrage rapide (5 minutes)
+
+```bash
+normacare-sdk new mon_composant_hl7 --template hl7
+cd mon_composant_hl7
+normacare-sdk test .        # exécute test_mon_composant_hl7.py
+normacare-sdk validate .    # vérifie le manifest .cmp
+normacare-sdk build .       # produit mon_composant_hl7-1.0.0.ncpkg
+normacare-sdk login         # connexion au Store
+normacare-sdk publish . --price 0
+```
+
+## Templates
+
+| Template     | Description |
+|---|---|
+| `basic`      | Composant Python minimal |
+| `hl7`        | Composant HL7 v2.x (extraction de segments) |
+| `database`   | Composant avec accès base de données |
+| `javascript` | Composant JavaScript / Node.js |
+| `http`       | Composant appel API REST |
+
+## Écrire un composant
+
+```python
+from normacare_sdk import NormaCareComponent, ComponentInfo, run
+
+class Component(NormaCareComponent):
+    info = ComponentInfo(type="mon_comp", label="Mon Composant", author="Moi")
+
+    def process(self, data, vars, params):
+        # self._config = options du composant (définies dans le .cmp / le Studio)
+        seuil = self.get_option(self._config, "seuil", default=10)
+        self.log("Traitement en cours")
+        return {"result": data, "seuil": seuil}
+
+run(Component)
+```
+
+À l'exécution, l'Engine injecte le contexte du flux :
+
+| Variable | Contenu |
+|---|---|
+| `_inputs` | sorties des nœuds parents |
+| `_vars`   | variables globales du flux |
+| `_params` | paramètres du job Engine |
+| `_config` | options du composant (du manifest `.cmp`) |
+
+## Tester
+
+```python
+from normacare_sdk.testing import ComponentTester
+from mon_comp import Component
+
+t = ComponentTester(Component)
+t.run(data={"raw": "MSH|..."}, config={"seuil": 5})
+t.assert_success()
+t.assert_output_key("result")
+t.print_report()
+```
+
+## Structure d'un composant
+
+```
+mon_composant/
+├── mon_composant.cmp      Manifest JSON (métadonnées, options, prix)
+├── mon_composant.py       Script (votre logique)
+├── test_mon_composant.py  Tests locaux
+└── README.md              Documentation (affichée sur le Store)
+```
+
+## Niveaux de protection
+
+| Niveau | Protection |
+|---|---|
+| Open source | aucune |
+| `"protected": true` | obfuscation PyArmor (`pip install normacare-sdk[protect]`) |
+| Payant | jeton d'achat requis (abonnement Publisher) |
+
+## Support
+
+- Documentation : https://docs.normacare.app/sdk
+- Store : https://store.normacare.app
+- Email : sdk@fdevelopment.eu
+
+© FDevelopment LTD

normacare_sdk-2.0.0/normacare_sdk/__init__.py

@@ -0,0 +1,39 @@
+"""
+NormaCare SDK — paquet public.
+
+Développez des composants d'intégration médicale réutilisables, testables
+et publiables sur le NormaCare Store, exécutés par NormaCare Engine.
+
+Usage minimal :
+
+    from normacare_sdk import NormaCareComponent, ComponentInfo, run
+
+    class MonComposant(NormaCareComponent):
+        info = ComponentInfo(type="mon_comp", label="Mon Composant", author="Moi")
+
+        def process(self, data, vars, params):
+            return {"processed": True, "data": data}
+
+    run(MonComposant)
+
+FDevelopment LTD
+"""
+from .component import (
+    NormaCareComponent,
+    ComponentInfo,
+    ComponentError,
+    run,
+)
+from .testing import ComponentTester, TestResult
+
+__version__ = "2.0.0"
+
+__all__ = [
+    "NormaCareComponent",
+    "ComponentInfo",
+    "ComponentError",
+    "run",
+    "ComponentTester",
+    "TestResult",
+    "__version__",
+]

normacare_sdk-2.0.0/normacare_sdk/cli.py

@@ -0,0 +1,393 @@
+"""
+NormaCare SDK — CLI
+===================
+Outil en ligne de commande pour créer, tester, valider, packager et publier
+des composants NormaCare.
+
+Commandes:
+    normacare-sdk new <nom> [--template T]  Créer un composant depuis un template
+    normacare-sdk validate [dossier]        Valider un composant avant publication
+    normacare-sdk test [dossier]            Exécuter les tests locaux (test_*.py)
+    normacare-sdk build [dossier]           Packager en bundle .ncpkg
+    normacare-sdk login                     Se connecter au Store NormaCare
+    normacare-sdk publish [dossier] [--price P]   Publier sur le Store
+
+FDevelopment LTD
+"""
+from __future__ import annotations
+import os
+import sys
+import json
+import shutil
+import zipfile
+import hashlib
+import argparse
+import subprocess
+from pathlib import Path
+from datetime import datetime, timezone
+
+STORE_URL    = os.getenv("NORMACARE_STORE_URL", "https://store.normacare.app")
+try:
+    from . import __version__ as SDK_VERSION
+except Exception:  # exécution hors paquet
+    SDK_VERSION = "2.0.0"
+CONFIG_FILE  = Path.home() / ".normacare" / "credentials.json"
+# Templates embarqués dans le paquet (inclus par pip via package-data).
+TEMPLATES_DIR = Path(__file__).parent / "templates"
+
+TEMPLATES = {
+    "basic":      "Composant Python minimal — point de départ universel",
+    "hl7":        "Composant spécialisé HL7 v2.x (segments MSH/PID/OBX…)",
+    "database":   "Composant avec accès base de données",
+    "javascript": "Composant JavaScript / Node.js",
+    "http":       "Composant appel API REST",
+}
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _ok(msg):   print(f"  ✓  {msg}")
+def _info(msg): print(f"  ℹ  {msg}")
+def _warn(msg): print(f"  ⚠  {msg}")
+def _err(msg):  print(f"  ✕  {msg}", file=sys.stderr)
+
+def _load_credentials():
+    if CONFIG_FILE.exists():
+        try:
+            return json.loads(CONFIG_FILE.read_text())
+        except Exception:
+            return None
+    return None
+
+def _save_credentials(data):
+    CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(json.dumps(data, indent=2))
+
+def _load_manifest(folder: Path) -> dict:
+    cmp_files = list(folder.glob("*.cmp"))
+    if not cmp_files:
+        _err(f"Aucun fichier .cmp trouvé dans {folder}")
+        sys.exit(1)
+    return json.loads(cmp_files[0].read_text(encoding="utf-8"))
+
+def _slug(name: str) -> str:
+    return name.strip().lower().replace(" ", "_").replace("-", "_")
+
+# ── Commande : new ─────────────────────────────────────────────────────────────
+
+def cmd_new(args):
+    template = args.template or "basic"
+    name     = _slug(args.name)
+    target   = Path(name)
+
+    if target.exists():
+        _err(f"Le dossier '{name}' existe déjà.")
+        sys.exit(1)
+
+    tpl_dir = TEMPLATES_DIR / template
+    if not tpl_dir.exists():
+        _err(f"Template '{template}' introuvable. Disponibles : {list(TEMPLATES)}")
+        sys.exit(1)
+
+    shutil.copytree(tpl_dir, target)
+
+    # Le template utilise le radical « component » ; on le remplace par <name>.
+    is_js   = template == "javascript"
+    old_stem = "component"
+    ext      = ".js" if is_js else ".py"
+
+    # Renomme le script principal.
+    old_script = target / f"{old_stem}{ext}"
+    new_script = target / f"{name}{ext}"
+    if old_script.exists():
+        old_script.rename(new_script)
+
+    # Renomme et réécrit le manifest.
+    old_cmp = target / f"{old_stem}.cmp"
+    manifest = json.loads(old_cmp.read_text(encoding="utf-8"))
+    manifest["type"]   = name
+    manifest["label"]  = name.replace("_", " ").title()
+    manifest["script"] = f"{name}{ext}"
+    new_cmp = target / f"{name}.cmp"
+    new_cmp.write_text(json.dumps(manifest, indent=2, ensure_ascii=False), encoding="utf-8")
+    if old_cmp.exists() and old_cmp != new_cmp:
+        old_cmp.unlink()
+
+    # Renomme le test et corrige son import (from component import ... → from <name>).
+    old_test = target / f"test_{old_stem}.py"
+    if old_test.exists():
+        txt = old_test.read_text(encoding="utf-8").replace(
+            f"from {old_stem} import", f"from {name} import"
+        ).replace(f"import {old_stem}\n", f"import {name}\n")
+        new_test = target / f"test_{name}.py"
+        new_test.write_text(txt, encoding="utf-8")
+        if old_test != new_test:
+            old_test.unlink()
+
+    print(f"\n  NormaCare SDK — composant créé : {name}/")
+    print(f"  Template : {TEMPLATES.get(template, template)}\n")
+    print("  Structure :")
+    for f in sorted(target.rglob("*")):
+        if f.is_file():
+            print(f"    {f.relative_to(target)}")
+    print("\n  Prochaines étapes :")
+    print(f"    1. cd {name}")
+    print(f"    2. Éditez {name}{ext}")
+    print("    3. normacare-sdk test .")
+    print("    4. normacare-sdk build .   (ou : publish . --price 0)\n")
+
+# ── Commande : validate ───────────────────────────────────────────────────────
+
+def cmd_validate(args):
+    folder = Path(args.folder)
+    print(f"\n  Validation de : {folder.resolve()}\n")
+    errors, warnings = [], []
+
+    manifest = _load_manifest(folder)
+
+    for field in ("type", "label", "version", "runtime", "script"):
+        if not manifest.get(field):
+            errors.append(f"Champ requis manquant : '{field}'")
+    if not manifest.get("author"):
+        warnings.append("Champ 'author' vide (requis pour publier sur le Store)")
+
+    if manifest.get("runtime") not in {"python", "javascript", "lua", "java"}:
+        errors.append(f"Runtime invalide : {manifest.get('runtime')!r} (python|javascript|lua|java)")
+
+    script_path = folder / manifest.get("script", "")
+    if manifest.get("script") and not script_path.exists():
+        errors.append(f"Script '{manifest.get('script')}' introuvable")
+
+    v = str(manifest.get("version", ""))
+    if not v or not all(p.isdigit() for p in v.split(".")):
+        warnings.append(f"Version '{v}' non standard (attendu X.Y.Z)")
+
+    if float(manifest.get("price", 0) or 0) < 0:
+        errors.append("Le prix ne peut pas être négatif")
+
+    if not (folder / "README.md").exists():
+        warnings.append("README.md manquant (recommandé pour le Store)")
+
+    if not (list(folder.glob("test_*.py")) + list(folder.glob("tests/*.py"))):
+        warnings.append("Aucun test trouvé (recommandé)")
+
+    for e in errors:   _err(e)
+    for w in warnings: _warn(w)
+
+    if not errors:
+        _ok(f"Validation réussie — {manifest['label']} v{manifest.get('version','?')}")
+        if warnings:
+            print(f"\n  {len(warnings)} avertissement(s) non bloquant(s)\n")
+        return True
+    print(f"\n  {len(errors)} erreur(s) — corrigez avant de publier\n")
+    sys.exit(1)
+
+# ── Commande : test ────────────────────────────────────────────────────────────
+
+def cmd_test(args):
+    folder = Path(args.folder)
+    tests = sorted(folder.glob("test_*.py")) + sorted(folder.glob("tests/test_*.py"))
+    if not tests:
+        _warn("Aucun test (test_*.py) trouvé.")
+        return
+    print(f"\n  Tests de : {folder.resolve()}\n")
+    all_ok = True
+    for t in tests:
+        _info(f"→ {t.name}")
+        # cwd = dossier du composant pour que « from <name> import … » fonctionne.
+        r = subprocess.run([sys.executable, t.name], cwd=str(folder))
+        if r.returncode != 0:
+            all_ok = False
+    print()
+    if all_ok:
+        _ok("Tous les tests sont passés.")
+    else:
+        _err("Des tests ont échoué.")
+        sys.exit(1)
+
+# ── Commande : build ───────────────────────────────────────────────────────────
+
+def cmd_build(args):
+    folder   = Path(args.folder)
+    manifest = _load_manifest(folder)
+    ctype    = manifest["type"]
+    version  = manifest.get("version", "1.0.0")
+
+    cmd_validate(argparse.Namespace(folder=str(folder)))
+
+    script_path = folder / manifest["script"]
+    script_code = script_path.read_text(encoding="utf-8")
+
+    if manifest.get("protected") and not getattr(args, "skip_protect", False):
+        try:
+            import pyarmor  # noqa: F401
+            _info("Obfuscation PyArmor du script…")
+            result = subprocess.run(
+                ["pyarmor", "gen", "--output", str(folder / "_dist"), str(script_path)],
+                capture_output=True, text=True,
+            )
+            _ok("Script obfusqué") if result.returncode == 0 else _warn("PyArmor indisponible — script non obfusqué")
+        except ImportError:
+            _warn("PyArmor non installé (pip install pyarmor) — script non obfusqué")
+
+    manifest["sha256"]   = hashlib.sha256(script_code.encode()).hexdigest()
+    manifest["built_at"] = datetime.now(timezone.utc).isoformat()
+
+    out_name = f"{ctype}-{version}.ncpkg"
+    out_path = folder.parent / out_name
+    with zipfile.ZipFile(out_path, "w", zipfile.ZIP_DEFLATED) as zf:
+        zf.writestr(f"{ctype}.cmp", json.dumps(manifest, indent=2, ensure_ascii=False))
+        zf.write(script_path, manifest["script"])
+        for opt in ("README.md", "CHANGELOG.md", "icon.png", "icon.svg"):
+            p = folder / opt
+            if p.exists():
+                zf.write(p, opt)
+        samples_dir = folder / "samples"
+        if samples_dir.exists():
+            for f in samples_dir.rglob("*"):
+                if f.is_file():
+                    zf.write(f, f"samples/{f.relative_to(samples_dir)}")
+
+    size_kb = out_path.stat().st_size // 1024
+    _ok(f"Bundle créé : {out_path.name} ({size_kb} Ko)")
+    print(f"  → {out_path.resolve()}\n")
+    return out_path
+
+# ── Commande : login ───────────────────────────────────────────────────────────
+
+def cmd_login(args):
+    import getpass
+    print("\n  Connexion au NormaCare Store\n")
+    email    = input("  Email : ").strip()
+    try:
+        password = getpass.getpass("  Mot de passe : ")
+    except Exception:
+        password = input("  Mot de passe : ").strip()
+
+    import urllib.request
+    try:
+        req = urllib.request.Request(
+            f"{STORE_URL}/api/auth/login",
+            data=json.dumps({"email": email, "password": password}).encode(),
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=15) as r:
+            data = json.loads(r.read())
+        _save_credentials({"email": email, "token": data["token"],
+                           "publisher_id": data.get("publisher_id")})
+        _ok(f"Connecté en tant que {email}")
+        _info(f"Plan : {data.get('plan', '?')}")
+    except Exception as e:
+        _err(f"Erreur de connexion : {e}")
+        sys.exit(1)
+
+# ── Commande : publish ─────────────────────────────────────────────────────────
+
+def cmd_publish(args):
+    folder   = Path(args.folder)
+    manifest = _load_manifest(folder)
+    creds    = _load_credentials()
+
+    if not creds:
+        _err("Non connecté. Lancez d'abord : normacare-sdk login")
+        sys.exit(1)
+
+    if args.price is not None:
+        manifest["price"] = float(args.price)
+    if args.visibility:
+        manifest["protected"] = args.visibility == "paid"
+
+    if float(manifest.get("price", 0) or 0) > 0:
+        cur = manifest.get("currency", "EUR")
+        print(f"\n  Publication payante : {manifest['label']} à {manifest['price']} {cur}")
+        print("  Commission FDevelopment LTD : 25%")
+        print(f"  Revenu net : {manifest['price'] * 0.75:.2f} {cur} / vente")
+        if input("\n  Confirmer ? (oui/non) : ").strip().lower() != "oui":
+            _info("Publication annulée.")
+            return
+
+    bundle_path = cmd_build(argparse.Namespace(folder=str(folder), skip_protect=False))
+
+    _info(f"Publication sur {STORE_URL}…")
+    import urllib.request
+    try:
+        bundle_data = Path(bundle_path).read_bytes()
+        metadata = json.dumps({"manifest": manifest,
+                               "publisher_id": creds.get("publisher_id")}).encode()
+        boundary = "NormaCareBoundary"
+        body  = f"--{boundary}\r\nContent-Disposition: form-data; name=\"metadata\"\r\n\r\n".encode()
+        body += metadata
+        body += (f"\r\n--{boundary}\r\nContent-Disposition: form-data; name=\"bundle\"; "
+                 f"filename=\"{bundle_path.name}\"\r\nContent-Type: application/octet-stream\r\n\r\n").encode()
+        body += bundle_data
+        body += f"\r\n--{boundary}--\r\n".encode()
+
+        req = urllib.request.Request(
+            f"{STORE_URL}/api/components/publish",
+            data=body,
+            headers={"Authorization": f"Bearer {creds['token']}",
+                     "Content-Type": f"multipart/form-data; boundary={boundary}"},
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=60) as r:
+            result = json.loads(r.read())
+        _ok("Composant publié !")
+        _info(f"URL Store : {STORE_URL}/components/{manifest['type']}")
+        _info(f"ID        : {result.get('id')}")
+        _info(f"Statut    : {result.get('status', 'en révision')}")
+    except Exception as e:
+        _err(f"Erreur de publication : {e}")
+        _info(f"Le bundle local est conservé : {bundle_path}")
+        sys.exit(1)
+
+# ── CLI main ──────────────────────────────────────────────────────────────────
+
+def build_parser():
+    parser = argparse.ArgumentParser(
+        prog="normacare-sdk",
+        description=f"NormaCare SDK v{SDK_VERSION} — Créez et publiez des composants",
+    )
+    parser.add_argument("--version", action="version", version=f"normacare-sdk {SDK_VERSION}")
+    sub = parser.add_subparsers(dest="cmd", metavar="commande")
+
+    p_new = sub.add_parser("new", help="Créer un composant depuis un template")
+    p_new.add_argument("name", help="Nom du composant (snake_case)")
+    p_new.add_argument("--template", "-t", default="basic", choices=list(TEMPLATES),
+                       help="Template à utiliser")
+
+    p_val = sub.add_parser("validate", help="Valider un composant")
+    p_val.add_argument("folder", nargs="?", default=".", help="Dossier du composant")
+
+    p_tst = sub.add_parser("test", help="Exécuter les tests locaux (test_*.py)")
+    p_tst.add_argument("folder", nargs="?", default=".", help="Dossier du composant")
+
+    p_bld = sub.add_parser("build", help="Packager le composant (.ncpkg)")
+    p_bld.add_argument("folder", nargs="?", default=".", help="Dossier du composant")
+    p_bld.add_argument("--skip-protect", action="store_true")
+
+    sub.add_parser("login", help="Se connecter au Store NormaCare")
+
+    p_pub = sub.add_parser("publish", help="Publier sur le Store NormaCare")
+    p_pub.add_argument("folder", nargs="?", default=".", help="Dossier du composant")
+    p_pub.add_argument("--price", type=float, default=None, help="Prix en EUR (0 = gratuit)")
+    p_pub.add_argument("--visibility", choices=["public", "paid"], default=None)
+    return parser
+
+def main(argv=None):
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    cmds = {
+        "new": cmd_new, "validate": cmd_validate, "test": cmd_test,
+        "build": cmd_build, "login": cmd_login, "publish": cmd_publish,
+    }
+    if args.cmd in cmds:
+        cmds[args.cmd](args)
+    else:
+        parser.print_help()
+        print("\n  Templates disponibles :")
+        for k, v in TEMPLATES.items():
+            print(f"    {k:<12} {v}")
+        print()
+
+if __name__ == "__main__":
+    main()