examshell-python 0.1.0__tar.gz

examshell_python-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: examshell-python
+Version: 0.1.0
+Summary: Interactive 42-style exam practice shell for Python exercises
+Author: Denis
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.0
+Requires-Dist: rich>=13.0

examshell_python-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "examshell-python"
+version = "0.1.0"
+description = "Interactive 42-style exam practice shell for Python exercises"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [
+    { name = "Denis" }
+]
+dependencies = [
+    "pydantic>=2.0",
+    "rich>=13.0",
+]
+
+[project.scripts]
+examshell = "examshell.main:cli"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+examshell = ["data/*.json"]

examshell_python-0.1.0/setup.cfg

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

examshell_python-0.1.0/src/examshell/__init__.py

@@ -0,0 +1,3 @@
+"""examshell — interactive 42-style exam practice shell."""
+
+__version__ = "0.1.0"

examshell_python-0.1.0/src/examshell/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for `python -m examshell`."""
+
+from .main import cli
+
+if __name__ == "__main__":
+    cli()

examshell_python-0.1.0/src/examshell/data/data.json

@@ -0,0 +1,588 @@
+[
+    {
+        "id": 1,
+        "level": 1,
+        "difficulty": "easy",
+        "name": "py_bracket_validator",
+        "file": "py_bracket_validator.py",
+        "description": {
+            "en": "Write a function that checks if the brackets in a string are valid.\nA string is valid if every opening bracket has a matching closing bracket\nin the correct order.\nAllowed brackets: (), [], {}",
+            "de": "Schreibe eine Funktion, die prГјft, ob Klammern in einem String korrekt gepaart und geschachtelt sind.\nUnterstГјtze drei Arten: (), [], {}.\n\nDie Funktion soll:\n- True zurГјckgeben, wenn alle Klammern korrekt gepaart sind\n- True fГјr Strings ohne Klammern zurГјckgeben\n- False bei nicht passenden oder falsch geschachtelten Klammern zurГјckgeben\n- Zeichen auГџerhalb von Klammern ignorieren",
+            "fr": "Écris une fonction qui vérifie si les parenthèses d’une chaîne sont correctement appariées et imbriquées.\nPrends en charge trois types : (), [], {}.\n\nLa fonction doit :\n- Retourner True si toutes les parenthèses sont correctement appariées\n- Retourner True pour les chaînes sans aucune parenthèse\n- Retourner False si elles ne correspondent pas ou sont mal imbriquées\n- Ignorer les caractères qui ne sont pas des parenthèses",
+            "es": "Escribe una funciГіn que compruebe si los parГ©ntesis de una cadena estГЎn bien emparejados y anidados.\nAdmite tres tipos: (), [], {}.\n\nLa funciГіn debe:\n- Devolver True si todos los parГ©ntesis estГЎn bien emparejados\n- Devolver True si la cadena no tiene parГ©ntesis\n- Devolver False si faltan pares o el anidamiento es incorrecto\n- Ignorar caracteres que no sean parГ©ntesis",
+            "it": "Scrivi una funzione che verifichi se le parentesi in una stringa sono accoppiate e annidate correttamente.\nSupporta tre tipi: (), [], {}.\n\nLa funzione deve:\n- Restituire True se tutte le parentesi sono corrette\n- Restituire True per stringhe senza parentesi\n- Restituire False se mancano coppie o l’annidamento è errato\n- Ignorare i caratteri che non sono parentesi"
+        },
+        "signature": "def bracket_validator(s: str) -> bool:",
+        "examples": [
+            {
+                "input": "bracket_validator(\"()\")",
+                "output": "True"
+            },
+            {
+                "input": "bracket_validator(\"()[]{}\")",
+                "output": "True"
+            },
+            {
+                "input": "bracket_validator(\"(]\")",
+                "output": "False"
+            },
+            {
+                "input": "bracket_validator(\"([)]\")",
+                "output": "False"
+            },
+            {
+                "input": "bracket_validator(\"{[]}\")",
+                "output": "True"
+            },
+            {
+                "input": "bracket_validator(\"hello(world)\")",
+                "output": "True"
+            },
+            {
+                "input": "bracket_validator(\"((())\")",
+                "output": "False"
+            },
+            {
+                "input": "bracket_validator(\"\")",
+                "output": "True"
+            }
+        ]
+    },
+    {
+        "id": 2,
+        "level": 1,
+        "difficulty": "easy",
+        "name": "py_cryptic_sorter",
+        "file": "py_cryptic_sorter.py",
+        "description": {
+            "en": "Write a function that sorts a list of strings according to multiple criteria:\n1. Primary sort: By string length (shortest first)\n2. Secondary sort: ASCII order, except letters are compared case-insensitively\n   (for strings of same length)\n3. Tertiary sort: By number of vowels (ascending, for same length and lexically equal)\n4. Equal strings will appear in the same order as in the input list.",
+            "de": "Schreibe eine Funktion, die eine Liste von Strings mit dreistufiger Priorität sortiert:\n1. Primär: nach Länge (aufsteigend)\n2. Sekundär: lexikographisch (alphabetisch, ohne Groß-/Kleinschreibung, aufsteigend)\n3. Tertiär: nach Anzahl der Vokale (aufsteigend bei gleicher Länge und lexikalischer Gleichheit)\n\nDie Funktion muss:\n- Leere Strings und leere Listen verarbeiten\n- Gemischte Groß-/Kleinschreibung (für Sortierung wie Kleinbuchstaben behandeln)\n- Sonderzeichen (für Vokalzählung ignorieren)",
+            "fr": "Г‰cris une fonction qui trie une liste de chaГ®nes avec une prioritГ© Г  trois niveaux :\n1. Tri principal : par longueur (croissant)\n2. Tri secondaire : lexicographique (alphabГ©tique, insensible Г  la casse, croissant)\n3. Tri tertiaire : par nombre de voyelles (croissant, si longueur et ordre lexicographique Г©gaux)\n\nLa fonction doit gГ©rer :\n- ChaГ®nes vides et listes vides\n- Casses mixtes (traiter comme des minuscules pour le tri)\n- CaractГЁres spГ©ciaux (les ignorer pour compter les voyelles)",
+            "es": "Escribe una funciГіn que ordene una lista de cadenas con prioridad en tres niveles:\n1. Primario: por longitud (ascendente)\n2. Secundario: lexicogrГЎfico (alfabГ©tico, sin distinguir mayГєsculas, ascendente)\n3. Terciario: por nГєmero de vocales (ascendente si la longitud y el orden lГ©xico coinciden)\n\nLa funciГіn debe manejar:\n- Cadenas vacГ­as y listas vacГ­as\n- MayГєsculas y minГєsculas mezcladas (tratar como minГєsculas al ordenar)\n- Caracteres especiales (ignorarlos al contar vocales)",
+            "it": "Scrivi una funzione che ordini una lista di stringhe con priorità a tre livelli:\n1. Primario: per lunghezza (crescente)\n2. Secondario: lessicografico (alfabetico, case-insensitive, crescente)\n3. Terziario: per numero di vocali (crescente a parità di lunghezza e ordine lessicale)\n\nLa funzione deve gestire:\n- Stringhe vuote e liste vuote\n- Maiuscole e minuscole miste (per l’ordinamento trattare come minuscole)\n- Caratteri speciali (ignorarli nel conteggio delle vocali)"
+        },
+        "signature": "def cryptic_sorter(strings: list[str]) -> list[str]:",
+        "examples": [
+            {
+                "input": "cryptic_sorter([\"apple\",\"cat\",\"banana\",\"dog\",\"elephant\"])",
+                "output": "[\"cat\",\"dog\",\"apple\",\"banana\",\"elephant\"]"
+            },
+            {
+                "input": "cryptic_sorter([\"aaa\",\"bbb\",\"AAA\",\"BBB\"])",
+                "output": "[\"AAA\", \"aaa\", \"BBB\", \"bbb\"]"
+            },
+            {
+                "input": "cryptic_sorter([\"hello\",\"world\",\"hi\",\"test\"])",
+                "output": "[\"hi\",\"test\",\"hello\",\"world\"]"
+            },
+            {
+                "input": "cryptic_sorter([])",
+                "output": "[]"
+            },
+            {
+                "input": "cryptic_sorter([\"\"])",
+                "output": "[\"\"]"
+            }
+        ]
+    },
+    {
+        "id": 3,
+        "level": 2,
+        "difficulty": "easy",
+        "name": "py_echo_validator",
+        "file": "py_echo_validator.py",
+        "description": {
+            "en": "Write a function that checks if a string is a palindrome,\nignoring spaces and case, only consider alphabetic characters\nfor the comparison.",
+            "de": "Schreibe eine Funktion, die prГјft, ob ein String ein Palindrom ist - Leerzeichen und GroГџ-/Kleinschreibung ignorieren; nur alphabetische Zeichen fГјr den Vergleich berГјcksichtigen.",
+            "fr": "Г‰cris une fonction qui vГ©rifie si une chaГ®ne est un palindrome, en ignorant espaces et casse, et en ne considГ©rant que les caractГЁres alphabГ©tiques pour la comparaison.",
+            "es": "Escribe una funciГіn que compruebe si una cadena es un palГ­ndromo, ignorando espacios y mayГєsculas/minГєsculas, y considerando solo caracteres alfabГ©ticos en la comparaciГіn.",
+            "it": "Scrivi una funzione che verifichi se una stringa ГЁ palindroma, ignorando spazi e maiuscole/minuscole e considerando solo i caratteri alfabetici nel confronto."
+        },
+        "signature": "def echo_validator(text: str) -> bool:",
+        "examples": [
+            {
+                "input": "echo_validator(\"racecar\")",
+                "output": "True"
+            },
+            {
+                "input": "echo_validator(\"A man a plan a canal Panama\")",
+                "output": "True"
+            },
+            {
+                "input": "echo_validator(\"race a car\")",
+                "output": "False"
+            },
+            {
+                "input": "echo_validator(\"Was it a car or a cat I saw\")",
+                "output": "True"
+            },
+            {
+                "input": "echo_validator(\"hello\")",
+                "output": "False"
+            },
+            {
+                "input": "echo_validator(\"Madam Im Adam\")",
+                "output": "True"
+            },
+            {
+                "input": "echo_validator(\"\")",
+                "output": "False"
+            }
+        ]
+    },
+    {
+        "id": 4,
+        "level": 2,
+        "difficulty": "easy",
+        "name": "py_mirror_matrix",
+        "file": "py_mirror_matrix.py",
+        "description": {
+            "en": "Given a 2D matrix (list of lists), return a new matrix where each row\nis reversed.",
+            "de": "Schreibe eine Funktion, die eine 2D-Matrix horizontal spiegelt, indem jede Zeile umgekehrt wird.\n\nDie Funktion soll:\n- Eine 2D-Liste (Matrix) aus ganzen Zahlen als Eingabe nehmen\n- Eine neue 2D-Liste zurückgeben, in der jede Zeile horizontal umgekehrt ist\n- Matrizen beliebiger Größe (quadratisch oder rechteckig) verarbeiten\n- Die ursprüngliche Zeilenreihenfolge beibehalten\n- Die ursprüngliche Matrix nicht verändern",
+            "fr": "Écris une fonction qui miroite une matrice 2D horizontalement en inversant chaque ligne.\n\nLa fonction doit :\n- Prendre une liste 2D (matrice) d’entiers en entrée\n- Retourner une nouvelle liste 2D où chaque ligne est inversée horizontalement\n- Gérer des matrices de toute taille (carrées ou rectangulaires)\n- Conserver l’ordre d’origine des lignes\n- Ne pas modifier la matrice d’origine",
+            "es": "Escribe una funciГіn que espeje una matriz 2D horizontalmente invirtiendo cada fila.\n\nLa funciГіn debe:\n- Recibir una lista 2D (matriz) de enteros\n- Devolver una nueva lista 2D donde cada fila estГ© invertida horizontalmente\n- Manejar matrices de cualquier tamaГ±o (cuadradas o rectangulares)\n- Conservar el orden original de las filas\n- No modificar la matriz original",
+            "it": "Scrivi una funzione che specchia una matrice 2D in orizzontale invertendo ogni riga.\n\nLa funzione deve:\n- Prendere in input una lista 2D (matrice) di interi\n- Restituire una nuova lista 2D in cui ogni riga è invertita orizzontalmente\n- Gestire matrici di qualsiasi dimensione (quadrate o rettangolari)\n- Preservare l’ordine originale delle righe\n- Non modificare la matrice originale"
+        },
+        "signature": "def mirror_matrix(matrix: list[list[int]]) -> list[list[int]]:",
+        "examples": [
+            {
+                "input": "mirror_matrix([[1,2,3],[4,5,6]])",
+                "output": "[[3,2,1],[6,5,4]]"
+            },
+            {
+                "input": "mirror_matrix([[1,2],[3,4],[5,6]])",
+                "output": "[[2,1],[4,3],[6,5]]"
+            },
+            {
+                "input": "mirror_matrix([[7]])",
+                "output": "[[7]]"
+            },
+            {
+                "input": "mirror_matrix([[1,2,3,4]])",
+                "output": "[[4,3,2,1]]"
+            },
+            {
+                "input": "mirror_matrix([[-1,-2],[-3,-4]])",
+                "output": "[[-2,-1],[-4,-3]]"
+            }
+        ]
+    },
+    {
+        "id": 5,
+        "level": 3,
+        "difficulty": "medium",
+        "name": "py_hidenp",
+        "file": "py_hidenp.py",
+        "description": {
+            "en": "Write a function that checks if the string 'small' is a subsequence\nof 'big'. A subsequence means all characters of 'small' appear in 'big'\nin the same order, but not necessarily consecutively.\nFunction is case-sensitive.",
+            "de": "Write a function that checks if the string 'small' is a subsequence\nof 'big'. A subsequence means all characters of 'small' appear in 'big'\nin the same order, but not necessarily consecutively.\nFunction is case-sensitive.",
+            "fr": "Write a function that checks if the string 'small' is a subsequence\nof 'big'. A subsequence means all characters of 'small' appear in 'big'\nin the same order, but not necessarily consecutively.\nFunction is case-sensitive.",
+            "es": "Write a function that checks if the string 'small' is a subsequence\nof 'big'. A subsequence means all characters of 'small' appear in 'big'\nin the same order, but not necessarily consecutively.\nFunction is case-sensitive.",
+            "it": "Write a function that checks if the string 'small' is a subsequence\nof 'big'. A subsequence means all characters of 'small' appear in 'big'\nin the same order, but not necessarily consecutively.\nFunction is case-sensitive."
+        },
+        "signature": "def hidenp(small: str, big: str) -> bool:",
+        "examples": [
+            {
+                "input": "hidenp(\"abc\", \"a1b2c3\")",
+                "output": "True"
+            },
+            {
+                "input": "hidenp(\"ace\", \"abcde\")",
+                "output": "True"
+            },
+            {
+                "input": "hidenp(\"aec\", \"abcde\")",
+                "output": "False"
+            },
+            {
+                "input": "hidenp(\"\", \"abc\")",
+                "output": "True"
+            },
+            {
+                "input": "hidenp(\"abc\", \"ab\")",
+                "output": "False"
+            },
+            {
+                "input": "hidenp(\"aaaa\", \"aaa\")",
+                "output": "False"
+            },
+            {
+                "input": "hidenp(\"sing\",\"subsequence testing\")",
+                "output": "True"
+            }
+        ]
+    },
+    {
+        "id": 6,
+        "level": 3,
+        "difficulty": "medium",
+        "name": "py_inter",
+        "file": "py_inter.py",
+        "description": {
+            "en": "Write a function that returns a string with the characters that appear\nin both strings, without repetitions. Characters are added in the order\nthey appear in the first string.",
+            "de": "Write a function that returns a string with the characters that appear\nin both strings, without repetitions. Characters are added in the order\nthey appear in the first string.",
+            "fr": "Write a function that returns a string with the characters that appear\nin both strings, without repetitions. Characters are added in the order\nthey appear in the first string.",
+            "es": "Write a function that returns a string with the characters that appear\nin both strings, without repetitions. Characters are added in the order\nthey appear in the first string.",
+            "it": "Write a function that returns a string with the characters that appear\nin both strings, without repetitions. Characters are added in the order\nthey appear in the first string."
+        },
+        "signature": "def inter(s1: str, s2: str) -> str:",
+        "examples": [
+            {
+                "input": "inter(\"hello\", \"world\")",
+                "output": "\"lo\""
+            },
+            {
+                "input": "inter(\"banana\", \"band\")",
+                "output": "\"ban\""
+            },
+            {
+                "input": "inter(\"abcabc\", \"bc\")",
+                "output": "\"bc\""
+            },
+            {
+                "input": "inter(\"abc\", \"xyz\")",
+                "output": "\"\""
+            },
+            {
+                "input": "inter(\"\", \"abc\")",
+                "output": "\"\""
+            }
+        ]
+    },
+    {
+        "id": 7,
+        "level": 3,
+        "difficulty": "medium",
+        "name": "py_number_base_converter",
+        "file": "py_number_base_converter.py",
+        "description": {
+            "en": "Write a function that converts a number from one base to another.\nSupport bases from 2 to 36 inclusive.\nUse digits 0-9 and letters A-Z for values 10-35.\nReturn \"ERROR\" for invalid inputs.",
+            "de": "Schreibe eine Funktion, die eine Zahl von einer Basis in eine andere konvertiert.\nUnterstГјtze Basen von 2 bis 36 einschlieГџlich, mit Ziffern 0-9 und Buchstaben A-Z fГјr die Werte 10-35. Gib bei ungГјltigen Eingaben (Basis, Ziffern) \"ERROR\" zurГјck.",
+            "fr": "Г‰cris une fonction qui convertit un nombre d'une base vers une autre.\nPrends en charge les bases de 2 Г  36 inclus, avec les chiffres 0-9 et les lettres A-Z pour les valeurs 10-35. Renvoie \"ERROR\" pour les entrГ©es invalides (base, chiffres).",
+            "es": "Escribe una funciГіn que convierta un nГєmero de una base a otra.\nAdmite bases de 2 a 36 inclusive, usando dГ­gitos 0-9 y letras A-Z para los valores 10-35. Devuelve \"ERROR\" si la entrada no es vГЎlida (base, dГ­gitos).",
+            "it": "Scrivi una funzione che converta un numero da una base a un'altra.\nSupporta basi da 2 a 36 inclusive, usando cifre 0-9 e lettere A-Z per i valori 10-35. Restituisci \"ERROR\" per input non validi (base, cifre)."
+        },
+        "signature": "def number_base_converter(number: str, from_base: int, to_base: int) -> str:",
+        "examples": [
+            {
+                "input": "number_base_converter(\"1010\", 2, 10)",
+                "output": "\"10\""
+            },
+            {
+                "input": "number_base_converter(\"FF\", 16, 10)",
+                "output": "\"255\""
+            },
+            {
+                "input": "number_base_converter(\"255\", 10, 16)",
+                "output": "\"FF\""
+            },
+            {
+                "input": "number_base_converter(\"123\", 10, 2)",
+                "output": "\"1111011\""
+            },
+            {
+                "input": "number_base_converter(\"Z\", 36, 10)",
+                "output": "\"35\""
+            },
+            {
+                "input": "number_base_converter(\"35\", 10, 36)",
+                "output": "\"Z\""
+            },
+            {
+                "input": "number_base_converter(\"123\", 1, 10)",
+                "output": "\"ERROR\""
+            },
+            {
+                "input": "number_base_converter(\"G\", 16, 10)",
+                "output": "\"ERROR\""
+            }
+        ]
+    },
+    {
+        "id": 8,
+        "level": 3,
+        "difficulty": "medium",
+        "name": "py_pattern_tracker",
+        "file": "py_pattern_tracker.py",
+        "description": {
+            "en": "Write a function that counts the number of valid consecutive digit pairs\nin a string. A valid pair consists of two adjacent digits where the second\ndigit is exactly one greater than the first.\nA 9 followed by a 0 is NOT a valid pair.",
+            "de": "Schreibe eine Funktion, die die Anzahl gültiger aufeinanderfolgender Ziffernpaare in einem String zählt. Ein gültiges Paar besteht aus zwei benachbarten Ziffern, bei denen die zweite genau um eins größer ist als die erste. Eine 9 gefolgt von 0 ist KEIN gültiges Paar.",
+            "fr": "Écris une fonction qui compte le nombre de paires de chiffres consécutifs valides dans une chaîne. Une paire valide est formée de deux chiffres adjacents dont le second vaut exactement un de plus que le premier. Un 9 suivi d’un 0 n’est PAS une paire valide.",
+            "es": "Escribe una funciГіn que cuente cuГЎntos pares consecutivos de dГ­gitos vГЎlidos hay en una cadena. Un par vГЎlido son dos dГ­gitos adyacentes donde el segundo es exactamente uno mayor que el primero. Un 9 seguido de 0 NO es un par vГЎlido.",
+            "it": "Scrivi una funzione che conti quante coppie consecutive di cifre valide ci sono in una stringa. Una coppia valida ГЁ formata da due cifre adiacenti in cui la seconda ГЁ esattamente uno piГ№ della prima. Un 9 seguito da 0 NON ГЁ una coppia valida."
+        },
+        "signature": "def pattern_tracker(text: str) -> int:",
+        "examples": [
+            {
+                "input": "pattern_tracker(\"123\")",
+                "output": "2"
+            },
+            {
+                "input": "pattern_tracker(\"12a34\")",
+                "output": "2"
+            },
+            {
+                "input": "pattern_tracker(\"987654321\")",
+                "output": "0"
+            },
+            {
+                "input": "pattern_tracker(\"01234567\")",
+                "output": "7"
+            },
+            {
+                "input": "pattern_tracker(\"abc\")",
+                "output": "0"
+            },
+            {
+                "input": "pattern_tracker(\"1a2b3c4\")",
+                "output": "0"
+            },
+            {
+                "input": "pattern_tracker(\"112233\")",
+                "output": "2"
+            }
+        ]
+    },
+    {
+        "id": 9,
+        "level": 4,
+        "difficulty": "medium",
+        "name": "py_anagram",
+        "file": "py_anagram.py",
+        "description": {
+            "en": "Write a function that checks if two strings are anagrams.\nThey must contain exactly the same letters with the same quantity,\nignoring case and spaces.",
+            "de": "Write a function that checks if two strings are anagrams.\nThey must contain exactly the same letters with the same quantity,\nignoring case and spaces.",
+            "fr": "Write a function that checks if two strings are anagrams.\nThey must contain exactly the same letters with the same quantity,\nignoring case and spaces.",
+            "es": "Write a function that checks if two strings are anagrams.\nThey must contain exactly the same letters with the same quantity,\nignoring case and spaces.",
+            "it": "Write a function that checks if two strings are anagrams.\nThey must contain exactly the same letters with the same quantity,\nignoring case and spaces."
+        },
+        "signature": "def anagram(s1: str, s2: str) -> bool:",
+        "examples": [
+            {
+                "input": "anagram(\"listen\", \"silent\")",
+                "output": "True"
+            },
+            {
+                "input": "anagram(\"Triangle\", \"Integral\")",
+                "output": "True"
+            },
+            {
+                "input": "anagram(\"Dormitory\", \"Dirty Room\")",
+                "output": "True"
+            },
+            {
+                "input": "anagram(\"hello\", \"world\")",
+                "output": "False"
+            },
+            {
+                "input": "anagram(\"\", \"\")",
+                "output": "True"
+            },
+            {
+                "input": "anagram(\"abc\", \"abcc\")",
+                "output": "False"
+            }
+        ]
+    },
+    {
+        "id": 10,
+        "level": 4,
+        "difficulty": "medium",
+        "name": "py_shadow_merge",
+        "file": "py_shadow_merge.py",
+        "description": {
+            "en": "Write a function that merges two sorted lists into one sorted list.",
+            "de": "Schreibe eine Funktion, die zwei sortierte Listen zu einer sortierten Liste zusammenfГјhrt.",
+            "fr": "Г‰cris une fonction qui fusionne deux listes triГ©es en une seule liste triГ©e.",
+            "es": "Escribe una funciГіn que fusione dos listas ordenadas en una sola lista ordenada.",
+            "it": "Scrivi una funzione che unisca due liste ordinate in un’unica lista ordinata."
+        },
+        "signature": "def shadow_merge(list1: list[int], list2: list[int]) -> list[int]:",
+        "examples": [
+            {
+                "input": "shadow_merge([1,3,5], [2,4,6])",
+                "output": "[1,2,3,4,5,6]"
+            },
+            {
+                "input": "shadow_merge([1,2,3], [4,5,6])",
+                "output": "[1,2,3,4,5,6]"
+            },
+            {
+                "input": "shadow_merge([1], [2,3,4])",
+                "output": "[1,2,3,4]"
+            },
+            {
+                "input": "shadow_merge([], [1,2,3])",
+                "output": "[1,2,3]"
+            },
+            {
+                "input": "shadow_merge([1,1,2], [1,3,3])",
+                "output": "[1,1,1,2,3,3]"
+            }
+        ]
+    },
+    {
+        "id": 11,
+        "level": 4,
+        "difficulty": "medium",
+        "name": "py_string_permutation_checker",
+        "file": "py_string_permutation_checker.py",
+        "description": {
+            "en": "Write a function that determines if two strings are permutations of each other.\nCase sensitive. Whitespace and punctuation count as regular characters.\nEmpty strings are permutations of each other.",
+            "de": "Schreibe eine Funktion, die feststellt, ob zwei Strings Permutationen voneinander sind.\nZwei Strings sind Permutationen, wenn sie dieselben Zeichen mit denselben Häufigkeiten enthalten.\n\nDie Funktion soll:\n- Prüfen, ob beide Strings genau dieselben Zeichen enthalten\n- Zeichenhäufigkeiten zählen (groß-/kleinschreibungssensitiv)\n- True zurückgeben, wenn es Permutationen sind, sonst False\n- Leere Strings behandeln (zwei leere Strings sind Permutationen)\n- Leerzeichen und Satzzeichen wie normale Zeichen behandeln",
+            "fr": "Écris une fonction qui détermine si deux chaînes sont des permutations l’une de l’autre.\nDeux chaînes sont des permutations si elles contiennent les mêmes caractères avec les mêmes fréquences.\n\nLa fonction doit :\n- Vérifier que les deux chaînes contiennent exactement les mêmes caractères\n- Compter les fréquences (sensible à la casse)\n- Retourner True si ce sont des permutations, sinon False\n- Gérer les chaînes vides (deux chaînes vides sont des permutations)\n- Traiter espaces et ponctuation comme des caractères normaux",
+            "es": "Escribe una funciГіn que determine si dos cadenas son permutaciones entre sГ­.\nDos cadenas son permutaciones si contienen los mismos caracteres con las mismas frecuencias.\n\nLa funciГіn debe:\n- Comprobar que ambas cadenas tienen exactamente los mismos caracteres\n- Contar frecuencias (distingue mayГєsculas y minГєsculas)\n- Devolver True si son permutaciones, False en caso contrario\n- Manejar cadenas vacГ­as (dos vacГ­as son permutaciГіn)\n- Tratar espacios y puntuaciГіn como caracteres normales",
+            "it": "Scrivi una funzione che determini se due stringhe sono permutazioni l’una dell’altra.\nDue stringhe sono permutazioni se contengono gli stessi caratteri con le stesse frequenze.\n\nLa funzione deve:\n- Verificare che entrambe le stringhe contengano esattamente gli stessi caratteri\n- Contare le frequenze (case-sensitive)\n- Restituire True se sono permutazioni, altrimenti False\n- Gestire stringhe vuote (due vuote sono permutazioni)\n- Considerare spazi e punteggiatura come caratteri normali"
+        },
+        "signature": "def string_permutation_checker(s1: str, s2: str) -> bool:",
+        "examples": [
+            {
+                "input": "string_permutation_checker(\"abc\", \"bca\")",
+                "output": "True"
+            },
+            {
+                "input": "string_permutation_checker(\"abc\", \"def\")",
+                "output": "False"
+            },
+            {
+                "input": "string_permutation_checker(\"listen\", \"silent\")",
+                "output": "True"
+            },
+            {
+                "input": "string_permutation_checker(\"hello\", \"bello\")",
+                "output": "False"
+            },
+            {
+                "input": "string_permutation_checker(\"\", \"\")",
+                "output": "True"
+            },
+            {
+                "input": "string_permutation_checker(\"a\", \"\")",
+                "output": "False"
+            },
+            {
+                "input": "string_permutation_checker(\"Abc\", \"abc\")",
+                "output": "False"
+            },
+            {
+                "input": "string_permutation_checker(\"a gentleman\",\"elegant man\")",
+                "output": "True"
+            }
+        ]
+    },
+    {
+        "id": 12,
+        "level": 5,
+        "difficulty": "hard",
+        "name": "py_string_sculptor",
+        "file": "py_string_sculptor.py",
+        "description": {
+            "en": "Write a function that transforms a string by alternating the case of\nalphabetic characters only.\nNon-alphabetic characters remain unchanged and are NOT counted in the\nalternation index.\nThe first alphabetic character should be lowercase, the second uppercase, etc.\nSpaces reset the alternation (next alpha after a space is lowercase again).",
+            "de": "Schreibe eine Funktion, die einen String transformiert, indem nur alphabetische Zeichen abwechselnd groß/klein geschrieben werden. Nicht-alphabetische Zeichen bleiben unverändert und zählen nicht für die Abwechslung. Das erste alphabetische Zeichen soll klein, das zweite groß, das dritte klein usw. sein.",
+            "fr": "Écris une fonction qui transforme une chaîne en alternant la casse des seuls caractères alphabétiques. Les autres caractères restent inchangés et ne comptent pas pour l’alternance. Le premier caractère alphabétique doit être en minuscule, le second en majuscule, le troisième en minuscule, etc.",
+            "es": "Escribe una funciГіn que transforme una cadena alternando mayГєsculas y minГєsculas solo en caracteres alfabГ©ticos. Los demГЎs permanecen igual y no cuentan para la alternancia. El primer carГЎcter alfabГ©tico debe ser minГєscula, el segundo mayГєscula, el tercero minГєscula, y asГ­ sucesivamente.",
+            "it": "Scrivi una funzione che trasformi una stringa alternando maiuscole e minuscole solo per i caratteri alfabetici. Gli altri restano invariati e non contano per l’alternanza. Il primo carattere alfabetico deve essere minuscolo, il secondo maiuscolo, il terzo minuscolo, e così via."
+        },
+        "signature": "def string_sculptor(text: str) -> str:",
+        "examples": [
+            {
+                "input": "string_sculptor(\"hello\")",
+                "output": "\"hElLo\""
+            },
+            {
+                "input": "string_sculptor(\"Hello World\")",
+                "output": "\"hElLo wOrLd\""
+            },
+            {
+                "input": "string_sculptor(\"abc123def\")",
+                "output": "\"aBc123DeF\""
+            },
+            {
+                "input": "string_sculptor(\"Python3.9!\")",
+                "output": "\"pYtHoN3.9!\""
+            },
+            {
+                "input": "string_sculptor(\"\")",
+                "output": "\"\""
+            }
+        ]
+    },
+    {
+        "id": 13,
+        "level": 5,
+        "difficulty": "hard",
+        "name": "py_twist_sequence",
+        "file": "py_twist_sequence.py",
+        "description": {
+            "en": "Write a function that rotates an array to the right by k positions.\nRotating right by k means the last k elements move to the front.",
+            "de": "Write a function that rotates an array to the right by k positions, rotating right by k means the last k elements move to the front.",
+            "fr": "Write a function that rotates an array to the right by k positions, rotating right by k means the last k elements move to the front.",
+            "es": "Write a function that rotates an array to the right by k positions, rotating right by k means the last k elements move to the front.",
+            "it": "Write a function that rotates an array to the right by k positions, rotating right by k means the last k elements move to the front."
+        },
+        "signature": "def twist_sequence(arr: list[int], k: int) -> list[int]:",
+        "examples": [
+            {
+                "input": "twist_sequence([1,2,3,4,5], 2)",
+                "output": "[4,5,1,2,3]"
+            },
+            {
+                "input": "twist_sequence([1,2,3], 1)",
+                "output": "[3,1,2]"
+            },
+            {
+                "input": "twist_sequence([1,2,3,4], 0)",
+                "output": "[1,2,3,4]"
+            },
+            {
+                "input": "twist_sequence([1,2,3], 5)",
+                "output": "[2,3,1]"
+            },
+            {
+                "input": "twist_sequence([], 3)",
+                "output": "[]"
+            }
+        ]
+    },
+    {
+        "id": 14,
+        "level": 6,
+        "difficulty": "hard",
+        "name": "py_whisper_cipher",
+        "file": "py_whisper_cipher.py",
+        "description": {
+            "en": "Write a function that creates a Caesar cipher by shifting letters in a\nstring by a given amount.\nNon-alphabetic characters should remain unchanged.\nThe shift can be negative (shift left).",
+            "de": "Schreibe eine Funktion, die eine einfache Verschlüsselung erzeugt, indem Buchstaben in einem String um einen gegebenen Betrag verschoben werden. Nicht-alphabetische Zeichen bleiben unverändert.",
+            "fr": "Écris une fonction qui réalise un chiffrement simple en décalant les lettres d’une chaîne d’un montant donné. Les caractères non alphabétiques restent inchangés.",
+            "es": "Escribe una funciГіn que cree un cifrado simple desplazando las letras de una cadena una cantidad dada. Los caracteres no alfabГ©ticos deben permanecer iguales.",
+            "it": "Scrivi una funzione che crei una cifratura semplice spostando le lettere di una stringa di una quantitГ  data. I caratteri non alfabetici restano invariati."
+        },
+        "signature": "def whisper_cipher(text: str, shift: int) -> str:",
+        "examples": [
+            {
+                "input": "whisper_cipher(\"hello\", 3)",
+                "output": "\"khoor\""
+            },
+            {
+                "input": "whisper_cipher(\"Hello World!\", 1)",
+                "output": "\"Ifmmp Xpsme!\""
+            },
+            {
+                "input": "whisper_cipher(\"xyz\", 3)",
+                "output": "\"abc\""
+            },
+            {
+                "input": "whisper_cipher(\"ABC123def\", 5)",
+                "output": "\"FGH123ijk\""
+            },
+            {
+                "input": "whisper_cipher(\"\", 10)",
+                "output": "\"\""
+            },
+            {
+                "input": "whisper_cipher(\"abc\", -3)",
+                "output": "\"xyz\""
+            }
+        ]
+    }
+]

examshell_python-0.1.0/src/examshell/main.py

@@ -0,0 +1,326 @@
+from .models import Task
+from .task_generator import TaskManager
+
+from rich.console import Console
+from rich.panel import Panel
+
+from rich.prompt import Prompt
+from rich.table import Table
+
+from rich.progress import Progress, BarColumn, TextColumn
+from rich.align import Align
+
+from rich import box
+
+console = Console()
+
+
+def choose_mode() -> bool:
+    console.clear()
+    console.print(
+        Panel.fit(
+            "[bold cyan]Real mode[/bold cyan] [dim](1)[/dim]\n"
+            "[bold yellow]Practice mode[/bold yellow] [dim](2)[/dim]",
+            title="[bold]Choose your Exam mode[/bold]",
+            border_style="cyan",
+        )
+    )
+    mode = Prompt.ask(
+        "Your answer", choices=["1", "2"], show_choices=False
+    )
+    return mode == "1"
+
+
+def points_bar(points: int, total: int = 100) -> Progress:
+    progress = Progress(
+        TextColumn("[bold]Progress[/bold]"),
+        BarColumn(bar_width=40),
+        TextColumn(f"[bold green]{points}[/bold green]/{total}"),
+    )
+    progress.add_task("points", total=total, completed=points)
+    return progress
+
+
+def real_mode_screen(manager: TaskManager, task: Task) -> None:
+    upld_path = manager.path / "rendu" / task.name / task.file
+
+    console.print(
+        Panel.fit(
+            "[bold]Welcome to the exam[/bold]",
+            border_style="cyan",
+            box=box.HEAVY,
+        )
+    )
+    console.rule(f"[bold cyan]{task.name}[/bold cyan]", style="cyan")
+    console.print(points_bar(manager.points))
+
+    info = Table.grid(padding=(0, 1))
+    info.add_column(style="bold")
+    info.add_column()
+    info.add_row("Level:", str(manager.current_level))
+    info.add_row("Upload to:", f"[italic]{upld_path}[/italic]")
+    console.print(info)
+
+    commands = Table(
+        title="Commands",
+        box=box.SIMPLE,
+        show_header=False,
+        title_style="bold magenta",
+    )
+    commands.add_column(style="bold green")
+    commands.add_column(style="dim")
+    commands.add_row("grademe", "check the answer")
+    commands.add_row("status", "show this message again")
+    commands.add_row("finish", "finish the exam")
+    console.print(commands)
+
+
+def grademe(manager: TaskManager, task: Task) -> Task:
+    check = manager.check_task()
+
+    if check:
+        manager.points += 16
+        manager.current_level += 1
+
+        if manager.points >= 100:
+            console.print(
+                Panel.fit(
+                    Align.center(
+                        f"[bold green]You passed the exam"
+                        f", congratulations![/bold green]\n"
+                        f"[bold]{manager.points}/100[/bold]"
+                    ),
+                    border_style="green",
+                    box=box.DOUBLE,
+                )
+            )
+            raise SystemExit(0)
+
+        console.print(
+            Panel(
+                f"[bold green]Task passed +16 points[/bold green] "
+                f"({manager.points}/100)",
+                border_style="green",
+            )
+        )
+
+        next_task = manager.get_next_task()
+        if next_task is None:
+            console.print(
+                Panel.fit(
+                    Align.center(
+                        "[bold yellow]No more tasks left.[/bold yellow]\n"
+                        f"[bold]Final score: {manager.points}/100[/bold]"
+                    ),
+                    border_style="yellow",
+                    box=box.DOUBLE,
+                )
+            )
+            raise SystemExit(0)
+
+        return next_task
+    else:
+        console.print(
+            Panel(
+                "[bold red]Failed.[/bold red] You can retry",
+                border_style="red",
+            )
+        )
+        return task
+
+
+def real_mode() -> None:
+    manager = TaskManager()
+    task = manager.get_next_task()
+
+    if task is None:
+        console.clear()
+        console.print(
+            Panel(
+                "[bold red]No tasks available to start the exam.[/bold red]",
+                border_style="red",
+            )
+        )
+        raise SystemExit(1)
+
+    console.clear()
+    manager.create_task_files()
+    real_mode_screen(manager, task)
+
+    while True:
+        user_input = Prompt.ask(
+            "[bold cyan]exam42[/bold cyan]",
+        ).strip()
+
+        match user_input:
+            case "status":
+                console.clear()
+                real_mode_screen(manager, task)
+            case "grademe":
+                console.clear()
+                real_mode_screen(manager, task)
+                task = grademe(manager, task)
+                manager.create_task_files()
+            case "finish":
+                console.clear()
+                console.print("[yellow]Exam finished by user.[/yellow]")
+                raise SystemExit(0)
+            case _:
+                console.clear()
+                real_mode_screen(manager, task)
+                console.print(f"[red]Unknown command:[/red] {user_input!r}")
+
+
+def task_list_table(manager: TaskManager) -> Table:
+    table = Table(title="Available tasks", header_style="bold magenta")
+    table.add_column("#", justify="right")
+    table.add_column("Name")
+    table.add_column("Level", justify="center")
+
+    for idx, task in enumerate(manager.data, start=1):
+        table.add_row(str(idx), task.name, str(task.level))
+
+    return table
+
+
+def practice_mode_screen(manager: TaskManager, task: Task) -> None:
+    upld_path = manager.path / "rendu" / task.name / task.file
+
+    console.print(
+        Panel.fit(
+            "[bold]Welcome to practice mode[/bold]",
+            border_style="yellow",
+            box=box.HEAVY,
+        )
+    )
+    console.rule(f"[bold yellow]{task.name}[/bold yellow]", style="yellow")
+
+    info = Table.grid(padding=(0, 1))
+    info.add_column(style="bold")
+    info.add_column()
+    info.add_row("Level:", str(task.level))
+    info.add_row("Upload to:", f"[italic]{upld_path}[/italic]")
+    console.print(info)
+
+    commands = Table(
+        title="Commands",
+        box=box.SIMPLE,
+        show_header=False,
+        title_style="bold magenta",
+    )
+    commands.add_column(style="bold yellow")
+    commands.add_column(style="dim")
+    commands.add_row("grademe", "check the answer")
+    commands.add_row("list", "show all available tasks")
+    commands.add_row("choose", "pick a task by number")
+    commands.add_row("skip", "move to the next task in order")
+    commands.add_row("status", "show this message again")
+    commands.add_row("finish", "finish practice")
+    console.print(commands)
+
+
+def choose_task(manager: TaskManager) -> Task:
+    console.print(task_list_table(manager))
+
+    numbers = [str(i) for i in range(1, len(manager.data) + 1)]
+    choice = Prompt.ask(
+        "Pick a task number", choices=numbers, show_choices=False
+    )
+
+    task = manager.data[int(choice) - 1]
+    manager.set_current_task(task)
+    return task
+
+
+def practice_mode() -> None:
+    console.clear()
+    console.print(
+        Panel.fit(
+            "[bold]Welcome to practice mode[/bold]",
+            border_style="yellow",
+            box=box.HEAVY,
+        )
+    )
+
+    manager = TaskManager(real_mode=False)
+
+    console.print("[dim]Pick a task to start with.[/dim]")
+    task = choose_task(manager)
+
+    console.clear()
+    manager.create_task_files()
+    practice_mode_screen(manager, task)
+
+    while True:
+        user_input = Prompt.ask(
+            "[bold yellow]practice42[/bold yellow]",
+        ).strip()
+
+        match user_input:
+            case "status":
+                console.clear()
+                practice_mode_screen(manager, task)
+            case "list":
+                console.clear()
+                practice_mode_screen(manager, task)
+                console.print(task_list_table(manager))
+            case "choose":
+                console.clear()
+                practice_mode_screen(manager, task)
+                task = choose_task(manager)
+                manager.create_task_files()
+                console.clear()
+                practice_mode_screen(manager, task)
+            case "skip":
+                next_task = manager.get_next_task()
+                console.clear()
+                if next_task is None:
+                    practice_mode_screen(manager, task)
+                    console.print(
+                        Panel(
+                            "[yellow]No more tasks after this one.[/yellow]",
+                            border_style="yellow",
+                        )
+                    )
+                else:
+                    task = next_task
+                    manager.create_task_files()
+                    practice_mode_screen(manager, task)
+            case "grademe":
+                console.clear()
+                practice_mode_screen(manager, task)
+                check = manager.check_task()
+                if check:
+                    console.print(
+                        Panel(
+                            "[bold green]Correct! Well done.[/bold green]",
+                            border_style="green",
+                        )
+                    )
+                else:
+                    console.print(
+                        Panel(
+                            "[bold red]Failed.[/bold red] You can retry",
+                            border_style="red",
+                        )
+                    )
+            case "finish":
+                console.clear()
+                console.print("[yellow]Practice finished by user.[/yellow]")
+                raise SystemExit(0)
+            case _:
+                console.clear()
+                practice_mode_screen(manager, task)
+                console.print(f"[red]Unknown command:[/red] {user_input!r}")
+
+
+def cli() -> None:
+    real = choose_mode()
+    if real:
+        real_mode()
+    else:
+        practice_mode()
+
+
+if __name__ == "__main__":
+    cli()

examshell_python-0.1.0/src/examshell/models.py

@@ -0,0 +1,25 @@
+from pydantic import BaseModel
+
+
+class Description(BaseModel):
+    en: str
+    de: str
+    fr: str
+    es: str
+    it: str
+
+
+class Example(BaseModel):
+    input: str
+    output: str
+
+
+class Task(BaseModel):
+    id: int
+    level: int
+    difficulty: str
+    name: str
+    file: str
+    description: Description
+    signature: str
+    examples: list[Example]

examshell_python-0.1.0/src/examshell/task_generator.py

@@ -0,0 +1,213 @@
+import ast
+import json
+
+import random
+from .models import Task
+
+from pydantic import TypeAdapter
+
+from pathlib import Path
+import importlib.util
+
+from rich.console import Console
+from rich.panel import Panel
+
+from rich.table import Table
+
+console = Console()
+
+
+def get_tasks() -> list[Task]:
+    adapter = TypeAdapter(list[Task])
+    with open("data.json", "r", encoding="utf-8") as f:
+        return adapter.validate_python(json.load(f))
+
+
+class TaskManager:
+    def __init__(self, real_mode: bool = True):
+        self.data = sorted(get_tasks(), key=lambda a: a.level)
+        self.real_mode = real_mode
+        self.points = 0
+        self.current_level = 1
+        self.current_task: int | None = None
+        self.path = self._create_folder()
+
+    def _create_folder(
+        self, path_str: str = "exam42", fallback: int = 1
+    ) -> Path:
+        path = Path(f"./{path_str}")
+        if path.exists():
+            return self._create_folder(
+                "exam42" + "-" + str(fallback), fallback=fallback + 1
+            )
+        path.mkdir(parents=True)
+        (path / "subjects").mkdir(parents=True)
+        (path / "rendu").mkdir(parents=True)
+        return path
+
+    def get_next_task(self) -> Task:
+        if self.real_mode:
+            return self._get_task_by_real_mode()
+        else:
+            return self._get_next_task()
+
+    def get_data_by_level(self, level) -> list[Task]:
+        data = []
+        for d in self.data:
+            if d.level == level:
+                data.append(d)
+        return data
+
+    def get_task_by_id(self, id) -> Task | None:
+        for t in self.data:
+            if t.id == id:
+                return t
+
+    def set_current_task(self, task: Task) -> None:
+        self.current_task = task.id
+
+    def _get_task_by_real_mode(self) -> Task | None:
+        data = self.get_data_by_level(self.current_level)
+        if not data:
+            return None
+        task = random.choice(data)
+        self.current_task = task.id
+        return task
+
+    def _get_next_task(self) -> Task:
+        if not self.current_task:
+            self.current_task = self.data[0].id
+            return self.data[0]
+
+        task = self.get_task_by_id(self.current_task)
+        next_task_index = self.data.index(task) + 1
+
+        if next_task_index < len(self.data):
+            next_task = self.data[next_task_index]
+            self.current_task = next_task.id
+            return next_task
+
+        return None
+
+    def create_task_files(self):
+        task = self.get_task_by_id(self.current_task)
+        if not task:
+            raise FileExistsError()
+
+        path_subject = self.path / "subjects" / task.name
+        if not path_subject.exists():
+            path_subject.mkdir(parents=True)
+
+        path_rendu = self.path / "rendu" / task.name
+        if not path_rendu.exists():
+            path_rendu.mkdir(parents=True)
+
+        text_examples = "\n\n"
+        for e in task.examples:
+            text_examples += e.input + "\n"
+            text_examples += e.output + "\n\n"
+
+        for lang, text in task.description.model_dump().items():
+            file_name = f"{task.name}.{lang}.txt"
+            file_path = path_subject / file_name
+
+            with open(file_path, "w", encoding="utf-8") as f:
+                f.write(
+                    text + "\n\n" + task.signature + text_examples
+                )
+
+    def check_task(self) -> bool:
+        task = self.get_task_by_id(self.current_task)
+
+        file_path = self.path / "rendu" / task.name / task.file
+
+        console.rule(f"[bold cyan]Checking: {task.name}[/bold cyan]")
+
+        if not file_path.is_file():
+            console.print(
+                Panel(
+                    f"[red]File not found:[/red] {file_path}",
+                    title="[bold red]Error[/bold red]",
+                    border_style="red",
+                )
+            )
+            return False
+
+        module_name = task.file[:-3]
+
+        try:
+            spec = importlib.util.spec_from_file_location(
+                module_name, file_path
+            )
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+        except Exception as exc:
+            console.print(
+                Panel(
+                    f"[red]Failed to import module:[/red]\n{exc}",
+                    title="[bold red]Import error[/bold red]",
+                    border_style="red",
+                )
+            )
+            return False
+
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("Test", justify="right")
+        table.add_column("Input", overflow="fold")
+        table.add_column("Expected", overflow="fold")
+        table.add_column("Got", overflow="fold")
+        table.add_column("Status", justify="center")
+
+        all_passed = True
+
+        for idx, example in enumerate(task.examples, start=1):
+            try:
+                result = eval(example.input, vars(module))
+                expected_result = ast.literal_eval(example.output)
+
+                if result != expected_result:
+                    all_passed = False
+                    table.add_row(
+                        str(idx),
+                        example.input,
+                        repr(expected_result),
+                        f"[red]{result!r}[/red]",
+                        "[bold red]FAIL[/bold red]",
+                    )
+                else:
+                    table.add_row(
+                        str(idx),
+                        example.input,
+                        repr(expected_result),
+                        f"[green]{result!r}[/green]",
+                        "[bold green]OK[/bold green]",
+                    )
+            except Exception as exc:
+                all_passed = False
+                table.add_row(
+                    str(idx),
+                    example.input,
+                    example.output,
+                    f"[red]Exception: {exc}[/red]",
+                    "[bold red]ERROR[/bold red]",
+                )
+
+        console.print(table)
+
+        if all_passed:
+            console.print(
+                Panel(
+                    f"[bold green]All tests passed![/bold green] "
+                    f"({len(task.examples)}/{len(task.examples)})",
+                    border_style="green",
+                )
+            )
+        else:
+            console.print(
+                Panel(
+                    "[bold red]Some tests failed.[/bold red]",
+                    border_style="red",
+                )
+            )
+
+        return all_passed

examshell_python-0.1.0/src/examshell_python.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: examshell-python
+Version: 0.1.0
+Summary: Interactive 42-style exam practice shell for Python exercises
+Author: Denis
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.0
+Requires-Dist: rich>=13.0

examshell_python-0.1.0/src/examshell_python.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+src/examshell/__init__.py
+src/examshell/__main__.py
+src/examshell/config.py
+src/examshell/main.py
+src/examshell/models.py
+src/examshell/task_generator.py
+src/examshell/data/data.json
+src/examshell_python.egg-info/PKG-INFO
+src/examshell_python.egg-info/SOURCES.txt
+src/examshell_python.egg-info/dependency_links.txt
+src/examshell_python.egg-info/entry_points.txt
+src/examshell_python.egg-info/requires.txt
+src/examshell_python.egg-info/top_level.txt

examshell_python-0.1.0/src/examshell_python.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

examshell_python-0.1.0/src/examshell_python.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+examshell = examshell.main:cli

examshell_python-0.1.0/src/examshell_python.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pydantic>=2.0
+rich>=13.0

examshell_python-0.1.0/src/examshell_python.egg-info/top_level.txt

@@ -0,0 +1 @@
+examshell