Aller au contenu

Résolveur#

Les résolveurs sont des outils permettant de compléter les workflows en remplaçant un pattern par la valeur calculée.

Utilisation#

Le nom d'un résolveur est donné à son initialisation. Il est possible d'avoir plusieurs résolveurs d'un même type.

A l'utilisation du SDK comme un exécutable, il y a 2 résolveurs d’instanciés :

A l'utilisation comme module, il n'y a aucun résolveur d’instancié. Il faut instancier des résolveurs dans le programme et les ajouter au GlobalResolver.

Dans le fichier de workflow, pour utiliser le résolveur il faut ajouter le pattern permettant d'activer le résolveur selon le type de donnée attendu :

  • Texte : "{nom_du_resolveur.nom_de_la_clef}"
  • Liste: ["_nom_du_resolveur_", "nom_de_la_clef"] ou ["_nom_du_resolveur.nom_de_la_clef"]
  • Dictionnaire : {"_nom_du_resolveur_": "nom_de_la_clef"}

Résolveurs de base#

Il y a 4 résolveurs de base :

  • DictResolver: permet d'insérer les valeurs contenues dans un dictionnaire ;
  • FileResolver: insère les valeurs contenues dans un fichier ;
  • StoreEntityResolver: récupère des informations sur les entités depuis la GPF ;
  • UserResolver: récupère des informations de l'utilisateur courant depuis la GPF.

DictResolver#

Permet de résoudre des paramètres clé -> valeur (pas de sous clef)

Prend en initialisation le dictionnaire contenant les valeurs.

Exemple :

from sdk_entrepot_gpf.workflow.resolver.DictResolver import DictResolver
from sdk_entrepot_gpf.workflow.resolver.GlobalResolver import GlobalResolver

dictionnaire = {
    "ajout_text": "valeur 1",
    "ajout_liste": ["val 1", "val 2"],
    "ajout_dict": {"key1": "val1", "key2": "val2"},
}

# initialisation (instanciation du résolveur + ajout)
dict_resolver = DictResolver("my_dict", dictionnaire)
GlobalResolver().add_resolver(dict_resolver)

# texte à résoudre
text = """
insertion de text ici >{my_dict.ajout_text}<
ici une liste >["_my_dict.ajout_liste"]<
ou une liste >["_my_dict_","ajout_liste"]<
ici un dictionnaire >{"_my_dict_": "ajout_dict"}<
"""

# resolution
print(GlobalResolver().resolve(text))
## affichage
#    insertion de text ici >valeur 1<
#    ici une liste >['val 1', 'val 2']<
#    ou une liste >['val 1', 'val 2']<
#    ici un dictionnaire >{'key1': 'val1', 'key2': 'val2'}<

FileResolver#

Permet de résoudre des paramètres faisant référence à des fichiers : ce résolveur permet d'insérer le contenu d'un fichier au moment de la résolution.

Ce fichier peut être un fichier texte basique, une liste au format JSON ou un dictionnaire au format JSON.

A l'utilisation de ce résolveur, il faut indiquer le chemin du fichier à insérer relativement au chemin indiqué à l'instanciation du résolveur :

  • récupération de texte : {nom_resolver}.str({chemin_fichier})
  • récupération d'une liste : {nom_resolver}.list({chemin_fichier})
  • récupération d'un dictionnaire : {nom_resolver}.dict({chemin_fichier})

Exemple :

from pathlib import Path
from sdk_entrepot_gpf.workflow.resolver.FileResolver import FileResolver
from sdk_entrepot_gpf.workflow.resolver.GlobalResolver import GlobalResolver

# dans le répertoire courant on a les fichiers suivants
## text simple: "text.txt"
# * contenu => "coucou"
## liste: "liste.json"
# * contenu => ["valeur 1", "valeur 2"]
## dictionnaire: "dict.json"
# * contenu => {"k1":"v1", "k2":"v2"}

# initialisation (le résolveur s'appelle "fichier" et cherche les fichiers relativement au répertoire courant)
file_resolver = FileResolver("fichiers", Path("."))
GlobalResolver().add_resolver(file_resolver)

# texte à résoudre
text = """
insertion de text ici >{fichiers.str(text.txt)}<
ici une liste >["_fichiers_","list(liste.json)"]<
ici un dictionnaire >{"_fichiers_":"dict(dict.json)"}<
"""

# resolution
print(GlobalResolver().resolve(text))
## affichage
#   insertion de text ici >coucou<
#   ici une liste >["valeur 1", "valeur 2"]<
#   ici un dictionnaire >{"k1":"v1", "k2":"v2"}<

StoreEntityResolver#

Permet de résoudre des paramètres faisant référence à une entité sur la GPF. Utilisation du pattern store_entity_regex de la configuration.

La structure est légèrement différente: {nom_résolveur}.{entity_type}.{field_type}.{field} ([INFOS ({key}={val}, [...])], [TAGS ({key}={val}, [...])])

avec :

  • entity_type : type de l'entité à récupérer, une des valeurs suivantes : upload|stored_data|processing_execution|offering|processing|configuration|endpoint|static|datastore ;
  • field_type : tags pour récupérer la valeur d'un tag, infos pour récupérer une valeur du dictionnaire décrivant l'entité ;
  • field: si tags nom du tag dont on veut la valeur, si infos clef du dictionnaire dont on veut la valeur ;
  • INFOS ({key}={val}, ...) : (optionnel) filtre sur les entités hors tag, voir la doc de la requête de liste des entités pour connaître la liste des clefs possibles ;
  • TAGS ({key}={val}, ...) : (optionnel) filtre sur les tags (s'il y a des tags sur cette entité).

Si on a plusieurs résultats le premier résultat est utilisé.

Exemple (fonctionne après la livraison des données du tutoriel 2 pour les flux vecteur ) :

from sdk_entrepot_gpf.workflow.resolver.StoreEntityResolver import StoreEntityResolver
from sdk_entrepot_gpf.workflow.resolver.GlobalResolver import GlobalResolver
from sdk_entrepot_gpf.io.Config import Config

# configuration
Config().read("config.ini")

# initialisation
file_resolver = StoreEntityResolver("store_entity")
GlobalResolver().add_resolver(file_resolver)

# texte à résoudre
text = """
id d'un traitement par son nom  >{store_entity.processing.infos._id [INFOS(name=Intégration de données vecteur livrées en base)]}<
id d'un upload par son nom >{store_entity.upload.infos._id [INFOS(name=EXAMPLE_DATASET_VECTOR)]}<
id d'un upload par son nom et tag >{store_entity.upload.infos._id [INFOS(name=EXAMPLE_DATASET_VECTOR), TAGS(tuto=oui)]}<
valeur du tag "tuto" d'un upload par son nom >{store_entity.upload.tags.tuto [INFOS(name=EXAMPLE_DATASET_VECTOR)]}<
"""

# resolution
print(GlobalResolver().resolve(text))
## affichage
#    id d'un traitement par son nom  >0de8c60b-9938-4be9-aa36-9026b77c3c96<
#    id d'un upload par son nom >a2703a39-d3d5-48f2-8372-bbabfc08cdf4<
#    id d'un upload par son nom et tag >a2703a39-d3d5-48f2-8372-bbabfc08cdf4<
#    valeur du tag "tuto" d'un upload par son nom >oui<

UserResolver#

Permet de résoudre des paramètres avec les informations sur l'utilisateur authentifié. Les informations disponibles sont celles renvoyée par la route /users/me.

Classe dérivée de DictRevolver, la plus-value sur la classe DictRevolver est que les infos de l'utilisateur sont directement récupérées par le constructeur de la classe.

from sdk_entrepot_gpf.workflow.resolver.UserResolver import UserResolver
from sdk_entrepot_gpf.workflow.resolver.GlobalResolver import GlobalResolver
from sdk_entrepot_gpf.io.Config import Config

# configuration
Config().read("config.ini")

# initialisation
file_resolver = UserResolver("user")
GlobalResolver().add_resolver(file_resolver)

# texte à résoudre
text = """
nom de l'utilisateur >{user.last_name}<
prénom de l'utilisateur >{user.first_name}<
"""

# resolution
print(GlobalResolver().resolve(text))

Créer son résolveur#

Pour créer votre résolveur, vous devez créer une classe qui hérite de la classe AbstractResolver.

Dans le constructeur de votre classe, il faudra implémenter les tâches qui doivent être effectuées une fois. Par exemple, de récupérer les informations de l'utilisateur (qui, à priori, ne changent pas à chaque résolution).

Dans la fonction resolve de votre classe, il faudra implémenter la résolution du paramétrage à partir de la string string_to_solve avant de retourner la valeur résolue.