Utilisation avancée =================== Build a XML processing chain ---------------------------- Syntaxe ^^^^^^^ .. _chain_example: .. code-block:: xml :linenos: /home/user1/data/lidar_ozone/2015_06_07/ s.* L0_Licel_V01r00 lidar loading 0 /home/user1/data/converted netcdf4_classic s_1, s_2 L'exemple ci-dessus illustre une chaîne de traitement au format XML. La balise du premier niveau ```` est obligatoire est permet de déclarer que nous travaillons bien sur une chaîne de traitement Licorne. Le second niveau contient l'ensemble des blocs. Sur ce niveau, il n'est possible de déclarer que des blocs. `Le bloc`_ est l'unité utilisé dans la chaîne. .. note:: *Licorne est capable de remplir certains paramètres de manière automatique. Si vous utilisez une fonction, les paramètres par défaut peuvent être omis. Si vous utilisez un algorithme évolutif, les paramètres de l'algorithme peuvent aussi être omis.* Le bloc """"""" Le bloc contient les informations pour appeler une fonction. Il doit être composé de deux balises principales. La balise de premier niveau est une balise déclarative. Elle contient un commentaire permettant de nommer le bloc. Sur le niveau suivant, il y aura une unique balise qui est le nom de la fonction utilisé. Immédiatement dans le niveau inférieur, on trouvera le noms et les valeurs des différents paramètres de la fonction utilisée. .. code-block:: xml /home/user1/data/lidar_ozone/2015_06_07/ s.* L0_Licel_V01r00 lidar Ici, ```` est la balise qui permet de déclarer le nom du bloc. Il n'a de sens que pour l'utilisateur et permet de se repérer dans la chaîne. Le nom doit cependant respecter les `spécification du langage XML `_. La balise ````, sur le second niveau, est une des nombreuses fonctionnalités disponibles dans Licorne. Elle est unique dans un bloc et englobe les balises des paramètres et leur valeur respective. Type de données """"""""""""""" Parceque Licorne est intimement liée au langage Python, certains type de données sont reconnus et automatiquement convertis à la lecture d'une fichier chaîne. Ces types sont assignés aux valeurs des balises paramètres des fonctions disponibles dans le framework. Les types disponibles sont: - ``int`` - ``float`` - ``str`` - ``list`` - ``dict`` L'entier est simplement représenté par sa valeur en caractère ascii et le flottant utilise le caractère ``.`` pour séparer la partie entière et la partie fractionnaire: .. code-block:: xml 12 704.45 La chaîne de caractère est détecté dès lors qu'il s'agit d'un ensemble de caractère ascii: .. code-block:: xml ceci est une chaine de caractere La liste est un ensemble de valeurs numériques ou de chaînes de caractère séparées par des virgules: .. code-block:: xml 1, 1.5, 1.833, 2.0833 s_1, s_2, s_3 Utiliser une sortie de bloc """"""""""""""""""""""""""" Dans :ref:`la chaîne d'exemple ` ci-dessus, la valeur du paramètre ```` de la fonction ```` à la ligne 12 est un ensemble de balises XML. Cette syntaxe permet de récupérer la sortie d'un bloc précédant (qui a déjà été éxécuté). .. code-block:: xml La valeur du premier bloc, ````, est le nom exact du bloc dont on souhaite utiliser la sortie. Pour rappel, le nom d'un bloc libre tant qu'il respecte la syntaxe de la norme XML. La valeur du second bloc, ````, est l'index de la sortie de la fonction. Comme il peut y avoir plusieurs sorties pour une même fonction, il faut préciser laquelle doit être utiliser. Il s'agit d'un index basé en zéro (comme une liste en Python). .. important:: Il faut vérifier ce que renvoie une fonction pour déterminer l'index de la sortie à utiliser. Voir :doc:`licorne` .. warning:: Certaines fonctions ne font que modifier l'objet et ne le renvoie pas en sortie. Il faut donc continuer à utiliser la sortie du dernier bloc qui renvoie l'objet. Voir les :ref:`examples` Utiliser de nouvelles fonctionnalitées """""""""""""""""""""""""""""""""""""" Il est possible que vous soyez limiter par les fonctions proposées dans Licorne. Il faut alors programmer soit même ces fonctions en python et les intégrés à la chaîne de traitement XML comme si elle faisait partie du framework. Vous devez insérer les balises suivantes dans un bloc de la chaîne de traitement avant de pouvoir en utiliser ses fonctions: .. code-block:: xml La première balise ```` est obligatoire est sert à préciser le chemin vers le module python contenant les fonctions à utiliser. La seconde balise ````, qui est optionnelle, permet de mettre une expression régulière pour importer uniquement les fonctions dont on a besoin. Si nous voulons utiliser la fonction du fichier ``module.py``, nous devons d'abord faire l'import du module avant de pouvoir l'utiliser. .. literalinclude:: module.py Exemple: .. literalinclude:: import_chain.xml :language: xml Ici, le premier bloc importe les fonctions disponibles dans module.py sans faire de filtrage sur les noms de fonctions. Le second bloc charge une geoscene. Le dernier bloc exécute la fonction ``print_description`` du module charger. Installation depuis le *git* ---------------------------- Intégrer un algorithme évolutif ------------------------------- Tester son code ---------------