fhe-cli 1.3.1__py3-none-any.whl

fhecli/solutions.py

@@ -0,0 +1,30 @@
+"""Encodage des solutions de référence embarquées dans le paquet.
+
+Les solutions ne sont pas stockées en clair dans le paquet : elles sont
+compressées (zlib) puis encodées en base64, derrière un petit en-tête.
+C'est une simple DISSUASION (éviter qu'un étudiant tombe sur la correction en
+ouvrant le dossier du paquet), PAS une protection cryptographique : n'importe
+qui peut les décoder avec ce module.
+"""
+
+import base64
+import zlib
+
+HEADER = "FHECLI-SOLUTION/1"
+LINE_WIDTH = 76
+
+
+def encode(text: str) -> str:
+    """Encode une solution en clair au format .sol."""
+    payload = base64.b64encode(zlib.compress(text.encode("utf-8"), 9)).decode("ascii")
+    lines = [payload[i:i + LINE_WIDTH] for i in range(0, len(payload), LINE_WIDTH)]
+    return "\n".join([HEADER, *lines]) + "\n"
+
+
+def decode(blob: str) -> str:
+    """Décode un fichier .sol produit par `encode`."""
+    lines = blob.strip().splitlines()
+    if not lines or lines[0].strip() != HEADER:
+        raise ValueError("Format de solution inconnu (en-tête manquant).")
+    payload = "".join(line.strip() for line in lines[1:])
+    return zlib.decompress(base64.b64decode(payload)).decode("utf-8")

fhecli/ui.py

@@ -0,0 +1,70 @@
+"""Petits utilitaires de terminal : couleurs ANSI, UTF-8, confirmations."""
+
+import os
+import sys
+
+if os.name == "nt":
+    # Active l'interprétation des séquences ANSI dans les vieilles consoles
+    # Windows (cmd.exe). Sans effet sur les terminaux modernes.
+    os.system("")
+
+_ENABLED = sys.stdout.isatty() and "NO_COLOR" not in os.environ
+
+RESET = "\033[0m" if _ENABLED else ""
+BOLD = "\033[1m" if _ENABLED else ""
+DIM = "\033[2m" if _ENABLED else ""
+GREEN = "\033[32m" if _ENABLED else ""
+RED = "\033[31m" if _ENABLED else ""
+YELLOW = "\033[33m" if _ENABLED else ""
+CYAN = "\033[36m" if _ENABLED else ""
+
+
+def setup_console() -> None:
+    """Force UTF-8 sur stdout/stderr (accents corrects dans les vieilles
+    consoles Windows ou quand la sortie est redirigée)."""
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(encoding="utf-8", errors="replace")
+        except (AttributeError, ValueError):
+            pass
+
+
+def color(text: str, code: str) -> str:
+    return f"{code}{text}{RESET}"
+
+
+def success(text: str) -> str:
+    return color(text, GREEN)
+
+
+def failure(text: str) -> str:
+    return color(text, RED)
+
+
+def warn(text: str) -> str:
+    return color(text, YELLOW)
+
+
+def info(text: str) -> str:
+    return color(text, CYAN)
+
+
+def bold(text: str) -> str:
+    return color(text, BOLD)
+
+
+def rule(char: str = "-", width: int = 70) -> str:
+    return char * width
+
+
+YES_ANSWERS = ("o", "oui", "y", "yes")
+
+
+def confirm(question: str) -> bool:
+    """Pose une question oui/non. Entrée vide, EOF ou Ctrl+C valent « non »."""
+    try:
+        answer = input(f"{question} [o/N] ")
+    except (EOFError, KeyboardInterrupt):
+        print()
+        return False
+    return answer.strip().lower() in YES_ANSWERS

fhecli/watch.py

@@ -0,0 +1,116 @@
+"""Mode « watch » : réexécute les tests de l'exercice courant à chaque
+sauvegarde du fichier, et avance automatiquement une fois qu'il est résolu.
+"""
+
+import sys
+import time
+
+from fhecli import resources, ui
+from fhecli.info import Exercise
+from fhecli.runner import has_marker, run_tests
+
+POLL_INTERVAL = 0.5
+
+
+def _print_exercise_banner(ex: Exercise, index: int, total: int) -> None:
+    print()
+    print(ui.rule("="))
+    print(ui.bold(f"Exercice {index}/{total} : {ex.name} - {ex.title}"))
+    print(f"{ui.info(ex.category)}" + (f"  {ui.warn('[bonus]')}" if ex.bonus else ""))
+    print(ui.rule("="))
+    print(f"Fichier à éditer : {ex.path}")
+    print(ui.DIM + "En attente de modifications... (Ctrl+C pour quitter)" + ui.RESET)
+
+
+def _run_and_report(ex: Exercise) -> bool:
+    passed, output = run_tests(ex.path)
+    print()
+    if passed:
+        print(ui.success("Tests : OK"))
+    else:
+        print(ui.failure("Tests : ÉCHEC"))
+        print(output)
+    return passed
+
+
+def _first_pending(exercises: list[Exercise]) -> Exercise | None:
+    for ex in exercises:
+        passed, _ = run_tests(ex.path)
+        if not (passed and not has_marker(ex.path)):
+            return ex
+    return None
+
+
+def _offer_solution(ex: Exercise) -> None:
+    """Après une réussite, propose d'afficher la solution de référence
+    (uniquement dans un vrai terminal interactif)."""
+    # stdin ET stdout : sous Windows, le périphérique NUL se déclare « tty ».
+    if not (sys.stdin.isatty() and sys.stdout.isatty() and resources.has_solution(ex.name)):
+        return
+    if ui.confirm("Exercice résolu ! Voir la solution de référence pour comparer ?"):
+        print(ui.rule())
+        print(resources.solution_text(ex.name))
+        print(ui.rule())
+
+
+def watch(exercises: list[Exercise]) -> None:
+    total = len(exercises)
+    print(ui.bold("fhecli watch") + " - mode surveillance")
+    print("Résolvez les exercices dans l'ordre. Dès que les tests d'un")
+    print("exercice passent, retirez le commentaire « # I AM NOT DONE » en")
+    print("haut du fichier : l'outil passera alors au suivant.")
+
+    try:
+        while True:
+            current = _first_pending(exercises)
+            if current is None:
+                print()
+                print(ui.rule("*"))
+                print(ui.success(ui.bold("Félicitations, vous avez terminé tous les exercices !")))
+                print(ui.rule("*"))
+                return
+
+            index = exercises.index(current) + 1
+            _print_exercise_banner(current, index, total)
+            # Date relevée AVANT de lancer les tests : une sauvegarde faite
+            # pendant leur exécution sera bien détectée au prochain passage.
+            last_mtime = _safe_mtime(current.path)
+            passed = _run_and_report(current)
+            if passed and not has_marker(current.path):
+                # Résolu entre-temps (fichier sauvegardé pendant l'analyse) :
+                # on avance sans attendre une nouvelle sauvegarde.
+                print(ui.success("Exercice résolu, passage au suivant..."))
+                _offer_solution(current)
+                continue
+            if passed:
+                print(ui.warn(
+                    "Tests OK ! Retirez « # I AM NOT DONE » en haut du fichier "
+                    "pour passer au suivant."
+                ))
+
+            while True:
+                time.sleep(POLL_INTERVAL)
+                mtime = _safe_mtime(current.path)
+                if mtime is not None and mtime != last_mtime:
+                    last_mtime = mtime
+                    time.sleep(0.15)  # laisse l'éditeur finir d'écrire le fichier
+                    passed = _run_and_report(current)
+                    if passed and not has_marker(current.path):
+                        print(ui.success("Exercice résolu, passage au suivant..."))
+                        _offer_solution(current)
+                        break
+                    if passed and has_marker(current.path):
+                        print(ui.warn(
+                            "Tests OK ! Retirez « # I AM NOT DONE » en haut du "
+                            "fichier pour passer au suivant."
+                        ))
+    except KeyboardInterrupt:
+        print()
+        print(ui.info("À bientôt !"))
+
+
+def _safe_mtime(path):
+    try:
+        return path.stat().st_mtime
+    except FileNotFoundError:
+        return None

fhecli/workspace.py

@@ -0,0 +1,58 @@
+"""Espace de travail de l'étudiant.
+
+Un espace de travail est un dossier qui contient le fichier marqueur
+`fhecli.toml`, un `pytest.ini` et le dossier `exercises/` où l'étudiant écrit
+son code. Il est créé par `fhecli init` ; toutes les autres commandes le
+retrouvent en remontant depuis le dossier courant jusqu'au marqueur.
+"""
+
+from pathlib import Path
+
+from fhecli import __version__, resources
+
+MARKER_FILE = "fhecli.toml"
+EXERCISES_DIR = "exercises"
+DEFAULT_DIR = "fhe-exercices"
+
+MARKER_CONTENT = f"""\
+# Espace de travail fhecli : ce fichier permet à `fhecli` de retrouver vos
+# exercices depuis n'importe quel sous-dossier. Ne le supprimez pas.
+[workspace]
+created_with = "{__version__}"
+"""
+
+PYTEST_INI = """\
+[pytest]
+# Les exercices contiennent leurs propres tests : on collecte donc tous les
+# fichiers .py du dossier exercises/ (pas seulement test_*.py).
+python_files = *.py
+testpaths = exercises
+addopts = -p no:cacheprovider
+"""
+
+
+class WorkspaceNotFound(Exception):
+    """Aucun espace de travail trouvé depuis le dossier courant."""
+
+
+def find_workspace(start: Path | None = None) -> Path:
+    """Remonte depuis `start` (ou le dossier courant) jusqu'au marqueur."""
+    current = (start or Path.cwd()).resolve()
+    for folder in (current, *current.parents):
+        if (folder / MARKER_FILE).is_file():
+            return folder
+    raise WorkspaceNotFound(str(current))
+
+
+def init_workspace(target: Path, exercise_names: list[str]) -> Path:
+    """Crée un espace de travail neuf. Refuse d'écraser un espace existant."""
+    target = target.resolve()
+    if (target / MARKER_FILE).exists() or (target / EXERCISES_DIR).exists():
+        raise FileExistsError(str(target))
+    exercises = target / EXERCISES_DIR
+    exercises.mkdir(parents=True)
+    for name in exercise_names:
+        (exercises / f"{name}.py").write_text(resources.original_text(name), encoding="utf-8")
+    (target / "pytest.ini").write_text(PYTEST_INI, encoding="utf-8")
+    (target / MARKER_FILE).write_text(MARKER_CONTENT, encoding="utf-8")
+    return target