cleanup pass with nbnorm focusing on slideshow & empty tags

Author: parmentelat

jupytext.toml

@@ -1,3 +1,3 @@
-cell_metadata_filter = """all,-hidden,-heading_collapsed,-run_control,-trusted,-editable"""
+cell_metadata_filter = """all,-hidden,-heading_collapsed,-run_control,-trusted,-editable,-slideshow"""
 # use the jupytext config exclusively for exclusions
 notebook_metadata_filter = """all, -jupytext.cell_metadata_filter, -jupytext.notebook_metadata_filter, -jupytext.text_representation.jupytext_version, -jupytext.text_representation.format_version,-language_info.version, -language_info.codemirror_mode,-language_info.file_extension, -language_info.mimetype, -toc, -rise, -version"""

notebooks/dashboards/marimo/README-marimo-nb.md

@@ -24,7 +24,7 @@ so you can {download}`download the companion zip<./ARTEFACTS-marimo.zip>`
 to run our samples locally
 ```
 
-*`marimo.io`* is a recent system to build [its own kind of notebooks](https://docs.marimo.io/index.html)  
+*`marimo.io`* is a recent system to build [its own kind of notebooks](https://docs.marimo.io/index.html)
 
 +++
 

notebooks/dashboards/streamlit/README-streamlit-nb.md

@@ -25,9 +25,6 @@ mais voici pour commencer un aperçu rapide de ce qu'on peut en faire
 
 la bibliothèque `streamlit` (<https://streamlit.io/>) est un utilitaire qui permet de réaliser rapidement des applis de type *dashboard* - c'est-à-dire par exemple une visualisation interactive où on peut faire varier différents paramètres d'entrée, pour explorer interactivement des données
 
-
-
-
 +++
 
 ## pour quoi faire ?

notebooks/geo-howtos/folium/HOWTO-folium-nb.md

@@ -25,7 +25,6 @@ la bibliothèque `folium` (<https://python-visualization.github.io/folium/latest
 
 elle est donc souvent utilisée en conjonction avec `geopandas`
 
-
 +++
 
 ## les bases

notebooks/geo-tps/addresses/README-addresses-nb.md

@@ -77,8 +77,6 @@ import pandas as pd
 vous pouvez charger le fichier `data/addresses.csv`; toutes ces adresses sont situées à PARIS
 
 ```{code-cell} ipython3
-:tags: []
-
 # load the data in data/addresses.csv
 # and display a few first lines
 
@@ -162,8 +160,6 @@ import requests
 ```
 
 ```{code-cell} ipython3
-:tags: []
-
 # here's how to use the API
 
 def localize_one(num, typ, nom):
@@ -255,6 +251,7 @@ curl -X POST -F data=@path/to/file.csv -F columns=voie -F columns=ville https://
   ```bash
   curl -o lapageweb.html http://github.com/flotpython/
   ```
+
 * quand on utilise une API, comme on vient de le faire pour aller chercher la position de la rue des bernardins, on doit **passer des paramètres** à l'API  
 et pour faire ça dans une requête http, il y a **deux mécanismes: GET et POST**
 
@@ -303,22 +300,26 @@ sauf que nous, on ne veut pas utiliser `curl`, on veut faire cette requête en P
 2. le résultat - toujours au format csv - pourra être également transformé en dataframe
 3. qu'il ne restera plus qu'à `merge` (ou `join` si vous préférez) avec la dataframe de départ, pour ajouter les résultats de la géolocalisation dans les données de départ
    pour cette étape on peut envisager de ne garder que certaines colonnes de la géolocalisation (assez bavarde par ailleurs), je vous recommande de conserver uniquement:
+
    * `latitude`, `longitude` - *of course*
    * `result_city` pour pouvoir vérifier la validité des résultats - ici on devrait toujours avoir `Paris`
    * `result_type` qui devrait toujours renvoyer `housenumber`, ça permet à nouveau de vérifier qu'on a bien une adresse connue
 
 +++
 
 ````{tip}
+
 * pour envoyer un POST avec des paramètres, on peut faire
   ```python
   response = requests.post(url, file=some_dict, data=another_dict)
   ```
+
 * et donc dans notre cas, puisque `data` est un paramètre de type fichier, alors que `columns` est un paramètre usuel, on fera
   ```python
   response = requests.post(url, files={'data': file_like}, data={'columns': ['col1', ...]})
   ```
   dans lequel `file_like` désigne le résultat d'un `open()` 
+
 * enfin, `pd.read_csv` s'attend à un paramètre de type fichier, i.e. du genre de ce qu'on obtient avec `open()`  
   et du coup pour reconstruire une dataframe à partir du texte obtenu dans la requête http, on a deux choix
   1. soit on commence par sauver le texte dans un fichier temporaire (juste faire attention à choisir un nom de fichier qui n'existe pas, de préférence dans un dossier temporaire, voir le module `tempfile`)
@@ -334,8 +335,6 @@ je vous recommande d'y aller pas à pas, commencez par juste l'étape 1, puis 1
 c'est utile aussi de commencer par une toute petite dataframe pour ne pas attendre des heures pendant la mise au point...
 
 ```{code-cell} ipython3
-:tags: []
-
 import requests
 # this one is to fake a file from a string
 import io

notebooks/numpy-exos/EXO-mandelbrot-nb.md

@@ -33,26 +33,22 @@ il s'agit de calculer l'image de la convergence de mandelbrot:
 </div>
 
 ```{code-cell} ipython3
----
-slideshow:
-  slide_type: slide
----
 import numpy as np
 import matplotlib.pyplot as plt
 %matplotlib ipympl
 ```
 
 ## comment ça marche ?
 
-+++ {"cell_style": "center", "slideshow": {"slide_type": "slide"}}
++++ {"cell_style": "center"}
 
 * dans l'espace complexe, on définit pour chaque $c\in\mathbb{C}$ la suite
    * $z_0 = c$
    * $z_{n+1} = z_n^2 + c$
 * on démontre que 
   * lorsque $|z_n|>2$, la suite diverge
 
-+++ {"cell_style": "center", "slideshow": {"slide_type": "-"}}
++++ {"cell_style": "center"}
 
 il s'agit pour nous de 
 
@@ -70,7 +66,7 @@ il s'agit pour nous de
 
 * on n'a plus qu'à afficher ensuite l'image obtenue `diverge` avec `plt.imshow`
 
-+++ {"slideshow": {"slide_type": "slide"}}
++++
 
 ````{admonition} indices
 

notebooks/numpy-tps/images/README-images1-nb.md

@@ -88,11 +88,13 @@ ou toute autre librairie d'affichage que vous aimez et/ou savez utiliser: `seabo
   :width: 100px
   :align: right
   ```
+
 * l'affichage à l'écran, d'une image couleur `rgb`, utilise les règles de la synthèse additive  
 `(r, g, b) = (255, 255, 255)` donne la couleur blanche  
 `(r, g, b) = (0, 0, 0)` donne du noir  
 `(r, g, b) = (255, 0, 0)` donne du rouge
 `(r, g, b) = (255, 255, 0)` donne du jaune ...
+
 * pour afficher le tableau `im` comme une image, utilisez: `plt.imshow(im)`
 * pour afficher plusieurs images dans une même cellule de notebook faire `plt.show()` après chaque `plt.imshow(...)`
 ````
@@ -104,6 +106,7 @@ ou toute autre librairie d'affichage que vous aimez et/ou savez utiliser: `seabo
 1. Créez un tableau **non initialisé**, pour représenter une image carrée **de 91 pixels de côté**, d'entiers 8 bits non-signés, et affichez-le  
    ```{admonition} indices
    :class: tip
+
    * il vous faut pouvoir stocker 3 `uint8` par pixel pour ranger les 3 couleurs
    * on s'intéresse uniquement à la taille, et pas au contenu puisqu'on a dit "non initialisé"; que vous ayez du blanc, du noir ou du bruit, c'est OK
    ```
@@ -215,6 +218,7 @@ ou toute autre librairie d'affichage que vous aimez et/ou savez utiliser: `seabo
 
 * vous pouvez créer plusieurs figures depuis une seule cellule  
   pour cela, faites plusieurs fois la séquence `plt.imshow(...); plt.show()`
+
 * vous pouvez ensuite choisir de 'replier' ou non la zone *output* en hauteur;  
   c'est-à-dire d'afficher soit toute la hauteur, soit une zone de taille fixe avec une scrollbar pour naviguer  
   pour cela cliquez dans la marge gauche de la zone *output*
@@ -259,6 +263,7 @@ affichez-le pour `(l, c) = (10, 20)`) puis `(l, c) = (100, 200)`
     * mais pour afficher une image unidimensionnelle contenant des nombres de `0` à `255`, 
       il faut bien lui dire à quoi correspondent les valeurs  
       (lors de l'affichage, le `255` des rouges n'est pas le même `255` des verts)
+
     * du coup, voyez le paramètre `cmap=` de `plt.imshow`; et notamment avec `'Reds'`,  `'Greens'` ou  `'Blues'`
     ```
 
@@ -273,6 +278,7 @@ affichez-le pour `(l, c) = (10, 20)`) puis `(l, c) = (100, 200)`
 ```
 
 5. Copiez l'image, et dans la copie, remplacer le carré de taille `(200, 200)` en bas à droite:
+
    * d'abord par un carré de couleur RGB `(219, 112, 147)` (vous obtenez quelle couleur)  
    * puis par un carré blanc avec des rayures horizontales rouges de 1 pixel d'épaisseur
 

notebooks/numpy-tps/images/README-images2-nb.md

@@ -131,6 +131,7 @@ on obtiendrait cette fois (observez la taille en pixels de l'image)
 
 ```{admonition} indice
 :class: tip dropdown
+
 * votre fonction retourne un tuple avec deux morceaux: le nombre de lignes, et le nombre de colonnes
 * dans un premier temps, vous pouvez vous contenter d'une version un peu brute: on pourrait utiliser juste la racine carrée, et toujours fabriquer des carrés
   
@@ -164,6 +165,7 @@ def rectangle_size(n):
 
 ````{admonition} indices
 :class: dropdown
+
 * sont potentiellement utiles pour cet exo:
   * la fonction `np.indices()`
   * [l'indexation d'un tableau par un tableau](https://numerique.info-mines.paris/numpy-optional-indexing-nb/)
@@ -346,6 +348,7 @@ B' = 0.272 * R + 0.534 * G + 0.131 * B
 * dans notre cas on suppose qu'en entrée on a des entiers non-signé 8 bits
 * mais attention, les calculs vont devoir se faire en flottants, et pas en uint8  
 pour ne pas avoir, par exemple, 256 devenant 0
+
 * toutefois on veut tout de même en sortie des entiers non-signé 8 bits !
 
 ça signifie qu'il va sans doute vous falloir faire un peu de gymnastique avec les types de vos tableaux

notebooks/numpy-tps/pentominos/README-pentominos-nb.md

@@ -256,6 +256,7 @@ you have 12 pieces and 60 slots to fill, so you need 72 columns
 ### model the problem
 
 decide how to represent the board and pieces:
+
 * using nd-arrays, so rectangular spaces
 * use only **booleans** to model **obstacles** in the board and the actual **contour** of pieces
 

notebooks/numpy-tps/sounds/README-sounds-nb.md

@@ -155,11 +155,8 @@ def MyAudio(what, **kwds):
 ```
 
 ```{code-cell} ipython3
----
-slideshow:
-  slide_type: ''
-tags: [raises-exception, gridwidth-1-2]
----
+:tags: [raises-exception, gridwidth-1-2]
+
 # je peux me contenter de faire ceci
 
 MyAudio(la_1seconde)
@@ -223,8 +220,6 @@ def sine(freq, duration=1, amplitude=1.):
 #MyAudio(sine(LA, 1.5), autoplay=True)
 ```
 
-+++ {"tags": []}
-
 ### pour les rapides
 
 on veut obtenir un effet de 'note qui monte'
@@ -234,16 +229,12 @@ améliorer un peu pour générer une courbe avec un fréquence qui croit (ou dé
 écrire une fonction `sine_linear(freq1, freq2, duration)`
 
 ```{code-cell} ipython3
-:tags: []
-
 # votre code
 def sine_linear(freq1, freq2, duration):
     ...
 ```
 
 ```{code-cell} ipython3
-:tags: []
-
 # décommenter pour écouter
 #MyAudio(sine_linear(440, 660, 3))
 ```
@@ -364,6 +355,7 @@ ce qui nous amène à une petite digression: profitons-en pour regarder un peu c
 l'encodage des **entiers signés** fonctionne comme suit; on regarde ici les types `int8` et `uint8` car c'est plus simple, le principe est exactement le même pour des tailles plus grandes
 
 il y a deux types d'encodages pour les entiers:
+
 * `uint8` (le `u` signifie *unsigned*): les entiers **non signés** reposent sur un encodage "naturel": on décompose en base 2, et donc avec 8 bits, on peut aller **de 0 à 255**
 * `int8`: par contre pour les entiers **signés**, on va devoir utiliser **un bit comme bit de signe**, ce qui limite le spectre de ce qu'il est possible d'encoder; avec en tout 8 bits on peut encoder de **-128 à 127 inclus**