Comment Retrouver du Code dans des Jupyter Notebooks ou des Scripts sur Mac

Introduction

Si vous écrivez beaucoup de scripts Python ou de notebooks Jupyter sur votre Mac, vous pouvez finir par rencontrer un problème très frustrant : vous vous souvenez d’un nom de variable, d’un nom de fonction ou d’un petit morceau de code, mais vous ne vous souvenez plus dans quel fichier il se trouve.

Par exemple, j’ai récemment eu besoin de retrouver un notebook contenant du code comme :

1

idx_start, idx_end, delta_start_sec, fraction_start = compute_subset_indices_from_start(...)

Je savais que le code se trouvait quelque part sur mon Mac, probablement dans un fichier .ipynb, mais je ne me souvenais plus du nom exact du notebook ni du dossier. La recherche classique avec le Finder de macOS n’était pas très utile. Finder est pratique pour chercher des noms de fichiers, des documents ou des métadonnées courantes, mais ce n’est pas toujours le meilleur outil lorsque vous devez rechercher à l’intérieur de fichiers de code, surtout dans des notebooks Jupyter.

Un notebook Jupyter n’est pas un simple fichier .py. Il s’agit en réalité d’un fichier JSON structuré qui contient des cellules de code, des cellules Markdown, des sorties et des métadonnées. Cela signifie qu’il est possible de rechercher à l’intérieur des notebooks, mais les outils du terminal sont souvent beaucoup plus fiables que Finder.

Dans ce tutoriel, nous allons voir comment rechercher à l’intérieur des fichiers .ipynb, .py et d’autres fichiers de code sur Mac en utilisant le Terminal.

Rechercher dans des notebooks Jupyter avec grep

La solution la plus simple consiste à utiliser grep, un outil en ligne de commande qui recherche des motifs de texte à l’intérieur des fichiers.

Ouvrez l’application Terminal et exécutez :

1

grep -RIl --include="*.ipynb" "compute_subset_indices_from_start" ~/Documents ~/Desktop ~/Downloads 2>/dev/null

Cette commande recherche récursivement dans vos dossiers Documents, Desktop et Downloads les notebooks Jupyter qui contiennent le texte :

1

compute_subset_indices_from_start

Si une correspondance est trouvée, la commande affiche le chemin du notebook.

Exemple de sortie :

1

/Users/yourname/Documents/projects/fire_analysis/matching_viirs_gitco.ipynb

Vous pouvez ensuite ouvrir le notebook avec :

1

open "/Users/yourname/Documents/projects/fire_analysis/matching_viirs_gitco.ipynb"

Explication de la commande

1

grep -RIl --include="*.ipynb" "compute_subset_indices_from_start" ~/Documents ~/Desktop ~/Downloads 2>/dev/null

Voici ce que signifie chaque partie :

1

grep

Recherche du texte à l’intérieur des fichiers.

1

-R

Recherche récursivement dans les dossiers et sous-dossiers.

1

-I

Ignore les fichiers binaires.

1

-l

Affiche uniquement les noms des fichiers qui contiennent le texte recherché.

1

--include="*.ipynb"

Recherche uniquement dans les fichiers qui se terminent par .ipynb.

1

"compute_subset_indices_from_start"

Le texte que vous voulez trouver.

1

~/Documents ~/Desktop ~/Downloads

Les dossiers dans lesquels la recherche sera effectuée.

1

2>/dev/null

Masque les erreurs de permission et les autres messages d’avertissement.

Rechercher un nom de variable

Si vous vous souvenez d’un nom de variable, vous pouvez le rechercher directement.

Par exemple :

1

grep -RIl --include="*.ipynb" "idx_start" ~/Documents ~/Desktop ~/Downloads 2>/dev/null

Ou :

1

grep -RIl --include="*.ipynb" "delta_start_sec" ~/Documents ~/Desktop ~/Downloads 2>/dev/null

C’est utile lorsque vous ne vous souvenez pas du nom complet de la fonction, mais que vous vous souvenez d’une variable utilisée dans le code.

Rechercher dans tous les notebooks Jupyter de votre dossier utilisateur

Si vous ne savez pas où se trouve le notebook, vous pouvez rechercher dans tout votre dossier utilisateur :

1

grep -RIl --include="*.ipynb" "compute_subset_indices_from_start" ~ 2>/dev/null

C’est plus complet, mais cela peut prendre plus de temps si vous avez beaucoup de fichiers.

Rechercher plusieurs mots-clés dans le même notebook

Parfois, un seul mot-clé ne suffit pas. Par exemple, vous pouvez vouloir trouver les notebooks qui contiennent tous ces termes :

1
2
3
4
5

idx_start
idx_end
delta_start_sec
fraction_start
compute_subset_indices_from_start

Vous pouvez utiliser :

1
2
3
4
5
6
7

grep -RIl --include="*.ipynb" "compute_subset_indices_from_start" ~/Documents ~/Desktop ~/Downloads 2>/dev/null | while read f; do
    grep -q "idx_start" "$f" &&
    grep -q "idx_end" "$f" &&
    grep -q "delta_start_sec" "$f" &&
    grep -q "fraction_start" "$f" &&
    echo "$f"
done

Cette commande trouve d’abord les notebooks contenant :

1

compute_subset_indices_from_start

Puis elle vérifie si le même notebook contient aussi :

1
2
3
4

idx_start
idx_end
delta_start_sec
fraction_start

Seuls les notebooks qui contiennent tous ces termes sont affichés.

Rechercher dans des scripts Python

Si vous voulez rechercher dans des fichiers .py au lieu de notebooks, utilisez :

1

grep -RIl --include="*.py" "compute_subset_indices_from_start" ~/Documents ~/Desktop ~/Downloads 2>/dev/null

Pour rechercher à la fois dans des scripts Python et des notebooks Jupyter, vous pouvez exécuter :

1

grep -RIl --include="*.py" --include="*.ipynb" "compute_subset_indices_from_start" ~/Documents ~/Desktop ~/Downloads 2>/dev/null

Rechercher dans plusieurs types de fichiers de code

Si votre code peut se trouver dans des fichiers Python, des notebooks, des scripts shell, des notes Markdown ou des fichiers texte, vous pouvez utiliser :

1
2
3
4
5
6
7
8

grep -RIl \
    --include="*.py" \
    --include="*.ipynb" \
    --include="*.sh" \
    --include="*.md" \
    --include="*.txt" \
    "compute_subset_indices_from_start" \
    ~/Documents ~/Desktop ~/Downloads 2>/dev/null

C’est utile si vous copiez parfois des extraits de code dans des notes ou des fichiers de documentation.

Afficher les lignes correspondantes

Les commandes précédentes affichent uniquement les noms de fichiers. Si vous voulez aussi voir les lignes correspondantes, supprimez l’option -l et ajoutez -n :

1

grep -RIn --include="*.ipynb" "compute_subset_indices_from_start" ~/Documents ~/Desktop ~/Downloads 2>/dev/null

L’option -n affiche le numéro de ligne où la correspondance a été trouvée.

Cependant, comme les fichiers .ipynb sont des fichiers JSON, la sortie peut parfois être difficile à lire. Cela reste utile pour identifier le notebook, mais pour une lecture détaillée, il est généralement préférable d’ouvrir le notebook lui-même.

Un meilleur outil : ripgrep

Un autre excellent outil est ripgrep, souvent appelé avec la commande rg.

Il est généralement plus rapide que grep, surtout lorsque vous recherchez dans de grands dossiers contenant beaucoup de fichiers.

Vous pouvez l’installer avec Homebrew :

1

brew install ripgrep

Puis rechercher dans les notebooks avec :

1

rg -l --glob "*.ipynb" "compute_subset_indices_from_start" ~/Documents ~/Desktop ~/Downloads

Pour rechercher dans tout votre dossier utilisateur :

1

rg -l --glob "*.ipynb" "compute_subset_indices_from_start" ~

Pour rechercher à la fois dans les fichiers .py et .ipynb :

1

rg -l --glob "*.py" --glob "*.ipynb" "compute_subset_indices_from_start" ~

Rechercher plusieurs termes avec ripgrep

Vous pouvez rechercher plusieurs mots-clés possibles en utilisant une expression régulière :

1

rg -n --glob "*.ipynb" "idx_start|idx_end|delta_start_sec|fraction_start|compute_subset_indices_from_start" ~

Cette commande trouve les notebooks qui contiennent l’un de ces termes :

1
2
3
4
5

idx_start
idx_end
delta_start_sec
fraction_start
compute_subset_indices_from_start

C’est très utile lorsque vous ne vous souvenez que d’une partie du code.

Méthode recommandée

Une bonne méthode consiste à :

1) Commencer avec le nom de fonction le plus spécifique

1

grep -RIl --include="*.ipynb" "compute_subset_indices_from_start" ~/Documents ~/Desktop ~/Downloads 2>/dev/null

2) Si rien n’est trouvé, rechercher un nom de variable

1

grep -RIl --include="*.ipynb" "delta_start_sec" ~ 2>/dev/null

3) Si vous avez ripgrep, utiliser

1

rg -n --glob "*.ipynb" "idx_start|idx_end|delta_start_sec|fraction_start|compute_subset_indices_from_start" ~

4) Une fois le notebook trouvé, l’ouvrir

1

open "/path/to/notebook.ipynb"

Rechercher dans un disque dur externe

Si votre code est stocké sur un disque externe, par exemple :

1

/Volumes/HD15TB/Datasets/

vous pouvez y rechercher avec :

1

grep -RIl --include="*.ipynb" "compute_subset_indices_from_start" /Volumes/HD15TB/Datasets/ 2>/dev/null

Ou avec ripgrep :

1

rg -l --glob "*.ipynb" "compute_subset_indices_from_start" /Volumes/HD15TB/Datasets/

C’est très utile lorsque vous avez beaucoup d’anciens projets stockés sur un disque externe.

Créer une petite fonction de recherche réutilisable

Si vous recherchez souvent du code sur votre Mac, vous pouvez créer une petite fonction shell.

Ouvrez votre fichier de configuration shell :

1

nano ~/.zshrc

Ajoutez cette fonction :

1
2
3
4
5
6
7
8
9

findcode() {
    grep -RIl \
        --include="*.py" \
        --include="*.ipynb" \
        --include="*.sh" \
        --include="*.md" \
        "$1" \
        ~/Documents ~/Desktop ~/Downloads 2>/dev/null
}

Enregistrez le fichier, puis rechargez votre shell :

1

source ~/.zshrc

Vous pouvez maintenant rechercher dans votre code comme ceci :

1

findcode "compute_subset_indices_from_start"

ou :

1

findcode "delta_start_sec"

Créer une version plus rapide avec ripgrep

Si vous avez installé ripgrep, vous pouvez ajouter ceci à votre fichier ~/.zshrc :

1
2
3
4
5
6
7
8
9

findcode_rg() {
    rg -l \
        --glob "*.py" \
        --glob "*.ipynb" \
        --glob "*.sh" \
        --glob "*.md" \
        "$1" \
        ~/Documents ~/Desktop ~/Downloads
}

Puis rechargez :

1

source ~/.zshrc

Utilisez-la avec :

1

findcode_rg "compute_subset_indices_from_start"

Conclusion

Lorsque vous devez retrouver un ancien script ou notebook Jupyter sur votre Mac, la recherche avec Finder peut ne pas suffire. Finder n’est pas toujours le meilleur outil pour rechercher à l’intérieur de fichiers de code, surtout lorsque le fichier est un notebook Jupyter.

L’utilisation de commandes du Terminal comme grep ou ripgrep vous donne une méthode beaucoup plus fiable pour rechercher des noms de fonctions, des variables, des mots-clés ou de petits extraits de code.

Par exemple, si vous vous souvenez d’une fonction comme :

1

compute_subset_indices_from_start

ou de variables comme :

1
2
3
4

idx_start
idx_end
delta_start_sec
fraction_start

vous pouvez rapidement trouver le notebook ou le script dans lequel elles ont été utilisées.

Pour les développeurs, data scientists et chercheurs qui travaillent souvent avec de nombreux notebooks et scripts, apprendre à rechercher à l’intérieur des fichiers depuis la ligne de commande peut faire gagner beaucoup de temps.

Références