docs/bac_a_sable.md

+---
+title: 🧸 Bac à sable
+---
+
+Un éditeur dans lequel faire des essais ...
+
+{{ IDE(MAX_SIZE=15) }}

docs/credits/credits.md

 ---
-author: Mireille Coilhac
-title: Crédits
+author: Votre nom
+title: 👏 Crédits
 ---
 
+Le site est hébergé par la forge des communs numériques éducatifs <a href="https://docs.forge.apps.education.fr/" target="_blank">
+<span aria-label="Avatar" aria-hidden="true" data-type="round" data-color="3" class="_avatar_k41ul_17 mx_BaseAvatar" style="--cpd-avatar-size: 16px;"><img loading="lazy" alt="" src="https://matrix.agent.education.tchap.gouv.fr/_matrix/media/v3/thumbnail/matrix.agent.education.tchap.gouv.fr/de0e2fe63b40dd452178360baa3ff29ba16d8b98?width=16&amp;height=16&amp;method=crop" crossorigin="anonymous" referrerpolicy="no-referrer" class="_image_k41ul_49" data-type="round" width="16px" height="16px"></span><span class="mx_Pill_text">Centre de documentation</span></a>
 
+![AEIF](../assets/images/logo_aeif_300.png){width=7%}    
+Le modèle du site a été créé par l'  [Association des enseignantes et enseignants d'informatique de France](https://aeif.fr/index.php/category/non-classe/){target="_blank"}.  
 
-Le site est construit avec [`mkdocs`](https://www.mkdocs.org/) et en particulier [`mkdocs-material`](https://squidfunk.github.io/mkdocs-material/), et surtout [Pyodide-Mkdocs-Theme](https://frederic-zinelli.gitlab.io/pyodide-mkdocs-theme/) pour la partie Python.
 
-😀 Un grand merci à Frédéric Zinelli, et Vincent-Xavier Jumel qui ont réalisé la partie technique de ce site. Merci également à Charles Poulmaire pour ses relectures attentives et ses conseils judicieux.
+Le site est construit avec [`mkdocs`](https://www.mkdocs.org/){target="_blank"} et en particulier [`mkdocs-material`](https://squidfunk.github.io/mkdocs-material/){target="_blank"}, et surtout [Pyodide-Mkdocs-Theme](https://frederic-zinelli.gitlab.io/pyodide-mkdocs-theme/){target="_blank"} pour la partie Python nécessaire pour les QCM.
+
+😀 Un grand merci à Frédéric Zinelli, et Vincent-Xavier Jumel qui ont réalisé la partie technique de ce site.   
+Merci également à Charles Poulmaire pour ses relectures attentives et ses conseils judicieux.
 

docs/somme/exo_somme.md → docs/exercice_deux_versions/exo_somme.md

 ---
 author: Votre nom
-title: Exercice avec code caché et deux versions
+title: Exercice avec du code caché et deux versions
 tags:
   - liste/tableau
 ---

docs/exercices_avec_dessins/arbre_tortue.py

+# --------- PYODIDE:env --------- #
+from js import document
+if "restart" in globals():
+    restart()
+
+def m_a_j(cible):
+    done()
+    document.getElementById(cible).innerHTML = Screen().html
+
+_cible = 'cible_3'
+
+# --------- PYODIDE:code --------- #
+from turtle import *
+setup(640, 480)  # pour définir la taille de la fenêtre
+speed(10)
+
+def arbre(l=100, n=5):
+    forward(l)
+    if n > 0:
+        left(45)
+        arbre(l/2, n-1)
+        right(90)
+        arbre(l/2, n-1)
+        left(45)
+    back(l)
+
+arbre(200, 5)
+
+# --------- PYODIDE:post --------- #
+if Screen().html is None:
+    forward(0)
+m_a_j(_cible)
+
+# --------- PYODIDE:post_term --------- #
+if "m_a_j" in globals():
+    m_a_j(_cible)

docs/exercices_avec_dessins/carre_cube_superposees.py

+# --- PYODIDE:env --- #
+
+import matplotlib.pyplot as plt         # Indispensable (provoque la déclaration de PyodidePlot)
+fig = PyodidePlot('cible_double')  
+fig.target()
+
+# --- PYODIDE:code --- #
+# L'import suivant a été fait dans du code caché : 
+# import matplotlib.pyplot as plt
+
+
+xs1 = [-3 + k * 0.1 for k in range(61)]
+ys1 = [x**2 for x in xs1]
+
+xs2 = [-2 + k * 0.1 for k in range(41)]
+ys2 = [x**3 for x in xs2]
+
+plt.plot(xs1, ys1, "r-", xs2, ys2, "b+")  
+plt.grid()  # Optionnel : pour voir le quadrillage
+plt.axhline()  # Optionnel : pour voir l'axe des abscisses
+plt.axvline()  # Optionnel : pour voir l'axe des ordonnées
+plt.title("La fonction carré et la fonction cube")
+plt.show()

docs/exercices_avec_dessins/dessiner.md

+---
+author: Mireille Coilhac
+title: Images  en Python
+---
+
+😊
+
+## I. Utiliser la bibliothèque matplotlib 
+
+### La fonction carré
+
+{{ IDE('fct_carre') }}
+
+{{ figure() }}
+
+### Les courbes de la fonction carré et de la fonction cube séparées
+
+{{ IDE('fct_carre_cube') }}
+ 
+{{ figure('cible_1') }}
+
+{{ figure('cible_2') }}
+
+### Les courbes de la fonction carré et de la fonction cube superposées
+
+{{ IDE('carre_cube_superposees') }}
+
+{{ figure('cible_double') }}
+
+
+
+## II. Utiliser la tortue par Romain Janvier
+
+
+???+ question "Utilisation de la tortue"
+
+    {{ IDE('arbre_tortue') }}
+
+    {{ figure('cible_3') }}
+
+
+

docs/exercices_avec_dessins/fct_carre.py

+# --- PYODIDE:env --- #
+
+# Un import de matplotlib en tout premier est indispensable, pour que la classe
+# PyodidePlot devienne disponible dans l'environnement:
+import matplotlib.pyplot as plt
+PyodidePlot().target()     # Cible la figure dans laquelle tracer la figure dans la page
+
+# --- PYODIDE:code --- #
+# L'import suivant a été fait dans du code caché : 
+# import matplotlib.pyplot as plt
+xs = [-3 + k * 0.1 for k in range(61)]
+ys = [x**2 for x in xs]
+plt.plot(xs, ys, "r-")
+plt.grid()  # Optionnel : pour voir le quadrillage
+plt.axhline()  # Optionnel : pour voir l'axe des abscisses
+plt.axvline()  # Optionnel : pour voir l'axe des ordonnées
+plt.title("La fonction carré")
+plt.show()

docs/exercices_avec_dessins/fct_carre_cube.py

+# --- PYODIDE:env --- #
+
+import matplotlib.pyplot as plt
+fig1 = PyodidePlot('cible_1')  
+fig2 = PyodidePlot('cible_2')
+
+# --- PYODIDE:code --- #
+# L'import suivant a été fait dans du code caché : 
+# import matplotlib.pyplot as plt
+
+fig1.target() # Pour tracer la fonction ci-dessous
+xs = [-3 + k * 0.1 for k in range(61)]
+ys = [x**2 for x in xs]
+plt.plot(xs, ys, "r-")
+plt.grid()  # Optionnel : pour voir le quadrillage
+plt.axhline()  # Optionnel : pour voir l'axe des abscisses
+plt.axvline()  # Optionnel : pour voir l'axe des ordonnées
+plt.title("La fonction carré")
+plt.show()
+
+fig2.target() # Pour tracer la fonction ci-dessous
+xs = [-2 + k * 0.1 for k in range(41)]
+ys = [x**3 for x in xs]
+plt.plot(xs, ys, "r-")
+plt.grid()  # Optionnel : pour voir le quadrillage
+plt.axhline()  # Optionnel : pour voir l'axe des abscisses
+plt.axvline()  # Optionnel : pour voir l'axe des ordonnées
+plt.title("La fonction cube")
+plt.show()

docs/index.md

-# Mon site
+---
+author: Votre nom
+title: 🏡 Accueil
+---
 
-Vous trouverez ...
+À vous de personnaliser cet accueil
 
-## titre 1
+!!! info "Adapter ce site modèle"
 
-leçons 
+    Le tutoriel est ici : [Tutoriel de site avec python](https://docs.forge.apps.education.fr/modeles/tutoriels/pyodide-mkdocs-theme-review/){:target="_blank" }
+    
+    Si vous voulez conserver certaines pages de ce modèles sans qu'elles ne soient visibles dans le menu, il suffit de les enlever du fichier .pages   
+    Vous les retrouverez facilement en utilisant la barre de recherche en haut à droite
 
-## titre 2
-
-autres leçons
+    Si vous voulez supprimer le lien vers le dépôt de votre site en haut à droite : ![lien_depot](assets/images/aller_depot.png){ width=5%}   
+    👉 les explications sont ici : [Tutoriel : votre propre contenu](https://docs.forge.apps.education.fr/modeles/tutoriels/pyodide-mkdocs-theme-review/08_tuto_fork/1_fork_projet/#iii-votre-propre-contenu){:target="_blank" }
+    
 
 😊  Bienvenue !
 
+_Dernière MAJ le 11/03/2025_
+
 
 
 

docs/python_imbrique/questions_imbriquees.md

 ---
 author: Votre nom
-title: Exercice plusieurs questions Python imbriquées
+title: Exercice avec plusieurs questions Python imbriquées
 tags:
   - modulo
   - liste/tableau

docs/qcm_1/autres_qcm.md

 ---
 author: Mireille
-title: Essais de qcm
+title: Ecrire des QCM
 tags:
   - qcm
   - Difficulté **
 ---
 
+Pour créer **très facilement de façon automatique** ce fichier, suivre ce lien : [Création de QCM : générer le fichier .json automatiquement](https://frederic-zinelli.gitlab.io/pyodide-mkdocs-theme/redactors/qcm_builder/){ .md-button target="_blank" rel="noopener" }. 
 
+{{ multi_qcm('qcm_exemple.json') }}
 
-## Multi QCM original ancien Pyodide
-
-
-{{multi_qcm(
-["Quelle est la réponse à la question universelle ? Cocher deux réponses.", 
-["$6\\times 7$", "$\\int_0^{42} 1 dx$", "Je ne sais pas", " `#!py sum([i for i in range(10)])`", "La réponse D"], [1, 2]],
-["1 + 1 = ? Cocher deux réponses.",
-["Je ne sais pas", "2", "L'âge du capitaine", "10 en binaire"], [2, 4]]
-)}}
-
-
-## De Fred avec bug
-
-multi_qcm(
-    [
-"""
-On a saisi le code suivant :
-```python title=''
-n = 8
-while n > 1:
-    n = n/2
-```
-
-Que vaut `n` après l'exécution du code ?
-""",
-        [
-            "2.0",
-            "4.0",
-            "1.0",
-            "0.5",
-        ],
-        [3]
-    ],
-    [
-        "Quelle est la machine qui va exécuter un programme JavaScript inclus dans une page HTML ?",
-        [
-            "La machine de l’utilisateur sur laquelle s’exécute le navigateur web.",
-            "La machine de l’utilisateur ou du serveur, selon celle qui est la plus disponible.",
-            "La machine de l’utilisateur ou du serveur, suivant la confidentialité des données manipulées.",
-            "Le serveur web sur lequel est stockée la page HTML."
-        ],
-        [1],
-    ],
-    [
-        """
-    Quelle expression permet d'accéder au numéro de Tournesol :
-    ```python title=''
-    repertoire = [{'nom': 'Dupont', 'tel': 5234}, {'nom': 'Tournesol', 'tel': 5248}, {'nom': 'Dupond', 'tel': 5237}]
-    ```
-        """,
-        [
-            "`#!py repertoire[1]['tel']`",
-            "`#!py repertoire['tel'][1]`",
-            "`#!py repertoire['Tournesol']`",
-            "`#!py repertoire['Tournesol']['tel']`",
-        ],
-        [1],
-        {'multi':True}
-    ],
-    multi = False,
-    qcm_title = "Un QCM avec mélange automatique des questions (bouton en bas pour recommencer)",
-    DEBUG = False,
-    shuffle = True,
-) 
-
-
-
-## De Fred autre essai
-
-{{ multi_qcm(
-    [
-"""
-On a saisi le code suivant :
-```python title=''
-n = 8
-while n > 1:
-    n = n/2
-```
-
-Que vaut `n` après l'exécution du code ?
-""",
-        [
-            "2.0",
-            "4.0",
-            "1.0",
-            "0.5",
-        ],
-        [3]
-    ],
-    [
-        "Quelle est la machine qui va exécuter un programme JavaScript inclus dans une page HTML ?",
-        [
-            "La machine de l’utilisateur sur laquelle s’exécute le navigateur web.",
-            "La machine de l’utilisateur ou du serveur, selon celle qui est la plus disponible.",
-            "La machine de l’utilisateur ou du serveur, suivant la confidentialité des données manipulées.",
-            "Le serveur web sur lequel est stockée la page HTML."
-        ],
-        [1],
-    ],
-    [
-"""
-Quelle expression permet d'accéder au numéro de Tournesol :
-```python title=''
-repertoire = [{'nom': 'Dupont', 'tel': 5234}, {'nom': 'Tournesol', 'tel': 5248}, {'nom': 'Dupond', 'tel': 5237}]
-```
-""",
-        [
-            "`#!py repertoire[1]['tel']`",
-            "`#!py repertoire['tel'][1]`",
-            "`#!py repertoire['Tournesol']`",
-            "`#!py repertoire['Tournesol']['tel']`",
-        ],
-        [1],
-        {'multi':True}
-    ],
-    multi = False,
-    qcm_title = "Un QCM avec mélange automatique des questions (bouton en bas pour recommencer)",
-    DEBUG = False,
-    shuffle = True,
-) }}

docs/qcm_1/qcm_exemple.json

+{
+    "questions": [
+      [
+        "```python title=\"\"\nn = 8\nwhile n > 1:\n    n = n/2\n```\n\nQue vaut `n` après l'exécution du code ?",
+        [
+          "0.5",
+          "1.0",
+          "2.0",
+          "4.0"
+        ],
+        [2]
+      ],
+      [
+        "`meubles = ['Table', 'Commode', 'Armoire', 'Placard', 'Buffet']`\n\nCocher toutes les bonnes réponses.",
+        [
+          "`meubles[-1]` vaut `'Buffet'`",
+          "`meubles[1]` vaut `'Table'`",
+          "`meubles[1]` vaut `'Commode'`"
+        ],
+        [1,3],
+        {"multi":true}
+      ]
+    ],
+    "description": "QCM Exemple",
+    "shuffle": true
+  }
+  
\ No newline at end of file

docs/qcm_1/qcm_premiere.md

----
-author: Mireille
-title: QCM 1
-tags:
-  - qcm
-  - Difficulté **
----
-
-{{ multi_qcm(
-    [
-"""On donne la table de vérité suivante :
-
-|a|b|?|
-|:----:|:----:|:----:|
-|F|F|V|
-|F|V|V|
-|V|F|V|
-|V|V|F|
-
-A quelle expression logique correspond cette table de vérité
-""",
-        [
-            "NON (a OU b)",
-            "a OU b",
-            "a ET b",
-            "NON (a ET b)",
-        ],
-        [4],
-    ],
-    [
-        "Le résultat de l'addition des deux nombres binaires 1101 et 0101 est:",
-        [
-            "10110",
-            "11010",
-            "10010",
-            "10011",
-        ],
-        [3],
-    ],
-    [
-        "Donner l'écriture binaire du nombre 34",
-        [
-            "100001",
-            "100110",
-            "100010",
-            "010010",
-        ],
-        [3],
-    ],
-    [
-"""Le réel $x$ est représenté par le code suivant avec la norme IEEE 764 :
-1 10001000110 1010 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
-On rappelle que $x=(-1)^s . m . 2^{e-1023}$ avec $s$ le bit de signe, $e$ codé sur 11 bits, $m=1,f$   avec $f$ codé sur 52 bits.
-Le réel $x$ est égal à :
-""",
-        [
-            "$-1,625 . 2^{71}$",
-            "$-1,625 . 10^{71}$",
-            "$1,625 . 2^{72}$",
-            "$1,625 . 10^{71}$",
-            "$-1,625 . 2^{72}$",
-            "Autre réponse",
-        ],
-        [1],
-    ],
-    [
-"""
-On a saisi le code suivant :
-```python title=''
-n = 8
-while n > 1:
-    n = n / 2
-```
-
-Que vaut `n` après l'exécution du code ?
-""",
-        [
-            "2.0",
-            "4.0",
-            "1.0",
-            "0.5",
-        ],
-        [3],
-    ],
-    [
-        "Que vaut :  `#!py [(a,b) for a in range(1, 3) for b in range(a)]`",
-        [
-            "`#!py [(1, 0), (2, 1), (2, 1)]`",
-            "`#!py [(1, 0), (2, 0), (2, 1)]`",
-            "`#!py [(1, 0), (2, 1), (3, 2)]`",
-            "`#!py [(0, 0), (1, 1), (2, 2)]`",
-        ],
-        [2],
-    ],
-    [
-"""
-On a saisi le code suivant :
-
-```python title=''
-def mystere(a, b):
-    reponse = 1
-    if a == 0:
-        if b == 0:
-            reponse = 0
-    return reponse
-```
-
-A quoi est évalué `#!py mystere(0, 1)` ?
-""",
-        [
-            "`#!py 0`",
-            "`#!py False`",
-            "`#!py True`",
-            "`#!py 1`",
-        ],
-        [4],
-    ],
-    [
-"""
-On définit un tableau `#!py t` rempli de 0 en langage Python. Ce tableau est une liste de listes, toutes les sous-listes ayant le même nombre d'éléments.
-
-```python title=''
-t = [ [0, 0, …, 0],
-      [0, 0, …, 0],
-      …
-      [0, 0, …, 0]]
-```
-
-On appelle `#!py h` le nombre de listes contenus dans `#!py t`et `#!py l` le nombre d'éléments appartenant à ces listes.
-Parmi les propositions suivantes, laquelle permet de calculer `#!py h` et `#!py l` ?
-""",
-        [
-            "`#!py h, l = len(t[0]), len(t)`",
-            "`#!py h, l = len(t), len(t[0])`",
-            "`#!py h, l = len(t[0]), len(t[1])`",
-            "`#!py h, l = len(t[1]), len(t[0])`",
-        ],
-        [2],
-    ],
-    [
-"""
-`#!py liste_eleves` est une liste de listes contenant les notes d’élèves.
-Le premier élément de chaque liste de `#!py liste_eleves` est le nom de l’élève, le deuxième est sa note au premier devoir et le troisième sa note au deuxième devoir.
-
-Quel code python permet d’obtenir la liste des noms des élèves ayant eu strictement plus de 15 au deuxième devoir ?
-""",
-        [
-            "`#!py [eleve[0] in liste_eleves if eleve[2] > 15]`",
-            "`#!py [eleve for eleve in liste_eleves if eleve[2] > 15]`",
-            "`#!py [eleve[0] for eleve in liste_eleves if eleve[2] > 15]`",
-            "`#!py [eleve for eleve in liste_eleves if eleve[3] > 15]`",
-        ],
-        [3],
-    ],
-    [
-"""
-On dispose du dictionnaire suivant : `#!py tel = {'Bill': '06 05 04 03 02', 'Roger': '06 12 11 13 20'}`
-
-Comment obtenir la liste des numéros de téléphones ?
-""",
-        [
-            "`#!py list(tel.items())`",
-            "`#!py list(tel)`",
-            "`#!py list(tel.values())`",
-            "`#!py list(tel.keys())`",
-            "Autre réponse",
-        ],
-        [3],
-    ],
-    [
-"""
-On a :
-
-```python title=''
-animaux = ['Chat', 'Cochon', 'Chien', 'Canard', 'Vache']
-effectif = [3, 8, 5, 9, 1]
-groupe = [animaux, effectif]
-```
-
-Que vaut `#!py groupe[1][3]` ?
-""",
-        [
-            "`#!py 9`",
-            "`#!py 'Chien'`",
-            "`#!py 'Canard'`",
-            "`#!py 5`",
-        ],
-        [1],
-    ],
-    [
-"""
-Dans la définition suivante de la fonction `#!py somme` en Python, quelle est l’instruction à ajouter pour que la valeur renvoyée par l’appel `#!py somme([10 , 11 , 12 , 13 , 14])` soit 60 ?
-
-```python title=''
-def somme (tab):
-   s = 0
-   for ind in range(len(tab)):
-      ...
-   return s
-```
-""",
-        [
-            "`#!py s = s + tab[ind]`",
-            "`#!py s = tab[ind]`",
-            "`#!py s = s + ind`",
-            "`#!py tab [ind] = tab[ind] + s`",
-        ],
-        [1],
-    ],
-    [
-"""
-Voici un dictionnaire de langues :
-`#!py dico = {'anglais':'english', 'allemand':'deutsch', 'breton':'brezhoneg'}`
-
-On souhaite ajouter une langue en plus et obtenir le dictionnaire suivant :
-`#!py dico = {'anglais':'english', 'allemand':'deutsch', 'breton':'brezhoneg', 'espagnol':'español'`
-
-
-Quelle instruction permet d'ajouter l'élément `#!py 'espagnol':'español'` dans le dictionnaire ?
-""",
-        [
-            "`#!py dico.append('espagnol':'español')`",
-            "`#!py dico['espagnol'] = 'español'`",
-            "`#!py dico += ['espagnol':'español']`",
-            "Ce n'est pas possible car un dictionnaire n'est pas modifiable",
-        ],
-        [2],
-    ],
-    [
-"""
-Que s'affiche-t-il si l'on exécute le script suivant ?
-
-```python title=''
-l = [0, 1, 2]
-m = [3, 4, 5]
-n = [l[i] + m[i] for i in range(len(l))]
-print(n)
-```
-""",
-        [
-            "Erreur",
-            "`#!py [3, 5, 7, 9]`",
-            "`#!py [0, 1, 2, 3, 4, 5]`",
-            "`#!py [3, 5, 7]`",
-        ],
-        [4],
-    ],
-    [
-"""
-Voici un extrait de la liste `#!py personnes`
-
-```python title=''
-personnes = [{'prénom': 'Marius', 'ville': 'Paris'},
-             {'prénom': 'Nassim', 'ville': 'Angers'},
-             {'prénom': 'Eléa', 'ville': 'Nantes'},
-             ...
-            ]
-```
-
-Quelles instructions permettent de donner la liste des prénoms des personnes nées à Rouen?
-""",
-        [
-            "`#!py [p['prénom'] for p in personnes if p['ville'] == 'Rouen']`",
-            "`#!py [personnes['prénom'] for p in personnes if personnes['ville'] == personnes['Rouen']]`",
-            "`#!py [p['prénom'] for p in personnes if if p['ville'] == p['Rouen']]`",
-            "`#!py [prénom for p in personnes if p['ville'] == 'Rouen']`",
-            "Autre réponse",
-        ],
-        [1],
-    ],
-    [
-"""
-    Quelle expression permet d'accéder au numéro de Tournesol :
-    ```python title=''
-    repertoire = [{'nom': 'Dupont', 'tel': 5234}, {'nom': 'Tournesol', 'tel': 5248}, {'nom': 'Dupond', 'tel': 5237}]
-    ```
-""",
-        [
-            "`#!py repertoire[1]['tel']`",
-            "`#!py repertoire['tel'][1]`",
-            "`#!py repertoire['Tournesol']`",
-            "`#!py repertoire['Tournesol']['tel']`",
-        ],
-        [1],
-    ],
-    [
-"""
-On considère la liste de p-uplets suivante :
-```python title=''
-table = [ ('Grace', 'Hopper', 'F', 1906),
-('Tim', 'Berners-Lee', 'H', 1955),
-('Ada', 'Lovelace', 'F', 1815),
-('Alan', 'Turing', 'H', 1912) ]
-```
-
-où chaque p-uplet représente un informaticien ou une informaticienne célèbre ; le premier élément est son prénom, le deuxième élément son nom, le troisième élément son sexe (‘H’ pour un homme, ‘F’ pour une femme) et le quatrième élément son année de naissance (un nombre entier entre 1000 et 2000).
-
-On définit une fonction :
-```python title=''
-def fonction_mystere(table):
-    mystere = []
-    for ligne in table:
-        if ligne[2] == 'F':
-            mystere.append(ligne[1])
-    return mystere
-```
-
-Que vaut `#!py fonction_mystere(table)`?
-""",
-        [
-            "`#!py ['Hopper', 'Lovelace']`",
-            "`#!py []`",
-            "`#!py [('Grace', 'Hopper', 'F', 1906), ('Ada', 'Lovelace', 'F', 1815)]`",
-            "`#!py [‘Grace’, ‘Ada’]`",
-            "Autre réponse",
-        ],
-        [1],
-    ],
-    [
-"""
-On donne ci-dessous le début du tableau `#!py personnes`
-```python title=''
-personnes = [{'prénom': 'Marius', 'ville': 'Paris', 'année': '2004'},
-             {'prénom': 'Nassim', 'ville': 'Angers', 'année': '1972'},
-             {'prénom': 'Eléa', 'ville': 'Nantes', 'année': '1993'},
-             ...
-            ]
-```
-
-Quelle instruction permet de construire un tableau t contenant les prénoms de toutes les personnes nées en 2001 ?
-""",
-        [
-            "`#!py t = [if p['année'] == '2001': p['prénom']]`",
-            "`#!py t = [personnes if p['année'] == '2001']`",
-            "`#!py t = [p for p in personnes if p['année'] == '2001']`",
-            "`#!py t = [p['prénom'] for p in personnes if p['année'] == '2001']`",
-            "Autre réponse",
-        ],
-        [4],
-    ],
-    [
-"""
-La fonction suivante doit calculer la moyenne d'un tableau de nombres, passé en paramètre. Avec quelles expressions faut-il compléter l'écriture pour que la fonction soit correcte ?
-```python title=''
-def moyenne(tableau) :
-     total = ...
-     for valeur in tableau :
-          total = total + valeur
-     return total / .....
-```
-""",
-        [
-            "1 et `#!py len(tableau)`",
-            "1 et `#!py len(tableau) + 1`",
-            "0 et `#!py len(tableau)`",
-            "0 et `#!py len(tableau) + 1`",
-            "Autre réponse",
-        ],
-        [3],
-    ],
-    [
-        "Quel type de serveur associe un nom de domaine avec une adresse IP ?",
-
-        [
-            "un serveur FTP",
-            "un serveur HTTP",
-            "un serveur Web",
-            "un serveur DNS",
-            "Autre réponse",
-        ],
-        [4],
-    ],
-    multi = False,
-    qcm_title = "QCM de première",
-    ID = 2,
-    DEBUG = False,
-    shuffle = True
-) }}

docs/xtra/stylesheets/ajustements.css

@@ -47,3 +47,11 @@
     display: block;
     margin: 0 auto;
 }
+
+
+/*
+  Largeur de la page
+*/
+.md-grid {
+    max-width: 90%;
+}
\ No newline at end of file

infra/js-turtle.py

-import js
-import inspect
-from math import cos, sin, pi, sqrt, atan2
-import time
-
-class Turtle:
-
-	""" TODO : les indicateurs de position ne fonctionnent pas car on ne renvoie rien.
-	Par exemple, self.state fixe l'appel à self._xcor qui renvoie une donnée.
-	"""
-
-	def __init__(self, x = 0, y = 0, angle = 0):
-		self.x, self.y = x, y
-		self.angle = angle
-		self.init_angle = angle
-		self.pen_color = 'black'
-		self.fill_color = 'black'
-		self._pen_down = True
-		self.width = 3
-		self.canvas = js.document.querySelector('canvas')
-		self.ctx = js.document.querySelector('canvas').getContext("2d")
-		self.canvas_pt = js.document.getElementById('pointer')
-		self.ctx_pt = js.document.getElementById('pointer').getContext("2d")
-		self.__set_default()
-		self.state = list()     # queue
-		self.on_draw = 0
-		self.stamp_number = 0
-		self.fill = False
-		self._speed = 5
-		self._hide = False
-
-	def __set_default(self):
-		self.ctx.lineJoin = "miter"
-		self.ctx.lineCap = "round"
-		self.ctx.strokeStyle = self.pen_color
-		self.ctx.lineWidth = self.width
-		self.style = self.triangle
-
-	def _basic_pointer_draw(function):
-
-		def wrapper(self):
-			self.ctx_pt.clearRect(0, 0, self.canvas_pt.width, self.canvas_pt.height)
-			self.ctx_pt.beginPath()
-			function(self)
-			self.ctx_pt.fill()
-			self.ctx_pt.stroke()
-
-		return wrapper
-
-	def speed(self, number):
-		assert 0 <= number <= 10
-		self._speed = number
-
-	def rad2deg(self, angle):
-		return angle / pi *180
-
-	def deg2rad(self, angle):
-		return angle / 180 * pi
-
-	def hideturtle(self):
-		self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}""", "hide" : True})
-
-	def ht(self):
-		self.hideturtle()
-	
-	def _hideturtle(self, params):
-		self._hide = params['hide']
-
-	def showturtle(self):
-		self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}""", "hide" : False})
-
-	def st(self):
-		self.hideturtle()
-	
-	def _showturtle(self, params):
-		self._hide = params['hide']
-
-	def goto(self, x, y):
-		self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}""", "x" : x, "y" : y})
-
-	def _goto(self, params):
-		x, y = params["x"], params["y"]
-		if self._pen_down : 
-			self.ctx.beginPath()
-			self.ctx.moveTo(self.x, self.y)
-			self.ctx.lineTo(x, y)
-			self.ctx.stroke()
-		self.x, self.y = x, y
-		if (not self._hide): self.style()
-
-	def _get_parameters(self, x, y):
-		if y is not None : 
-			x2, y2 = x, y
-		elif isinstance(x, Turtle): 
-			x2, y2 = Turtle.x, Turtle.y 
-		else :
-			x2, y2 = x
-		return x2, y2
-
-	def towards(self, x, y = None):
-		""" Fonction à revoir ?"""
-		self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}""", "x" : x, "y" : y})
-
-	def _towards(self, params):
-		x2, y2 = self._get_parameters(params["x"], params["y"])
-		return (self.rad2deg(atan2(self.y-y2, self.x-x2)) + 180) % 360
-
-	def distance(self, x, y = None):
-		self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}""", "x" : x, "y" : y})
-
-	def _distance(self, x, y = None):
-		x2, y2 = self._get_parameters(params["x"], params["y"])
-		return sqrt((self.x-x2)**2 + (self.y-y2)**2)
-
-	def pencolor(self, r = None, g = None, b = None):
-		self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}""", "r" : r, "g" : g, "b" : b})
-
-	def _pencolor(self, params):
-		r, g, b = params["r"], params["g"], params["b"]
-		if isinstance(r, str) :
-			color = r
-		elif isinstance(r, tuple) :
-			rr, g, b = r
-			color = self.rgb2hex(rr, g, b)
-		elif g is not None and b is not None :
-			color = self.rgb2hex(r, g, b)
-		elif r is None:
-			return self.pen_color
-		self.pen_color = color
-		self.ctx.strokeStyle = color
-		self.ctx_pt.strokeStyle = color
-
-	def fillcolor(self, r = None, g = None, b = None):
-		self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}""", "r" : r, "g" : g, "b" : b})
-
-	def _fillcolor(self, params):
-		r, g, b = params["r"], params["g"], params["b"]
-		if isinstance(r, str) :
-			color = r
-		elif isinstance(r, tuple) :
-			rr, g, b = r
-			color = self.rgb2hex(rr, g, b)
-		elif g is not None and b is not None :
-			color = self.rgb2hex(r, g, b)
-		elif r is None:
-			return self.fill_color
-		self.fill_color = color
-		self.ctx.fillStyle = color
-		self.ctx_pt.fillStyle = color
-
-	def color(self, r1 = None, g1 = None, b1 = None, r2 = None, g2 = None, b2 = None):
-		self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}""", \
-							"r1" : r1, "g1" : g1, "b1" : b1, "r2" : r2, "g2" : g2, "b2" : b2 })
-
-	def _color(self, params):
-		r1, g1, b1 = params["r1"], params["g1"], params["b1"]
-		r2, g2, b2 = params["r2"], params["g2"], params["b2"]
-		if r1 is None and r2 is None:
-			return self.pen_color, self.fill_color
-		elif isinstance(r1, str) and isinstance(g1, str): 
-			new_pen_params = {"r" : r1, "g":None, "b": None}
-			new_fill_params = {"r" : g1, "g":None, "b": None}
-			self._pencolor(new_pen_params)
-			self._fillcolor(new_fill_params)
-		elif isinstance(r1, tuple) and isinstance(g1, tuple): 
-			new_pen_params = {"r" : r1, "g":None, "b": None}
-			new_fill_params = {"r" : g1, "g":None, "b": None}
-			self._pencolor(new_pen_params)
-			self._fillcolor(new_fill_params)
-		elif isinstance(r1, str) and g1 is None:
-			new_params = {"r" : r1, "g":None, "b": None}
-			self._pencolor(new_params)
-			self._fillcolor(new_params)
-		elif isinstance(r1, tuple) and g1 is None:
-			new_params = {"r" : r1, "g":None, "b": None}
-			self._pencolor(new_params)
-			self._fillcolor(new_params)
-		elif r1 is not None and g1 is not None and b1 is not None and r2 is None: 
-			new_params = {"r" : r1, "g":g1, "b": b1}
-			self._pencolor(new_params)
-			self._fillcolor(new_params)
-
-	#def _determine_colors(self, r, g, b):
-
-	def rgb2hex(self, r, g, b):
-		for i in [r, g, b]:
-			assert 0 <= i <= 255, "Wrong color code"
-		return '#%02x%02x%02x' % (r, g, b)
-
-	def pensize(self, width = None):
-		self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}""", "width" : width })
-
-	def width(self, width = None):
-		self.pensize(width)
-
-	def _pensize(self, params):
-		width = params["width"]
-		if (width is None): return self.ctx.lineWidth
-		self.ctx.lineWidth = width
-
-	def pendown(self):
-		self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}"""})
-
-	def pd(self):
-		self.pendown()
-
-	def down(self):
-		self.pendown()
-
-	def _pendown(self, params):
-		self._pen_down = True
-
-	def penup(self):
-		self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}"""})
-
-	def up(self):
-		self.penup()
-
-	def pu(self):
-		self.penup()
-
-	def _penup(self, params):
-		self._pen_down = False
-
-	def shape(self, style = None):
-		self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}""", "sh" : style})
-	
-	def _shape(self, params):
-		style = params["sh"]
-		dico_style = {'arrow' : self.arrow, 'turtle' : self.turtle, \
-			'circle' : self.cercle, 'square' : self.square, \
-			'triangle' : self.triangle, 'classic': self.arrow}
-		self.style = dico_style[style]
-
-	def forward(self, L):
-		if self._speed == 0 : 
-			self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}""", "L" : L })
-		else :
-			for _ in range(0, L, self._speed):
-				self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}""", "L" : self._speed})
-			self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}""", "L" : L % self._speed})
-
-	def fd(self, L):
-		self.forward(L)
-				
-	def _forward(self, params):
-		L = params["L"]
-		if self.fill : self.fill_coordinates.append((self.x, self.y))
-		self.ctx.beginPath()
-		if (not self._hide): self.style()
-		self.ctx.moveTo(self.x, self.y)
-		self.ctx.lineTo(self.x + L * cos(self.deg2rad(self.angle)), \
-						self.y + L * sin(self.deg2rad(self.angle)))
-		if self._pen_down: self.ctx.stroke()
-		self.x += L * cos(self.deg2rad(self.angle))
-		self.y += L * sin(self.deg2rad(self.angle))
-
-	def backward(self, L):
-		if self._speed == 0 : 
-			self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}""", "L" : -L })
-		else :
-			for _ in range(0, L, self._speed):
-				self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}""", "L" : -self._speed})
-			self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}""", "L" : -L % self._speed})
-
-	def back(self, L):
-		self.backward(L)
-
-	def bk(self, L):
-		self.backward(L)
-
-	def _backward(self, params):
-		L = params["L"]
-		if self.fill : self.fill_coordinates.append((self.x, self.y))
-		self.ctx.beginPath()
-		if (not self._hide): self.style()
-		self.ctx.moveTo(self.x, self.y)
-		self.ctx.lineTo(self.x + L * cos(self.deg2rad(self.angle)), \
-						self.y + L * sin(self.deg2rad(self.angle)))
-		if self._pen_down: self.ctx.stroke()
-		self.x += L * cos(self.deg2rad(self.angle))
-		self.y += L * sin(self.deg2rad(self.angle))
-
-	def xcor(self):
-		""" non fonctionnel """
-		self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}"""})
-
-	def _xcor(self, params):
-		return self.x
-
-	def ycor(self):
-		""" non fonctionnel """
-		self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}"""})
-
-	def _ycor(self):
-		return self.y
-
-	def heading(self):
-		self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}"""})
-
-	def _heading(self):
-		return self.angle
-
-	def setheading(self, angle):
-		self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}""", "a" : angle})
-
-	def seth(self, angle):
-		self.setheading(angle)
-
-	def _setheading(self, params):
-		angle = params["a"]
-		self.angle = angle
-
-	def setx(self, x):
-		self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}""", "x" : x})
-
-	def _setx(self, params):
-		x = params["x"]
-		self.x = x
-
-	def sety(self, y):
-		self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}""", "y" : y})
-
-	def _setx(self, params):
-		y = params["y"]
-		self.y = y
-
-	def home(self):
-		self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}"""})
-
-	def _home(self, params):
-		self.x, self.y, self.angle = 0, 0, self.init_angle
-
-	def begin_fill(self):
-		self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}"""})
-
-	def _begin_fill(self, *args):
-		self.fill_coordinates = []
-		self.fill = True
-
-	def end_fill(self):
-		self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}"""})
-
-	def _end_fill(self, *args):
-		self.ctx.fillStyle = self.fill_color
-		for ptX, ptY in self.fill_coordinates:
-			self.ctx.lineTo(ptX, ptY)
-		self.ctx.fill("evenodd")
-		self.fill = False
-
-	def filling(self):
-		return self.fill
-
-	@_basic_pointer_draw
-	def triangle(self):
-		x, y = self.x, self.y
-		x1, y1 = self.rotation(-15, -10)
-		x2, y2 = self.rotation(-15, 10)
-		self.ctx_pt.moveTo(x, y)
-		self.ctx_pt.lineTo(x+x1, y+y1)
-		self.ctx_pt.lineTo(x+x2, y+y2)
-
-	@_basic_pointer_draw
-	def arrow(self):
-		x, y = self.x, self.y
-		x1, y1 = self.rotation(-15, -8)
-		x2, y2 = self.rotation(-15, 8)
-		x3, y3 = self.rotation(-10, 0)
-		self.ctx_pt.moveTo(x, y)
-		self.ctx_pt.lineTo(x+x1, y+y1)
-		self.ctx_pt.lineTo(x+x3, y+y3)
-		self.ctx_pt.lineTo(x+x2, y+y2)
-
-	@_basic_pointer_draw
-	def turtle(self):
-		x, y = self.x, self.y
-		quarter_turtle = [(-5,2), (-6,4), (-5,5), (-4,3)] 
-		half_head = [(5,1), (7,2)] 
-		half_turtle = quarter_turtle + [(-1,4)] \
-			+ [self._x_symmetry(p, q, -1) for (p,q) in quarter_turtle[::-1]] \
-			+ half_head
-		full_turtle = [(-6,0)] + half_turtle + [(9,0)] \
-			+ [self._y_symmetry(p, q, 0) for (p,q) in half_turtle[::-1]]
-		rotated_full_turtle = [self.rotation(p, q) for (p, q) in full_turtle]
-		rotated_full_turtle = [self._stretch(p, q) for (p, q) in rotated_full_turtle]
-		
-		self.ctx_pt.moveTo(x + rotated_full_turtle[0][0], y + rotated_full_turtle[0][1])
-		for (p,q) in rotated_full_turtle:
-			self.ctx_pt.lineTo(x + p, y + q)
-	
-	def _stretch(self, x, y, stretch_factor=2):
-		return (x*stretch_factor, y*stretch_factor)
-
-	@_basic_pointer_draw            
-	def cercle(self):
-		rad = 15
-		x, y = self.x, self.y
-		self.ctx_pt.arc(x, y, rad, 0, 2*pi)
-
-	@_basic_pointer_draw
-	def square(self):
-		side = 15
-		x, y = self.x, self.y
-		x0, y0 = self.rotation(-side/2, -side/2)
-		x1, y1 = self.rotation(-side/2, side/2)
-		x2, y2 = self.rotation(side/2, -side/2)
-		x3, y3 = self.rotation(side/2, side/2)
-		self.ctx_pt.moveTo(x+x0, y+y0)
-		self.ctx_pt.lineTo(x+x1, y+y1)
-		self.ctx_pt.lineTo(x+x3, y+y3)
-		self.ctx_pt.lineTo(x+x2, y+y2)
-
-	def _x_symmetry(self, x, y, x_axis):
-		return (2*x_axis-x, y)
-
-	def _y_symmetry(self, x, y, y_axis):
-		return (x, 2*y_axis-y)
-
-	def rotation(self, x, y):
-		inv_rot_mat = [[cos(self.deg2rad(self.angle)), -sin(self.deg2rad(self.angle))], \
-					[sin(self.deg2rad(self.angle)), cos(self.deg2rad(self.angle))]]
-		new_x = inv_rot_mat[0][0]*x + inv_rot_mat[0][1]*y
-		new_y = inv_rot_mat[1][0]*x + inv_rot_mat[1][1]*y
-		return new_x, new_y
-
-	def circle(self, radius, extent = None, steps = None):
-		#coords = self._get_circle_coordinates(radius)
-		#n = 12
-		#for i in range(n):
-		#    self.state.append({"code": f"""self._{inspect.currentframe().f_code.co_name}""", \
-		#                       "x" : coords[i][0], "y" : coords[i][1]})
-		self.state.append({"code": f"""self._{inspect.currentframe().f_code.co_name}""", \
-								"r": radius, "e":extent , "s":steps})
-		
-	def _circle(self, params):
-		#self._goto(params)
-		
-		radius, extent, steps = params["r"], params["e"], params["s"]
-		n = 12
-		eps = 1
-		if radius < 0 : radius, eps = -radius, -1
-		center = [self.x+radius*cos(self.deg2rad(self.angle - 90)), \
-						self.y+radius*sin(self.deg2rad(self.angle - 90))]
-		if extent is None and steps is None:
-			angle = [eps*i*360/n-90 for i in range(n)]
-			coords = [(radius*cos(self.deg2rad(angle[i])), radius*sin(self.deg2rad(angle[i]))) for i in range(n)]
-			self.ctx.clearRect(0, 0, self.canvas_pt.width, self.canvas_pt.height)
-			self.ctx.beginPath()
-			self.ctx.moveTo(center[0]+coords[0][0], center[1]+coords[0][1])
-			for i in range(1, n):
-				self.ctx.lineTo(center[0]+coords[i][0], center[1]+coords[i][1])
-			self.ctx.closePath()
-			self.ctx.stroke()
-		#elif steps is None:
-
-		#else:
-
-	#def _get_circle_coordinates(self, radius):
-	#   n = 12
-	#   eps = 1
-	#   if radius < 0 : radius, eps = -radius, -1
-	#   center = [self.x+radius*cos(self.deg2rad(self.angle - 90)), \
-		#           self.y+radius*sin(self.deg2rad(self.angle - 90))]
-		#angle = [eps*i*360/n-90 for i in range(n)]
-		#coords = [(center[0] +radius*cos(self.deg2rad(angle[i])), center[1] +radius*sin(self.deg2rad(angle[i]))) for i in range(n)]
-		#return coords
-
-	def right(self, angle):
-		if self._speed == 0 : 
-			self.state.append({"code": f"""self._{inspect.currentframe().f_code.co_name}""", "a": angle})
-		else :
-			for _ in range(angle//self._speed):
-				self.state.append({"code": f"""self._{inspect.currentframe().f_code.co_name}""", "a": self._speed})
-			self.state.append({"code": f"""self._{inspect.currentframe().f_code.co_name}""", "a": angle % (self._speed)})
-
-	def rt(self, angle):
-		self.right(angle)
-
-	def left(self, angle):
-		if self._speed == 0 : 
-			self.state.append({"code": f"""self._{inspect.currentframe().f_code.co_name}""", "a": angle})
-		else :
-			for _ in range(angle//self._speed):
-				self.state.append({"code": f"""self._{inspect.currentframe().f_code.co_name}""", "a": self._speed})
-			self.state.append({"code": f"""self._{inspect.currentframe().f_code.co_name}""", "a": angle % (self._speed)})
-
-	def lt(self, angle):
-		self.left(angle)
-
-	def _right(self, params):
-		angle = params["a"]
-		self.angle += angle
-		if (not self._hide): self.style()
-
-	def _left(self, params):
-		angle = params["a"]
-		self.angle -= angle
-		if (not self._hide): self.style()
-
-	#def stamp(self):
-	#    self.stamp_number += 1
-	#    self.ctx.triangle()
-	#    return self.stamp_number
-
-	def dot(self, size = None, color = None):
-		if isinstance(size, str) : size, color = None, size
-		self.state.append({"code": f"""self._{inspect.currentframe().f_code.co_name}""", "size": size, "color": color})
-
-	def _dot(self, params):
-		# dot is not always on top of the line
-		color = params["color"]
-		size = params["size"]/2 if params["size"] is not None else max(self.ctx.lineWidth+4, self.ctx.lineWidth*2)
-		assert size >= 1, f"""bad screen distance {size}"""
-		self.ctx.beginPath()
-		self.ctx.arc(self.x, self.y, size, 0, 2*pi)
-		self.ctx.fillStyle = color if color is not None else self.color
-		self.ctx.fill()
-
-	def position(self):
-		self.state.append({"code" : f"""self._{inspect.currentframe().f_code.co_name}"""})
-	
-	def _position(self, *args):
-		return (self.x, self.y)
-
-	def pos(self):
-		self.position()     
-
-	def tick(self):
-		# Clear canvas
-		if len(self.state) > 0 :	
-			# Draw current state
-			commands = self.state.pop(0)
-			command = commands.pop("code")
-			params = commands
-			eval(command)(params)
-		else : 
-			js.clearInterval(self.on_draw)
-
-	def mainloop(self):
-		self.ctx.clearRect(0, 0, self.canvas.width, self.canvas.height)
-		self.ctx_pt.clearRect(0, 0, self.canvas_pt.width, self.canvas_pt.height)
-		self._animate()
-
-	def _mainloop_noclear(self):
-		self._animate()            
-
-	def _animate(self):
-		self.on_draw = js.window.setInterval(lambda x=2 : self.tick(), 10)
-
-_direct_access_turtle = Turtle()
-def _deco_direct_access(function):
-
-	def wrapper(*args):
-		global _direct_access_turtle
-		function(*args)
-		_direct_access_turtle._mainloop_noclear()
-
-	return wrapper
-
-
-method_list = [func for func in dir(Turtle) if callable(getattr(Turtle, func)) and not func.startswith("_")]
-
-for nom in method_list:
-	exec(f"""@_deco_direct_access\ndef {nom}(*args):\n\t_direct_access_turtle.{nom}(*args)""")

infra/rename_scripts.zsh

-#!/bin/zsh
-cd docs/scripts/
-for rep in `ls -d */`
-do
-  cd $rep
-  echo $rep
-  for i in `ls -1 corr_*`
-  do
-    echo $i ${i:-2}
-    echo ${i:5:-3}_corr.py
-    mv $i ${i:5:-3}_corr.py; 
-  done
-  for i in `ls -1 test_*`
-  do
-    echo $i ${i:-2}
-    echo ${i:5:-3}_test.py
-    mv $i ${i:5:-3}_test.py; 
-  done
-  cd ..
-done
-cd ..

main.py

-from pyodide_mkdocs_theme.pyodide_macros import PyodideMacrosPlugin, TestsToken
-
-def define_env(env:PyodideMacrosPlugin):
-
-    custom = {
-                "tests": TestsToken("\n# Tests"),
-                }
-                
\ No newline at end of file