Comment créer une interface en ligne de commande avec Python Fire sur Ubuntu 22.04

Introduction

Python Fire est une bibliothèque Python qui vous permet de créer automatiquement des CLIs (interfaces de ligne de commande) à partir d'objets Python. Les CLIs sont des programmes qui prennent des entrées texte depuis la ligne de commande et peuvent être utiles pour votre flux de travail de développement et de débogage. Cela peut être utile pour ceux qui se sentent plus à l'aise avec Bash et la ligne de commande.

Bien que la méthode traditionnelle d'utilisation de argparse de la bibliothèque standard Python puisse accomplir la même chose, avec Python Fire, le prototypage et la maintenance sont considérablement améliorés. Si vous souhaitez avoir ce contrôle complet, consultez ce tutoriel sur la manière d'utiliser argparse pour écrire des programmes en ligne de commande en Python.

Dans ce tutoriel, vous installerez Python Fire et l'utiliserez pour créer des CLIs personnalisés. Ces CLIs peuvent être créés sans avoir à toucher au code source Python. En revanche, pour des scripts plus granulaires qui s'intègrent directement dans vos fonctions et classes, vous importerez Python Fire et travaillerez avec lui dans votre code.

Conditions préalables

• Un serveur Ubuntu 22.04, configuré selon notre guide de configuration initiale pour Ubuntu 22.04, avec un utilisateur non root ayant des privilèges sudo et un pare-feu activé.
• La dernière version de Python 3 installée sur votre machine, avec un environnement virtuel créé, suivant les étapes d'installation de Python 3 et de configuration d'un environnement de programmation sur un serveur Ubuntu 22.04.
• Une familiarité avec le langage Python et comment coder avec. Un bon guide serait cette série sur la façon de coder en Python 3.

Étape 1 — Installer Python Fire

Python Fire est hébergé sur PyPI et peut être installé via pip. Une fois que vous avez suivi les prérequis pour installer Python 3, vous devez avoir un environnement virtuel créé et activé. Si vous ne l'avez pas activé, naviguez vers votre répertoire d'environnements :

cd environments

Puis activez votre environnement virtuel :

source my_env/bin/activate

Cela garantit que votre installation de fire n'affectera pas les installations globales de pip. De plus, les installations de pip à un niveau global peuvent interagir de manière imprévisible avec des gestionnaires de paquets tels que apt. Avec votre environnement virtuel activé, installez fire:

pip install fire

fire peut être invoqué de plusieurs façons, y compris en ligne de commande sans ajouts de code à vos programmes Python. Vous allez explorer cette méthode ensuite, tout en examinant plus tard les usages conventionnels de Python Fire en l'ajoutant à votre code réel pour permettre un contrôle plus granulaire.

Étape 2 — Création d'un CLI à partir d'un programme sans ajouts de code

Tout d'abord, configurez votre fichier Python. Cela peut être désigné par un fichier, un programme ou un script, tout cela est correct.

Pour créer votre nouveau fichier, utilisez nano ou votre éditeur de texte préféré :

nano example.py

Insérez le code Python suivant dans votre nouveau fichier :

def my_name(name):
  return "My name is {name}".format(name=name)

Enregistrez et quittez votre fichier. Avec nano, vous le faites en appuyant sur CTRL+O puis CTRL+X.

C'est une fonction Python appelée my_name qui prend un argument appelé name. Appeler cette fonction avec la variable requise insérera la variable name dans une phrase en utilisant le formatage de chaîne Python. Si vous deviez exécuter ce code dans un interpréteur Python, avec sammy comme variable, cela afficherait “Mon nom est sammy ”.

Avec Python Fire, vous pouvez transformer ce code Python existant en une commande CLI et exécuter ce code tout en insérant une variable, sans avoir à écrire du code Python pour l'invoquer. Entrez votre nouvelle commande CLI, en utilisant -m pour l'appeler en tant que module Python :

python -m fire example my_name --name=sammy

My name is sammy

Ici, vous spécifiez exemple comme le programme Python que vous souhaitez exécuter, avec mon_nom comme la fonction que vous souhaitez exécuter spécifiquement. Étant donné que mon_nom est une fonction qui nécessite un argument appelé nom, vous fournissez l'argument en utilisant le drapeau --nom.

Sans aucun changement à votre code Python, vous avez construit une interface en ligne de commande fonctionnelle et minimale.

Étape 3 — Création d'une CLI à partir d'un programme avec fire importé

La manière la plus conventionnelle d'utiliser Python Fire est d'importer fire dans votre code. Cela permet un contrôle plus granulaire et une structuration plus complexe de votre code pour une utilisation dans un CLI.

Ouvrez votre example.py et insérez le code suivant :

import fire

def my_name(name):
  return "My name is {name}".format(name=name)

if __name__ == '__main__':
  fire.Fire()

Il y a deux changements notables dans le code original. fire est importé au début. Il est ensuite invoqué à la fin avec un appel fire.Fire(), ce qui permet la fonctionnalité CLI. Cela ne se produira que lorsque le programme Python est exécuté directement par l'utilisateur, et ne s'exécutera pas lorsque ce fichier est importé dans un autre script Python. La fonction my_name elle-même reste inchangée.

Enregistrez et quittez votre fichier.

Maintenant, vous pouvez utiliser votre CLI en entrant cette commande :

python example.py my_name sammy

My name is sammy

Parce que fire est maintenant importé dans votre code Python au début, vous n'avez plus besoin d'appeler le module fire dans votre commande via python -m. Au lieu de cela, vous pouvez appeler votre CLI directement à partir du fichier et fournir des arguments pour le nom de la fonction et la variable.

Cela offre une expérience CLI plus propre au détriment de modifications à votre code réel. Ensuite, vous allez créer une CLI directement à partir d'une fonction, au lieu de tout le programme Python.

Étape 4 — Création d'une CLI à partir d'une fonction

Au lieu d'exposer toutes vos fonctions dans votre programme à votre CLI, vous pouvez choisir de créer une CLI à partir de fonctions spécifiques. Insérez ce qui suit dans votre example.py :

import fire

def my_name(name):
  return "My name is {name}".format(name=name)

def my_full_name(first_name, last_name):
    return "My name is {first_name} {last_name}".format(first_name=first_name, last_name=last_name)

if __name__ == '__main__':
  fire.Fire(my_name)

Enregistrez et quittez votre fichier.

Cette fois, il y a deux fonctions. Il y a la fonction originale my_name, et maintenant une seconde my_full_name. La fonction my_full_name est un peu différente car elle prend deux arguments, ce que Python Fire a la flexibilité de permettre. Elle sera utilisée plus tard dans ce tutoriel.

De plus, lorsque fire.Fire est appelé à la fin, il prend désormais un argument. Pour spécifier une fonction que vous souhaitez utiliser, vous l'incluez ici en tant qu'argument. Dans cet exemple, my_name sera celle que vous ciblez pour votre CLI.

Parce que vous avez spécifié la fonction à utiliser dans le CLI, dans la ligne de commande, vous n'avez qu'à fournir le programme et l'argument nécessaires pour exécuter la fonction :

python example.py sammy

My name is sammy

Remarquez que dans la sortie, seule la fonction my_name est retournée, comme vous l'avez spécifié. La nouvelle fonction my_full_name reste inchangée.

Cependant, vous pouvez exposer plusieurs fonctions pour votre interface en ligne de commande (CLI). Pour ce faire, passez un dictionnaire Python à l'appel fire.Fire. Utiliser un dictionnaire comme structure de données clé-valeur vous permet de spécifier plusieurs fonctions pour votre CLI. Ce dictionnaire contiendra toutes les fonctions que vous souhaitez utiliser dans votre CLI. Insérez ce qui suit dans example.py :

import fire

def my_name(name):
  return "My name is {name}".format(name=name)

def my_full_name(first_name, last_name):
    return "My name is {first_name} {last_name}".format(first_name=first_name, last_name=last_name)

if __name__ == '__main__':
  fire.Fire({
      'my_name': my_name,
      'my_full_name': my_full_name,
  })

Vous pouvez maintenant appeler la première fonction via votre interface de ligne de commande :

python example.py my_name sammy

My name is sammy

Ou vous pouvez appeler votre deuxième fonction :

python example.py my_full_name sammy shark

My name is sammy shark

Le seul changement cette fois-ci est le passage du dictionnaire. Avec le dictionnaire, vous pouvez appeler l'une ou l'autre fonction depuis votre interface en ligne de commande (CLI). Ensuite, vous allez créer une CLI à partir d'une classe Python, au lieu d'une fonction.

Étape 5 — Création d'une CLI à partir d'une classe

La façon dont vous structurez votre code, que ce soit en classes ou seulement en fonctions, est une question de préférence et d'adhésion personnelle aux meilleures pratiques. Créer une interface en ligne de commande à partir de classes avec Python Fire n'est pas fondamentalement différent de l'utilisation de fonctions.

Pour créer une classe, vous allez restructurer votre code, en plaçant vos fonctions à l'intérieur comme partie de la classe. Insérez ce qui suit dans example.py

import fire

class Namer(object):
    def my_name(self, name):
        return "My name is {name}".format(name=name)

    def my_full_name(self, first_name, last_name):
        return "My name is {first_name} {last_name}".format(first_name=first_name, last_name=last_name)

if __name__ == '__main__':
  fire.Fire(Namer)

Maintenant, malgré le refactoring de votre code pour utiliser des classes, vous pouvez utiliser la même commande que dans l'étape précédente pour appeler la première fonction via votre CLI :

python example.py my_name sammy

My name is sammy

Ou vous pouvez appeler votre deuxième fonction :

python example.py my_full_name sammy shark

My name is sammy shark

La CLI qui est créée est fonctionnellement identique, utilisant exactement les mêmes commandes que l'étape précédente. L'appel fire.Fire est également le même. La seule chose qui a changé est la restructuration du code pour utiliser des classes.

Python Fire s'adapte à vos préférences, vous permettant de coder de la manière que vous préférez en utilisant des classes ou des fonctions régulières.

Conclusion

Dans ce tutoriel, vous avez installé Python Fire, puis exploré plusieurs façons de créer vos propres CLIs personnalisés en utilisant des programmes, des fonctions et des classes Python. Pour une immersion encore plus approfondie, consultez la documentation officielle. Et pour une approche alternative à la création de CLI en Python, consultez le guide sur la façon d'utiliser argparse pour écrire des programmes en ligne de commande en Python.