PaeoniaCommon/SkillsOdea

Créer un Process

Tous les chemins sont relatifs à la racine du dépôt. Le package se trouve dans process_package/.

Comment fonctionne la classe parente

process_package/toy_process/process.py définit Process :

• __init__(**overrides) définit self.params = {**self.set_parameters(), **overrides}, puis self.steps = self.set_steps().
• set_parameters() et set_steps() sont abstraites. Une classe fille qui n'en possède pas une ne peut pas être instanciée.
• run(context=None) parcourt self.steps dans l'ordre :
  • une instance de Process → step.run(context), imbriqué, avec le même dictionnaire context
  • tout autre appelable → step(context)
  • autre chose → TypeError
• run retourne le dictionnaire context et affiche une trace indentée.

Ne modifiez pas toy_process/ et ne surchargez pas __init__ ou run dans une classe fille.

Règles pour la classe fille

1. Importer from toy_process import Process et en hériter.
2. set_parameters(self) retourne un dict de valeurs par défaut. Utilisez {} s'il n'y en a pas.
3. set_steps(self) retourne une list. Chaque élément est soit :
   • une méthode liée : self.count_words, sans parenthèses, ou
   • une instance de Process : CleanText(lowercase=self.params["lowercase"]).
4. Chaque méthode d'étape a la signature def nom(self, context):.
   • Lisez les paramètres depuis self.params["..."].
   • Lisez et écrivez les données dans context["..."].
   • Ne retournez rien. Les valeurs de retour sont ignorées.
5. Définissez une classe de sous-processus au-dessus de la classe qui l'utilise, ou importez-la.

Modèle

"""Description en une ligne de ce que fait le processus.

Exécutez depuis process_package/ :
    python -m examples.<nom_du_module>
"""

from toy_process import Process


class SousTache(Process):
    def set_parameters(self):
        return {"option": True}

    def set_steps(self):
        return [self.faire_partie]

    def faire_partie(self, context):
        if self.params["option"]:
            context["value"] = context["value"] * 2


class TachePrincipale(Process):
    def set_parameters(self):
        return {"start": 1, "option": True}

    def set_steps(self):
        return [
            self.charger,
            SousTache(option=self.params["option"]),  # sous-processus imbriqué
            self.terminer,
        ]

    def charger(self, context):
        context["value"] = self.params["start"]

    def terminer(self, context):
        context["result"] = f"value est {context['value']}"


if __name__ == "__main__":
    print(TachePrincipale(start=5).run()["result"])

Fichiers à créer

1. process_package/examples/<nom_du_module>.py : le processus, d'après le modèle.
2. process_package/tests/test_<nom_du_module>.py : un test unittest qui appelle .run() et vérifie les clés dans le context retourné. Vérifiez aussi que la surcharge d'un paramètre modifie le résultat.

import unittest

from examples.<nom_du_module> import TachePrincipale


class TestsTachePrincipale(unittest.TestCase):
    def test_execution(self):
        self.assertEqual(TachePrincipale(start=5).run()["result"], "value est 10")

    def test_surcharge_parametre(self):
        self.assertEqual(TachePrincipale(start=5, option=False).run()["result"], "value est 5")


if __name__ == "__main__":
    unittest.main()

Ensuite, vérifiez avec la compétence run-process. Un exemple complet fonctionnel est process_package/examples/word_report.py.