Gestion des paquets¶

Installation de paquets avec `mip`¶

Les cartes dotées de capacités réseau incluent le module mip, qui peut installer des paquets depuis micropython-lib et depuis des sites tiers (y compris GitHub, GitLab).

mip (« mip installs packages ») est similaire dans son concept à l’outil pip de Python, mais il n’utilise pas l’index PyPI ; il utilise plutôt micropython-lib comme index par défaut. mip récupérera automatiquement le .mpy file compilé lors du téléchargement depuis micropython-lib.

La façon la plus courante d’utiliser mip est depuis le REPL

>>> import mip
>>> mip.install("pkgname")  # Installs the latest version of "pkgname" (and dependencies)
>>> mip.install("pkgname", version="x.y")  # Installs version x.y of "pkgname"
>>> mip.install("pkgname", mpy=False)  # Installs the source version (i.e. .py rather than .mpy files)

mip détectera un emplacement approprié sur le système de fichiers en recherchant dans sys.path la première entrée se terminant par /lib. Vous pouvez remplacer la destination en utilisant target, mais notez que ce chemin doit figurer dans sys.path pour pouvoir ensuite l’importer

>>> mip.install("pkgname", target="third-party")
>>> sys.path.append("third-party")

En plus de télécharger des paquets depuis l’index micropython-lib, mip peut également installer des bibliothèques tierces. La méthode la plus simple consiste à télécharger directement un fichier

>>> mip.install("http://example.com/x/y/foo.py")
>>> mip.install("http://example.com/x/y/foo.mpy")

Lors de l’installation directe d’un fichier, l’argument target est toujours pris en charge pour définir le chemin de destination, mais mpy et version sont ignorés.

L’URL peut également commencer par github: ou gitlab: comme moyen simple de pointer vers du contenu hébergé sur GitHub ou GitLab

>>> mip.install("github:org/repo/path/foo.py")  # Uses default branch
>>> mip.install("github:org/repo/path/foo.py", version="branch-or-tag")  # Optionally specify the branch or tag
>>> mip.install("gitlab:org/repo/path/foo.py")  # Uses default branch
>>> mip.install("gitlab:org/repo/path/foo.py", version="branch-or-tag")  # Optionally specify the branch or tag

Des paquets plus sophistiqués (c’est-à-dire avec plusieurs fichiers, ou avec des dépendances) peuvent être téléchargés en spécifiant le chemin vers leur package.json

>>> mip.install("http://example.com/x/package.json")
>>> mip.install("github:org/user/path/package.json")
>>> mip.install("gitlab:org/user/path/package.json")

Si aucun fichier json n’est spécifié, alors « package.json » est ajouté implicitement

>>> mip.install("http://example.com/x/")
>>> mip.install("github:org/repo")  # Uses default branch of that repo
>>> mip.install("github:org/repo", version="branch-or-tag")
>>> mip.install("gitlab:org/repo")  # Uses default branch of that repo
>>> mip.install("gitlab:org/repo", version="branch-or-tag")

Utilisation de `mip` sur le port Unix¶

Sur le port Unix, mip peut être utilisé dans le REPL comme ci-dessus, et également en utilisant -m

$ ./micropython -m mip install pkgname-or-url
$ ./micropython -m mip install pkgname-or-url@version

Les arguments --target path, --no-mpy et --index peuvent être définis

$ ./micropython -m mip install --target third-party pkgname
$ ./micropython -m mip install --no-mpy pkgname
$ ./micropython -m mip install --index https://host/pi pkgname

Installation de paquets avec `mpremote`¶

L’outil mpremote inclut également les mêmes fonctionnalités que mip et peut être utilisé depuis un PC hôte pour installer des paquets sur un appareil connecté localement (par ex. via USB ou UART)

$ mpremote mip install pkgname
$ mpremote mip install [email protected]
$ mpremote mip install http://example.com/x/y/foo.py
$ mpremote mip install github:org/repo
$ mpremote mip install github:org/repo@branch-or-tag
$ mpremote mip install gitlab:org/repo
$ mpremote mip install gitlab:org/repo@branch-or-tag

Les arguments --target=path, --no-mpy et --index peuvent être définis

$ mpremote mip install --target=/flash/third-party pkgname
$ mpremote mip install --no-mpy pkgname
$ mpremote mip install --index https://host/pi pkgname

mpremote peut également installer des paquets à partir de fichiers stockés sur le système de fichiers local de l’hôte

$ mpremote mip install path/to/pkg.py
$ mpremote mip install path/to/app/package.json
$ mpremote mip install \\path\\to\\pkg.py

Ceci est particulièrement utile pour tester des paquets pendant le développement et pour installer des paquets à partir de clones locaux de dépôts GitHub. Notez que les URL dans les fichiers package.json doivent utiliser des barres obliques (« / ») comme séparateurs de répertoires, même sous Windows, afin d’être compatibles avec l’installation depuis le web.

Installation manuelle de paquets¶

Les paquets peuvent également être installés (sous forme .py ou .mpy) en copiant manuellement les fichiers sur l’appareil. Selon la carte, cela peut se faire via le stockage de masse USB, l’outil mpremote (par ex. mpremote fs cp path/to/package.py :package.py), webrepl, etc.

Écriture et publication de paquets¶

La publication sur micropython-lib est le moyen le plus simple de rendre votre paquet largement accessible aux utilisateurs de MicroPython, et automatiquement disponible via mip et mpremote et compilé en bytecode. Voir https://github.com/micropython/micropython-lib pour plus d’informations.

Pour écrire un paquet « auto-hébergé » qui peut être téléchargé par mip ou mpremote, vous avez besoin d’un serveur web statique (ou de GitHub) pour héberger soit un unique fichier .py, soit un fichier package.json aux côtés de vos fichiers .py.

Un exemple de bibliothèque mlx90640 hébergée sur GitHub pourrait être installé avec

$ mpremote mip install github:org/micropython-mlx90640

La disposition du paquet sur GitHub pourrait ressembler à ceci

https://github.com/org/micropython-mlx90640/
    package.json
    mlx90640/
        __init__.py
        utils.py

Le fichier package.json spécifie l’emplacement des fichiers à installer ainsi que d’autres dépendances

{
  "urls": [
    ["mlx90640/__init__.py", "mlx90640/__init__.py"],
    ["mlx90640/utils.py", "mlx90640/utils.py"]
  ],
  "deps": [
    ["collections-defaultdict", "latest"],
    ["os-path", "latest"],
    ["github:org/micropython-additions", "main"],
    ["gitlab:org/micropython-otheradditions", "main"]
  ],
  "version": "0.2"
}

La liste urls spécifie les fichiers à installer selon

"urls": [
    [destination_path, source_url]
    ...

où destination_path est l’emplacement et le nom du fichier à installer sur l’appareil et source_url est l’URL du fichier à installer. L’URL source serait généralement spécifiée relativement au répertoire contenant le fichier package.json, mais peut aussi être une URL absolue, par ex.

["mlx90640/utils.py", "github:org/micropython-mlx90640/mlx90640/utils.py"]

Le paquet dépend de collections-defaultdict et os-path qui seront installés automatiquement depuis micropython-lib. La troisième dépendance installe le contenu tel que défini par le fichier package.json de la branche main du dépôt GitHub org/micropython-additions.

Gel des paquets¶

Lorsqu’un module ou un paquet Python est importé depuis le système de fichiers de l’appareil, il est compilé en bytecode dans la RAM, prêt à être exécuté par la VM. Pour un .mpy file, cette conversion a déjà été effectuée, mais le bytecode se retrouve tout de même dans la RAM.

Pour les appareils à faible mémoire, ou pour les applications volumineuses, il peut être avantageux d’exécuter plutôt le bytecode depuis la ROM (c’est-à-dire la mémoire flash). Cela peut se faire en « gelant » le bytecode dans le micrologiciel MicroPython, qui est ensuite flashé sur l’appareil. Les performances à l’exécution sont les mêmes (bien que l’importation soit plus rapide), mais cela peut libérer des quantités significatives de RAM pour votre programme.

L’inconvénient de cette approche est qu’elle est beaucoup plus lente à développer, car vous devez flasher le micrologiciel à chaque fois, mais cela peut tout de même être utile de geler les dépendances qui ne changent pas souvent.

Le gel se fait en écrivant un fichier manifeste et en l’utilisant dans la compilation, souvent dans le cadre d’une définition de carte personnalisée. Voir le guide Fichiers manifest de MicroPython pour plus d’informations.