normacare-sdk 2.0.0__py3-none-any.whl

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/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()

normacare_sdk/component.py

@@ -0,0 +1,206 @@
+"""
+NormaCare SDK — Base Component
+==============================
+Classe de base pour créer des composants NormaCare.
+Hérite de cette classe pour créer ton propre composant.
+
+Usage:
+    from normacare_sdk import NormaCareComponent, ComponentInfo, run
+
+    class MyComponent(NormaCareComponent):
+        def process(self, data, vars, params):
+            # ton code ici
+            return {"result": data}
+
+    run(MyComponent)
+"""
+from __future__ import annotations
+import json
+import sys
+import os
+import traceback
+from dataclasses import dataclass, field, asdict
+from typing import Any, Dict, List, Optional
+
+
+# ── Métadonnées d'un composant ────────────────────────────────────────────────
+
+@dataclass
+class ComponentInfo:
+    """Décrit un composant NormaCare pour le Store et le Studio."""
+    type:        str            # identifiant unique snake_case : "hl7_enricher"
+    label:       str            # nom affiché : "HL7 Enricher"
+    version:     str = "1.0.0"
+    runtime:     str = "python" # python | javascript | lua
+    description: str = ""
+    author:      str = ""
+    author_email:str = ""
+    company:     str = ""
+    website:     str = ""
+    icon:        str = "🧩"     # emoji ou URL
+    tags:        List[str] = field(default_factory=list)
+    inputs:      List[str] = field(default_factory=lambda: ["data"])
+    outputs:     List[str] = field(default_factory=lambda: ["result"])
+    license:     str = "proprietary"  # MIT | Apache-2.0 | proprietary
+    min_engine:  str = "2.0.0"
+    # Champs Store
+    price:       float = 0.0   # 0.0 = gratuit
+    currency:    str = "EUR"
+    protected:   bool = False  # True = code obfusqué avant publication
+    options_schema: Dict[str, Any] = field(default_factory=dict)
+
+    def to_manifest(self) -> dict:
+        """Génère le manifest .cmp"""
+        d = asdict(self)
+        d["script"] = f"{self.type}.py"
+        return d
+
+
+# ── Classe de base ────────────────────────────────────────────────────────────
+
+class NormaCareComponent:
+    """
+    Classe de base pour tous les composants NormaCare.
+
+    Surcharge la méthode process() pour implémenter ton traitement.
+    Les méthodes helper (log, get_option, fail) sont disponibles.
+
+    Exemple minimal :
+        class MyComp(NormaCareComponent):
+            info = ComponentInfo(type="my_comp", label="My Component", author="Moi")
+
+            def process(self, data, vars, params):
+                return {"processed": True, "data": data}
+    """
+    info: ComponentInfo = None  # À définir dans chaque composant
+
+    def __init__(self):
+        self._logs: List[str] = []
+        self._config: Dict = {}   # options du composant (.cmp) injectées à l'exécution
+
+    # ── À surcharger ──────────────────────────────────────────────────────────
+
+    def process(self, data: Any, vars: Dict, params: Dict) -> Any:
+        """
+        Traitement principal du composant.
+
+        Args:
+            data:   Output du nœud parent (dict, str, list…)
+            vars:   Variables globales du flux (_vars.NOM_VARIABLE)
+            params: Paramètres du job (définis à la création du job Engine)
+
+        Returns:
+            Le résultat à transmettre au nœud suivant.
+            Doit être JSON-sérialisable.
+
+        Raises:
+            ComponentError: si le traitement échoue (sera loggé + propagé)
+        """
+        raise NotImplementedError("Implémentez la méthode process()")
+
+    def validate_config(self, config: Dict) -> List[str]:
+        """
+        Valide la configuration du composant (appelé au chargement).
+        Retourne une liste d'erreurs (vide = OK).
+        Surcharge optionnelle.
+        """
+        return []
+
+    def on_start(self):
+        """Hook appelé une fois au démarrage du flux. Surcharge optionnelle."""
+        pass
+
+    def on_stop(self):
+        """Hook appelé à l'arrêt du flux. Surcharge optionnelle."""
+        pass
+
+    # ── Helpers disponibles dans process() ────────────────────────────────────
+
+    def log(self, message: str, level: str = "info"):
+        """Émet un log visible dans les traces NormaCare Studio/Engine."""
+        prefix = {"info": "ℹ", "warning": "⚠", "error": "✕", "debug": "◦"}.get(level, "ℹ")
+        entry = f"[{prefix}] {message}"
+        self._logs.append(entry)
+        print(entry, file=sys.stderr)  # visible dans les traces Engine
+
+    def fail(self, message: str):
+        """Lève une erreur métier et arrête le traitement."""
+        raise ComponentError(message)
+
+    def get_option(self, config: Dict, key: str, default=None, required: bool = False):
+        """Récupère une option de configuration avec valeur par défaut."""
+        val = config.get(key, default)
+        if required and (val is None or val == ""):
+            self.fail(f"Option requise manquante : '{key}'")
+        return val
+
+    def parse_json(self, value: Any, default=None) -> Any:
+        """Parse une valeur JSON si c'est une string, sinon retourne tel quel."""
+        if isinstance(value, str):
+            try:
+                return json.loads(value)
+            except (json.JSONDecodeError, ValueError):
+                return default
+        return value
+
+    def extract_first_input(self, data: Dict) -> Any:
+        """Extrait la première valeur des inputs (pattern courant)."""
+        if isinstance(data, dict) and data:
+            return next(iter(data.values()))
+        return data
+
+    # ── Runner interne (appelé par run()) ────────────────────────────────────
+
+    def _run(self, inputs: Dict, vars: Dict, params: Dict, config: Dict) -> Any:
+        """Exécute le composant avec gestion d'erreur et logging."""
+        self._config = config or {}
+        try:
+            self.on_start()
+            # Passe les données du premier nœud parent
+            data = self.extract_first_input(inputs) if inputs else None
+            result = self.process(data, vars, params)
+            self.on_stop()
+            return result
+        except ComponentError as e:
+            self.log(str(e), "error")
+            raise
+        except Exception as e:
+            self.log(f"Erreur inattendue : {e}\n{traceback.format_exc()}", "error")
+            raise
+
+
+class ComponentError(Exception):
+    """Erreur métier dans un composant NormaCare."""
+    pass
+
+
+# ── Point d'entrée standard ───────────────────────────────────────────────────
+
+def run(component_class: type):
+    """
+    Lance le composant en mode exécution Engine.
+    Lit les inputs depuis stdin (JSON) et écrit le résultat sur stdout.
+
+    Appelé automatiquement par l'Engine — ne pas appeler manuellement.
+    """
+    frame = sys._getframe(1)
+    g = frame.f_globals
+    # run() ne s'exécute que lorsque l'Engine a injecté le contexte du flux
+    # (_inputs/_vars/_params/_config comme variables globales du script). À
+    # l'import (test unitaire, introspection), c'est un no-op : cela permet de
+    # tester le composant avec ComponentTester sans déclencher une exécution.
+    if not any(k in g for k in ("_inputs", "_vars", "_params", "_config")):
+        return
+    try:
+        inputs  = g.get("_inputs",  {})
+        vars_   = g.get("_vars",    {})
+        params  = g.get("_params",  {})
+        config  = g.get("_config",  {})
+
+        comp   = component_class()
+        result = comp._run(inputs, vars_, params, config)
+        print(json.dumps(result, ensure_ascii=False, default=str))
+    except Exception as e:
+        # En cas d'erreur, on sort un JSON d'erreur sur stdout
+        print(json.dumps({"_error": True, "message": str(e)}, ensure_ascii=False))
+        sys.exit(1)

normacare_sdk/templates/basic/README.md

@@ -0,0 +1,8 @@
+# Component
+
+Composant NormaCare de base.
+
+```bash
+normacare-sdk test .
+normacare-sdk build .
+```

normacare_sdk/templates/basic/component.cmp

@@ -0,0 +1,34 @@
+{
+  "type": "component",
+  "label": "Component",
+  "version": "1.0.0",
+  "runtime": "python",
+  "script": "component.py",
+  "description": "Composant Python de base.",
+  "author": "",
+  "author_email": "",
+  "company": "",
+  "website": "",
+  "icon": "🧩",
+  "tags": [
+    "exemple"
+  ],
+  "inputs": [
+    "data"
+  ],
+  "outputs": [
+    "result"
+  ],
+  "license": "proprietary",
+  "min_engine": "2.0.0",
+  "price": 0.0,
+  "currency": "EUR",
+  "protected": false,
+  "options_schema": {
+    "prefix": {
+      "type": "string",
+      "default": "",
+      "label": "Préfixe à ajouter"
+    }
+  }
+}