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/filtre.py

+# --------- PYODIDE:env --------- #
+
+def est_pair(n):
+    return n % 2 == 0
+
+
+# --------- PYODIDE:code --------- #
+
+def filtre_pair(entiers):
+    ...
+
+
+# --------- PYODIDE:corr --------- #
+
+def filtre_pair(entiers):
+    return [nbre for nbre in entiers if est_pair(nbre)]
+
+
+# --------- PYODIDE:tests --------- #
+
+assert filtre_pair([1, 2, 3, 4, 5, 6, 7]) == [2, 4, 6]
+assert filtre_pair([]) == []
+
+
+# --------- PYODIDE:secrets --------- #
+
+assert filtre_pair([100, 201, 302, 404, 501, 601, 700]) == [100, 302, 404, 700]

docs/python_imbrique/pair.py

+# --------- PYODIDE:code --------- #
+
+def est_pair(n):
+    ...
+
+# --------- PYODIDE:corr --------- #
+
+def est_pair(n):
+    return n % 2 == 0
+
+
+# --------- PYODIDE:tests --------- #
+
+assert est_pair(42) is True
+assert est_pair(1) is False
+
+
+# --------- PYODIDE:secrets --------- #
+
+assert est_pair(0) is True
+assert est_pair(2001) is False

docs/python_imbrique/questions_imbriquees.md

+---
+author: Votre nom
+title: Exercice avec plusieurs questions Python imbriquées
+tags:
+  - modulo
+  - liste/tableau
+---
+
+???+ question "Exercice 1"
+
+    
+    **Question 1**
+    
+    Compléter la fonction `est_pair` qui prend en paramètre un nombre entier `nbre`, et renvoie `True` s'il est pair, `False` sinon.
+
+    {{ IDE('pair') }}
+    
+
+    **Question 2**
+
+    Compléter la fonction `filtre_pair` qui prend en paramètre un tableau de nombres entiers `entiers` et qui renvoie un nouveau tableau
+    ne contenant que les nombres pairs de `entiers`.
+
+    !!! danger "Contrainte"
+
+        Vous appelerez **obligatoirement** la fonction écrite à la question 1. Elle est dans le code caché de cette question. Vous n'êtes pas obligé
+        d'avoir réussi la question 1 pour répondre à cette question.
+
+    {{ IDE('filtre') }}
+

docs/qcm_1/autres_qcm.md

+---
+author: Mireille
+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') }}
+

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/saisies/exo.py

+# --------- PYODIDE:env --------- #
+
+def devine(reponse = None):
+    debut = NB_MIN
+    fin = NB_MAX
+    reussi = False
+    while (fin-debut >= 0 or erreur or reponse == None) and not reussi:
+        reussi = False
+        erreur = False
+        milieu = (fin + debut)//2
+        reponse = input(f"Si le nombre est strictement plus grand que {milieu} appuyer sur +, s'il est strictement plus petit appuyer sur - ,si c'est le bon appuyer sur =")
+        if reponse == '+':
+            debut=milieu + 1
+        elif reponse == '-':
+            fin = milieu - 1
+        elif reponse == '=':
+            print("Le nombre que vous avez choisi est : ", milieu)
+            reussi = True
+        else :
+            print("Erreur de saisie. Il faut saisir + ou - ou =")
+            erreur = True
+
+# --------- PYODIDE:code --------- #
+
+"""Vous jouez contre l'ordinateur. Le code de la fonction devine est caché.
+Vous devez penser à un nombre compris entre NB_MIN et NB_MAX.
+L'ordinateur va tenter de le deviner en vous posant des questions.
+Il faut juste cliquer sur l'icône Exécuter le code, pour exécuter ce script."""
+
+NB_MIN = 1
+NB_MAX = 100
+devine()

docs/saisies/intro_dicho.md

+---
+author: Votre nom
+title: Exercice avec du code caché et des saisies
+---
+
+???+ question "Je joue contre l'ordinateur"
+
+    Question 1.   
+
+    Exécuter le programme du jeu du nombre mystère.
+    Faire quelques parties, expliquer la stratégie de l'ordinateur pour trouver le nombre mystère.
+
+    {{ IDE('exo') }} 
+
+    ??? success "Solution"
+
+        A chaque fois, il se place au milieu.
\ No newline at end of file

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"),
-                }
-    env.lang.overload(custom)

mkdocs.yml

 # À modifier avec le nom et la description du site
-site_name: "Site jn APMEP"
-site_description: Un modèle avec mkdocs
+site_name: "Site modèle avec Python"
+site_description: Un modèle avec pyodide-mkdocs-theme
 
 # À modifier, avec votre nom et la licence choisie
 copyright: |
-    M. Coilhac
-    <a rel="license" href="https://creativecommons.org/licenses/by-nc-sa/4.0/deed.fr"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a><br/>
-    Hébergé sur la forge gérée par l'<a href="https://aeif.fr">AEIF</a>
+    Nom d'auteur
+    <a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-sa/4.0/88x31.png" /></a>.
+    <br><a href="https://aeif.fr">Design by AEIF</a>
 
 # À modifier, avec votre mail
 #extra:
@@ -20,11 +20,15 @@ copyright: |
 
 # Éventuellement à modifier avec votre thème de couleurs
 theme:
-    favicon: assets/favicon.ico
+    favicon: assets/images/favicon.png
     icon:
       logo: material/stairs-up
-    #custom_dir: my_theme_customizations/
     name: pyodide-mkdocs-theme
+
+    # La palette de couleur est maintenant intégrée par défaut au thème.
+    # Si vous souhaitez en changer, vous pouvez redéclarer la section entière
+    # et vos réglages prendront le pas sur les valeurs par défaut.
+    # Mêmes choses pour la langue et la suppression des google-fonts (non RGPD).
     #font: false                     # RGPD ; pas de fonte Google
     #language: fr                    # français
     #palette:                        # Palettes de couleurs jour/nuit
@@ -43,14 +47,17 @@ theme:
             #icon: material/weather-night
             #name: Passer au mode jour
     features:
-        # - navigation.instant
-        # - navigation.tabs   Pour avoir le menu vertical il fallait supprimer ça
+        #- navigation.instant
+        #- navigation.tabs   Pour avoir le menu vertical il fallait supprimer ça
         - navigation.top
         - toc.integrate
         - header.autohide
         - content.code.annotate   # Pour les annotations de code deroulantes avec +
+        - content.code.copy  # Ajout après MAJ pour pouvoir copier du code
+
+    custom_dir: overrides
+
 
-# Fin de modifications à effectuer, ne pas toucher les lignes suivantes sauf si vous comprenez ce que vous faites.
 
 site_url: !ENV [CI_PAGES_URL, "http://127.0.0.1:8000/"]
 site_author: !ENV [CI_COMMIT_AUTHOR, "Nom d'auteur"]
@@ -59,9 +66,7 @@ edit_uri: !ENV [EDIT_VARIABLE]
 
 docs_dir: docs
 
-nav:
-  - "🏡 Accueil": index.md
-  - ... | regex=^(?:(?!_REM.md).)*$
+#nav:   inutile on utilise les fichiers .pages plus pratiques
 
 markdown_extensions:
     - md_in_html
@@ -76,18 +81,22 @@ markdown_extensions:
     - pymdownx.mark                 # Passage ==surligné==.
     - pymdownx.tilde                # Passage ~~barré~~ ou en ~indice~.
     - pymdownx.highlight:           # Coloration syntaxique du code
+        auto_title: true
+        anchor_linenums: true
+        line_spans: __span
+        pygments_lang_class: true
     - pymdownx.inlinehilite         # pour  `#!python  <python en ligne>`
     - pymdownx.snippets             # Inclusion de fichiers externe.
     - pymdownx.tasklist:            # Cases à cocher  - [ ]  et - [x]
         custom_checkbox:    false   #   avec cases d'origine
         clickable_checkbox: true    #   et cliquables.
     - pymdownx.tabbed:              # Volets glissants.  === "Mon volet"
-        alternate_style: true 
+        alternate_style: true
     - pymdownx.keys:                # Touches du clavier.  ++ctrl+d++
         separator: "\uff0b"
-    - pymdownx.emoji:               # Émojis  :boom:
-        emoji_index:     !!python/name:materialx.emoji.twemoji
-        emoji_generator: !!python/name:materialx.emoji.to_svg
+    - pymdownx.emoji: # Émojis  :boom:
+        emoji_index: !!python/name:material.extensions.emoji.twemoji
+        emoji_generator: !!python/name:material.extensions.emoji.to_svg
     - pymdownx.superfences:
         custom_fences:
           - name: mermaid
@@ -102,16 +111,20 @@ markdown_extensions:
 
 plugins:
 
-  - awesome-pages:
+  - awesome-pages:   # Pour les fichiers .pages
       collapse_single_pages: true
 
-  - material/search
-  - material/tags:
+  - search
+  - tags:
       tags_file: tags.md
   - pyodide_macros:
       # Vous pouvez ajouter ici tout réglage que vous auriez ajouté concernant les macros:
       on_error_fail: true     # Il est conseillé d'ajouter celui-ci si vous ne l'utilisez pas.
-
+      build:
+        python_libs:
+          - turtle
+        tab_to_spaces: 4
+  - sqlite-console
 
 
 # En remplacement de mkdocs-exclude. Tous les fichiers correspondant aux patterns indiqués seront
@@ -121,16 +134,10 @@ exclude_docs: |
     **/*_REM.md
     **/*.py
 
+#extra_javascript:  Supprimé pour MAJ pyodide pris en compte par le thème lui même
+  #- xtra/mathjax.js                    # MathJax
+  #- https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js
 
 
-
-
-
-
-#extra_javascript:
-  # - xtra/javascripts/mathjax-config.js       Supprimé pour MAJ pyodide             
-  # - https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js
-
 extra_css:
-  # - xtra/stylesheets/qcm.css ##       Supprimé pour MAJ pyodide  
   - xtra/stylesheets/ajustements.css  # ajustements

overrides/js-libs/mathjax-libs.js

+function mathJaxUpdate(){
+    jsLogger('[MathJax] - Page formatting')
+  
+    if(!window.MathJax.startup.output){
+      console.error("Cannot update MathJax (CDN failed to load?)")
+      return
+    }
+  
+    window.MathJax.startup.output.clearCache()
+    window.MathJax.typesetClear()
+    window.MathJax.texReset()
+    window.MathJax.typesetPromise()
+  }
+  const mathJaxIsReady = subscribeWhenReady('mathJax', mathJaxUpdate, {maxTries:100})
+  
+  
+  window.MathJax = {
+    startup: {
+      ready: () => {
+        jsLogger("[MathJax] - Setting up");
+        MathJax.startup.defaultReady();
+        jsLogger("[MathJax] - Ready");
+        mathJaxIsReady()
+        mathJaxUpdate()
+      },
+    },
+    loader: {
+      load: ['[tex]/cancel', 'output/svg', '[tex]/color', '[tex]/mhchem']
+    },
+    tex: {
+      packages: {'[+]': ['cancel', 'color', 'mhchem']},
+      inlineMath: [["\\(", "\\)"]],
+      displayMath: [["\\[", "\\]"]],
+      processEscapes: true,
+      processEnvironments: true,
+    },
+    options: {
+      ignoreHtmlClass: ".*|",
+      processHtmlClass: "arithmatex",
+    },
+  }