Cet article vous présente le concept des environnements virtuels en Python, qui sont essentiels pour gérer les dépendances et isoler les projets du système d'exploitation.

Qu'est-ce qu'un environnement virtuel?

Un environnement virtuel est un dossier qui contient :

• Une version spécifique de Python
• Au démarrage, un répertoire site-packages vide

Les environnements virtuels vous aideront à isoler votre projet de l'installation Python du système d'exploitation et d'autres projets.

Utilisation

Pour utiliser les environnements virtuels, vous pouvez suivre les étapes suivantes:

1. Création d'un environnement virtuel: Vous pouvez créer un environnement virtuel à l'aide du module venv fourni avec Python. Ouvrez votre terminal et exécutez:

   python -m venv .venv
   

   Remplacez .venv par le nom de l'environnement souhaité.

2. Activation de l'environnement virtuel: Après avoir créé l'environnement virtuel, vous devez l'activer. La commande varie en fonction de votre système d'exploitation:

   • Sous Windows:

   .venv\Scripts\Activate.ps1
   

   Si vous rencontrez une erreur, vous devrez peut-être exécuter la commande suivante dans votre terminal

   Set-ExecutionPolicy -ExecutionPolicy Bypass -Scope Process -Force; .venv\Scripts\Activate.ps1
   

   • Sous macOS et Linux:

   source .venv/bin/activate
   

Une fois activé, le prompt de votre terminal se modifie pour indiquer que vous travaillez désormais dans l'environnement virtuel.

Exemple:

(.venv) user@machine:~/project$

Remarquez le préfixe (.venv) du prompt du terminal, qui indique que l'environnement virtuel est actif.

Vous pouvez maintenant installer des packages à l'aide de pip. Ils seront installés dans l'environnement virtuel plutôt que dans l'installation globale de Python.

Puis-je utiliser des environnements virtuels dans IRIS?

Bonne question!

La réponse est simple : oui et non.

• Non, puisque IRIS ne prend pas officiellement en charge les environnements virtuels.
• Oui, puisque après avoir lu tous ces articles, nous connaissons désormais le fonctionnement de Python, celui d'IRIS et nous savons ce qu'est un environnement virtuel. Nous sommes donc peut-être en mesure de simuler un environnement virtuel dans IRIS en utilisant les configurations et les paramètres appropriés.

Comment simuler un environnement virtuel dans IRIS?

Un environnement virtuel comprend deux éléments:

• Une version spécifique de Python
• Un répertoire site-packages

IRIS dispose d'un système appelé Flexible Python Runtime (environnement d'exécution Python flexible) qui nous donne la possibilité suivante:

• utiliser une version spécifique de Python.
• mettre à jour le sys.path pour inclure un répertoire spécifique.

Nous pouvons donc simuler un environnement virtuel dans IRIS en utilisant leFlexible Python Runtime et en configurant le sys.path pour inclure un répertoire spécifique et une version spécifique de Python. 🥳

La configuration d'un Flexible Python Runtime dans IRIS est facile, vous pouvez suivre les étapes décrites dans la documentation IRIS.

En bref, il faut:

1. Configurez PythonRuntimeLibrary pour l'orienter vers le fichier lib python de la version Python spécifique que vous souhaitez utiliser.

   Exemple:

   • Windows : C:\Program Files\Python311\python3.dll (Python 3.11 sous Windows)
   • Linux : /usr/lib/x86_64-linux-gnu/libpython3.11.so.1.0 (Python 3.11 sous Ubuntu 22.04 avec architecture x86)

2. Configurez le PythonPath pour l'orienter vers le répertoire site-packages de la version Python spécifique que vous souhaitez utiliser.

   Exemple:

   • Utilisez le répertoire site-packages de votre environnement virtuel, qui se trouve généralement dans le répertoire .venv/lib/python3.x/site-packages.

⚠️ Ainsi, toute votre instance IRIS sera configurée pour l'utilisation d'une version spécifique de Python et d'un répertoire site-packages spécifique.

🩼 Limitation :

• Vous n'obtiendrez pas exactement le même sys.path que pour un environnement virtuel, car IRIS ajoutera automatiquement certains répertoires au sys.path, tels que <installation_directory>/lib/python et d'autres que nous avons examinés dans l'article sur les modules.

🤫 Si vous souhaitez automatiser cette opération, vous pouvez utiliser ce formidable package: iris-embedded-python-wrapper

Pour l'utiliser, il faut:

Que vous soyez dans votre environnement venv, puis installez le package:

(.venv) user@machine:~/project$
pip install iris-embedded-python-wrapper

Ensuite, liez simplement ce venv à IRIS à l'aide de la commande suivante:

(.venv) user@machine:~/project$
bind_iris

Vous verrez le message suivant:

INFO:iris_utils._find_libpyton:Created backup at /opt/intersystems/iris/iris.cpf.0f4a1bebbcd4b436a7e2c83cfa44f515
INFO:iris_utils._find_libpyton:Created merge file at /opt/intersystems/iris/iris.cpf.python_merge
IRIS Merge of /opt/intersystems/iris/iris.cpf.python_merge into /opt/intersystems/iris/iris.cpf
INFO:iris_utils._find_libpyton:PythonRuntimeLibrary path set to /usr/local/Cellar/python@3.11/3.11.13/Frameworks/Python.framework/Versions/3.11/Python
INFO:iris_utils._find_libpyton:PythonPath set to /xxxx/.venv/lib/python3.11/site-packages
INFO:iris_utils._find_libpyton:PythonRuntimeLibraryVersion set to 3.11

Pour dissocier le venv d'IRIS, vous pouvez utiliser la commande suivante:

(.venv) user@machine:~/project$
unbind_iris

Conclusion

Vous avez découvert les avantages de l'utilisation d'environnements virtuels en Python, la manière de les créer et de les utiliser, ainsi que la manière de simuler un environnement virtuel dans IRIS à l'aide du Flexible Python Runtime.

Découvrez comment concevoir des agents IA évolutifs et autonomes qui combinent raisonnement, recherche vectorielle et intégration d'outils à l'aide de LangGraph.

C'est trop long, vous n'avez pas lu

• Les agents IA sont des systèmes proactifs qui combinent mémoire, contexte et initiative pour automatiser des tâches dépassant le simple champ d'action des chatbots.
• LangGraph est un framework qui nous permet de créer des workflows d'IA complexes, en utilisant des nœuds (tâches) et des arêtes (connexions) avec une gestion d'état intégrée.
• Ce guide vous explique comment créer un agent de support client basé sur l'IA qui classe les priorités, identifie les sujets pertinents et détermine si une escalade ou une réponse automatique est nécessaire.

Alors, les agents IA, c'est quoi exactement?

Soyons réalistes, le terme "agents IA" peut faire penser à des robots qui vont envahir votre bureau. En réalité, il s'agit de vos assistants proactifs qui peuvent rationaliser des flux de travail complexes et éliminer les tâches répétitives. Considérez-les comme la prochaine étape évolutive après les chatbots: ils ne se contentent pas d'attendre des instructions, ils lancent des actions, coordonnent plusieurs étapes et s'adaptent tout au long du processus.

Autrefois, créer un système "intelligent" signifiait jongler avec différents modèles pour la compréhension du langage, la génération de code, la recherche de données, etc., puis les assembler à la va-vite. Auparavant, vous passiez la moitié de votre temps dans l'enfer de l'intégration, et l'autre moitié à corriger les erreurs.

Les agents renversent la tendance. Ils regroupent le contexte, l'initiative et l'adaptabilité en un seul flux orchestré. Il ne s'agit pas seulement d'automatisation, mais d'intelligence au service d'une mission. Et grâce à des frameworks tels que LangGraph, la création de votre propre équipe d'agents peut même devenir... oserais-je dire, amusante?

LangGraph, c'est quoi exactement?

LangGraph est un cadre innovant qui révolutionne la manière dont nous construisons des applications complexes impliquant des modèles linguistiques à grande échelle (LLM).

Imaginez que vous dirigez un orchestre: chaque instrument (ou "nœud") doit savoir quand entrer, à quel volume jouer et dans quel ordre. LangGraph, dans ce cas**,** est votre baguette, qui vous donne les informations suivantes:

• Structure graphique: utilise une structure graphique avec des nœuds et des arêtes, permettant aux développeurs de concevoir des flux de travail flexibles et non linéaires qui s'adaptent aux branches et aux boucles. Elle reflète les processus décisionnels complexes qui ressemblent au fonctionnement des voies neuronales.
• Gestion d'état: LangGraph offre des outils intégrés pour la persistance d'état et la récupération d'erreurs, simplifiant la gestion des données contextuelles à différentes étapes d'une application. Il peut basculer efficacement entre la mémoire à court terme et la mémoire à long terme, améliorant ainsi la qualité des interactions grâce à des outils tels que Zep.
• Intégration d'outils: Avec LangGraph, les agents LLM peuvent facilement collaborer avec des services ou des bases de données externes pour récupérer des données du monde réel, améliorant ainsi la fonctionnalité et la réactivité de vos applications.
• Human-in-the-Loop: Au-delà de l'automatisation, LangGraph s'adapte aux interventions humaines dans les flux de travail, qui sont essentielles pour les processus décisionnels nécessitant une supervision analytique ou une réflexion éthique.

Lorsque vous créez un chatbot doté d'une mémoire réelle, un moteur d'histoires interactives ou une équipe d'agents chargés de résoudre un problème complexe, LangGraph transforme les tâches fastidieuses en une machine à états simple et visuelle.

Pour commencer

Pour commencer à utiliser LangGraph, vous aurez besoin d'une configuration de base qui implique généralement l'installation de bibliothèques essentielles telles que langgraph et langchain-openai. Ensuite, vous pourrez définir les nœuds (tâches) et les bords (connexions) au sein du graphe, en mettant efficacement en œuvre des points de contrôle pour la mémoire à court terme et en utilisant Zep pour les besoins en mémoire plus persistants.

Lorsque vous utilisez LangGraph, gardez à l'esprit les remarques suivantes:

• Flexibilité de conception: Tirez parti de la puissante structure graphique pour prendre en compte les ramifications et les interactions potentielles du flux de travail qui ne sont pas strictement linéaires.
• Interaction prudente avec les outils: Améliorez les capacités du LLM à l'aide d'outils externes, mais ne les remplacez pas. Fournissez à chaque outil des descriptions complètes pour permettre une utilisation précise.
• Utilisation de solutions de mémoire riches: Utilisez la mémoire de manière efficace, soyez attentif à la fenêtre contextuelle du LLM et envisagez d'intégrer des solutions externes pour la gestion automatiquedu contenu factuel.

Nous avons abordé les bases de LangGraph, passons maintenant à un exemple pratique. Pour cela, nous allons développer un agent IA spécialement conçu pour le support client.

Cet agent recevra les demandes par e-mail, analysera la description du problème dans le corps du message, puis déterminera la priorité de la demande et le sujet/la catégorie/le secteur approprié.

Alors, attachez vos ceintures et c'est parti!

Pour commencer, nous devons définir ce qu'est un "outil". Vous pouvez le considérer comme un "assistant manager" spécialisé pour votre agent, lui permettant d'interagir avec des fonctionnalités externes.

Le décorateur @tool est ici essentiel. LangChain simplifie la création d'outils personnalisés, ce qui signifie que vous définissez d'abord une fonction Python, puis appliquez le décorateur @tool.

Illustrons cela en créant notre premier outil. Cet outil aidera l'agent à classer la priorité d'un ticket d'assistance informatique en fonction du contenu de l'e-mail:

    from langchain_core.tools import tool
    
    @tool
    def classify_priority(email_body: str) -> str:
        """Classify the priority of an IT support ticket based on email content."""
        prompt = ChatPromptTemplate.from_template(
            """Analyze this IT support email and classify its priority as High, Medium, or Low.
            
            High: System outages, security breaches, critical business functions down
            Medium: Non-critical issues affecting productivity, software problems
            Low: General questions, requests, minor issues
            
            Email: {email}
            
            Respond with only: High, Medium, or Low"""
        )
        chain = prompt | llm
        response = chain.invoke({"email": email_body})
        return response.content.strip()

Excellent! Nous avons maintenant une invite qui demande à l'IA de recevoir le corps de l'e-mail, de l'analyser et de classer sa priorité comme Élevée, Moyenne ou Faible.

C'est tout! Vous venez de créer un outil accessible à votre agent!

Créons maintenant un outil similaire pour identifier le sujet principal (ou la catégorie) de la demande de support:

    @tool
    def identify_topic(email_body: str) -> str:
        """Identify the main topic/category of the IT support request."""
        prompt = ChatPromptTemplate.from_template(
            """Analyze this IT support email and identify the main topic category.
            
            Categories: password_reset, vpn, software_request, hardware, email, network, printer, other
            
            Email: {email}
            
            Respond with only the category name (lowercase with underscores)."""
        )
        chain = prompt | llm
        response = chain.invoke({"email": email_body})
        return response.content.strip()

Nous devons maintenant créer un état, et dans LangGraph, cette petite partie est plutôt importante.

Considérez-le comme le système nerveux central de votre graphe. C'est ainsi que les nœuds communiquent entre eux, en se passant des petits mots comme des surdoués à l'école.

Selon la documentation:

“Un état est une structure de données partagée qui représente l'instantané actuel de votre application.”

Et en pratique? L'état est un message structuré qui circule entre les nœuds. Il transporte le résultat d'une étape comme entrée pour la suivante. En gros, c'est le ciment qui maintient l'ensemble de votre flux de travail.

Par conséquent, avant de construire le graphique, nous devons d'abord définir la structure de notre état. Dans cet exemple, notre état sera composé des éléments suivants:

• La demande de l'utilisateur (corps de l'email)
• La priorité attribuée
• Le sujet identifié (catégorie)

C'est simple et clair, vous pouvez donc vous déplacer à travers le graphe comme un pro.

    from typing import TypedDict

    # Définition de la structure d'état
    class TicketState(TypedDict):
        email_body: str
        priority: str
        topic: str
        
    
    # Initialisation d'état
    initial_state = TicketState(
        email_body=email_body,
        priority="",
        topic=""
    )

Nœuds et bords: Composants clés de LangGraph

Les éléments fondamentaux de LangGraph sont les nœuds et les bords.

• Nœuds: Il s'agit des unités opérationnelles du graphe qui effectuent le travail proprement dit. Un nœud se compose généralement d'un code Python capable d'exécuter n'importe quelle logique, qu'il s'agisse de calculs ou d'interactions avec des modèles linguistiques (LLM) ou des intégrations externes. Les nœuds sont essentiellement similaires aux fonctions ou agents individuels de la programmation traditionnelle.
• Bords: les bords définissent le flux d'exécution entre les nœuds et déterminent ce qui se passe ensuite. Elles agissent comme des connecteurs qui permettent à l'état de passer d'un nœud à l'autre en fonction de conditions prédéfinies. Dans le contexte de LangGraph, les bords sont essentiels pour orchestrer la séquence et le flux de décision entre les nœuds.

Pour comprendre le fonctionnement des bords, prenons l'exemple simple d'une application de messagerie:

• Nœuds sont similaires aux utilisateurs (ou à leurs appareils) qui participent activement à une conversation.
• Bords symbolisent les fils de discussion ou les connexions entre les utilisateurs qui facilitent la communication.

Lorsqu'un utilisateur sélectionne un fil de discussion pour envoyer un message, un bord est créée, le reliant à un autre utilisateur. Chaque interaction, qu'il s'agisse d'envoyer un message textuel, vocal ou vidéo, suit une séquence prédéfinie, comparable au schéma structuré de l'état de LangGraph. Cela garantit l'uniformité et l'interprétabilité des données transmises le long des bords.

Contrairement à la nature dynamique des applications pilotées par les événements, LangGraph utilise un schéma statique qui reste cohérent tout au long de l'exécution. Il simplifie la communication entre les nœuds, permettant aux développeurs de s'appuyer sur un format stable, garantissant ainsi une communication fluide au niveau des bords.

Conception d'un flux de travail de base

L'ingénierie des flux dans LangGraph peut être conceptualisée comme la conception d'une machine d'état. Dans ce paradigme, chaque nœud représente un état ou une étape de traitement distinct, tandis que les arêtes définissent les transitions entre ces états. Cette approche est particulièrement avantageuse pour les développeurs qui cherchent à trouver un équilibre entre les séquences de tâches déterministes et les capacités décisionnelles dynamiques de l'IA. Commençons à construire notre flux en initialisant StateGraph avec la classe TicketState que nous avons définie précédemment.

    from langgraph.graph import StateGraph, START, END
    
    workflow = StateGraph(TicketState)

Ajout de nœuds: Les nœuds sont des éléments fondamentaux, définis pour exécuter des tâches spécifiques telles que la classification de la priorité d'un ticket ou l'identification de son sujet.

Chaque fonction de nœud reçoit l'état actuel, effectue son opération et renvoie un dictionnaire permettant de mettre à jour l'état:

   def classify_priority_node(state: TicketState) -> TicketState:
        """Node to classify ticket priority."""
        priority = classify_priority.invoke({"email_body": state["email_body"]})
        return {"priority": priority}

    def identify_topic_node(state: TicketState) -> TicketState:
        """Node to identify ticket topic."""
        topic = identify_topic.invoke({"email_body": state["email_body"]})
        return {"topic": topic}
        
        
    workflow.add_node("classify_priority", classify_priority_node)
    workflow.add_node("identify_topic", identify_topic_node)

Les méthodes classify_priority_node et identify_topic_node modifieront le TicketState et enverront la saisie du paramètre.

Création des bords: Définissez les bords pour connecter les nœuds:

    workflow.add_edge(START, "classify_priority")
    workflow.add_edge("classify_priority", "identify_topic")
    workflow.add_edge("identify_topic", END)

The classify_priority establishes the start, whereas the identify_topic determines the end of our workflow so far.

Compilation et exécution: Une fois les nœuds et les bords configurés, compilez le flux de travail et exécutez-le.

    graph = workflow.compile()
    result = graph.invoke(initial_state)

Très bien! Vous pouvez également générer une représentation visuelle de notre flux LangGraph.

graph.get_graph().draw_mermaid_png(output_file_path="graph.png")

Si vous exécutez le code jusqu'à ce point, vous obtiendrez un graphe similaire au suivant:

Cette illustration visualise une exécution séquentielle: démarrage, suivi du classement des priorités, puis identification du sujet et enfin terminaison.

L'un des aspects les plus puissants de LangGraph est sa flexibilité, qui nous permet de créer des flux et des applications plus complexes. Par exemple, nous pouvons modifier le flux de travail pour ajouter des bords depuis START vers les deux nœuds avec la ligne suivante:

    workflow.add_edge(START, "classify_priority")
    workflow.add_edge(START, "identify_topic")

Cette modification aura pour conséquence que l'agent exécutera simultanément classify_priority et identify_topic.

Une autre fonctionnalité très utile de LangGraph est la possibilité d'utiliser des bords conditionnels. Ils permettent au flux de travail de se ramifier en fonction de l'évaluation de l'état actuel, ce qui permet un routage dynamique des tâches.

Améliorons notre flux de travail. Nous allons créer un nouvel outil qui analyse le contenu, la priorité et le sujet de la demande afin de déterminer s'il s'agit d'un problème hautement prioritaire nécessitant une escalade (c'est-à-dire l'ouverture d'un ticket pour être traité par une équipe humaine). Si ce n'est pas le cas, une réponse automatisée sera générée pour l'utilisateur.

    @tool
    def make_escalation_decision(email_body: str, priority: str, topic: str) -> str:
        """Decide whether to auto-respond or escalate to IT team."""
        prompt = ChatPromptTemplate.from_template(
            """Based on this IT support ticket, decide whether to:
            - "auto_respond": Send an automated response for simple/common or medium priority issues
            - "escalate": Escalate to the IT team for complex/urgent issues
            
            Email: {email}
            Priority: {priority}
            Topic: {topic}
            
            Consider: High priority items usually require escalation, while complex technical issues necessitate human review.
            
            Respond with only: auto_respond or escalate"""
        )
        chain = prompt | llm
        response = chain.invoke({
            "email": email_body,
            "priority": priority,
            "topic": topic
        })
        return response.content.strip()
        

De plus, si la demande est jugée de priorité faible ou moyenne (ce qui entraîne une décision "auto_respond"), nous effectuerons une recherche vectorielle pour récupérer les réponses historiques. Ces informations seront ensuite utilisées pour générer une réponse automatisée appropriée. Cependant, cela nécessitera deux outils supplémentaires:

    @tool
    def retrieve_examples(email_body: str) -> str:
        """Retrieve relevant examples from past responses based on email_body."""
        try:
            examples = iris.cls(__name__).Retrieve(email_body)
            return examples if examples else "No relevant examples found."
        except:
            return "No relevant examples found."

    @tool
    def generate_reply(email_body: str, topic: str, examples: str) -> str:
        """Generate a suggested reply based on the email, topic, and RAG examples."""
        prompt = ChatPromptTemplate.from_template(
            """Generate a professional IT support response based on:
            
            Original Email: {email}
            Topic Category: {topic}
            Example Response: {examples}
            
            Create a helpful, professional response that addresses the user's concern.
            Keep it concise and actionable."""
        )
        chain = prompt | llm
        response = chain.invoke({
            "email": email_body,
            "topic": topic,
            "examples": examples
        })
        return response.content.strip()

Maintenant, définissons les nœuds correspondants à ces nouveaux outils:

    
    def decision_node(state: TicketState) -> TicketState:
        """Node to decide on escalation or auto-response."""
        decision = make_escalation_decision.invoke({
            "email_body": state["email_body"],
            "priority": state["priority"],
            "topic": state["topic"]
        })
        return {"decision": decision}
        
    
    def rag_node(state: TicketState) -> TicketState:
        """Node to retrieve relevant examples using RAG."""
        examples = retrieve_examples.invoke({"email_body": state["email_body"]})
        return {"rag_examples": examples}

    def generate_reply_node(state: TicketState) -> TicketState:
        """Node to generate suggested reply."""
        reply = generate_reply.invoke({
            "email_body": state["email_body"],
            "topic": state["topic"],
            "examples": state["rag_examples"]
        })
        return {"suggested_reply": reply}
        
    
    def execute_action_node(state: TicketState) -> TicketState:
        """Node to execute final action based on decision."""
        if state["decision"] == "escalate":
            action = f"🚨 ESCALATED TO IT TEAM\nPriority: {state['priority']}\nTopic: {state['topic']}\nTicket created in system."
            print(f"[SYSTEM] Escalating ticket to IT team - Priority: {state['priority']}, Topic: {state['topic']}")
        else:
            action = f"✅ AUTO-RESPONSE SENT\nReply: {state['suggested_reply']}\nTicket logged for tracking."
            print(f"[SYSTEM] Auto-response sent to user - Topic: {state['topic']}")
        
        return {"final_action": action}
        
        
        
    workflow.add_node("make_decision", decision_node)
    workflow.add_node("rag", rag_node)
    workflow.add_node("generate_reply", generate_reply_node)
    workflow.add_node("execute_action", execute_action_node)

Le bord conditionnel utilisera alors le résultat du nœud make_decision pour diriger le flux:

    workflow.add_conditional_edges(
        "make_decision",
        lambda x: x.get("decision"),
        {
            "auto_respond": "rag",
            "escalate": "execute_action"
        }
    )

Si l'outil make_escalation_decision (via decision_node) renvoie "auto_respond", le workflow passe par le nœud rag (pour récupérer des exemples), puis par generate_reply (pour rédiger la réponse) et enfin par execute_action (pour enregistrer la réponse automatique).

En revanche, si la décision est “escalate”, le flux contournera le RAG et passera aux étapes de génération, passant directement à execute_action pour gérer l'escalade. Pour compléter le graphe en ajoutant les bords standard restants, procédez comme suit:

    workflow.add_edge("rag", "generate_reply")
    workflow.add_edge("generate_reply", "execute_action")
    workflow.add_edge("execute_action", END)

Remarque sur le jeu de données: pour ce projet, le jeu de données utilisé pour alimenter la génération augmentée par récupération (RAG) provient du jeu de données Customer Support Tickets dataset on Hugging Face. Le jeu de données a été filtré afin de n'inclure que les éléments classés dans la catégorie de support technique 'Technical Support' et limité aux saisies en anglais English. Cela a permis de garantir que le système RAG ne récupère que des exemples très pertinents et spécifiques au domaine pour les tâches de support technique.

À ce stade, notre graphique devrait ressembler au suivant:

Lorsque vous exécutez ce graphe avec un e-mail qui entraîne une classification de priorité élevée et une décision "escalate", vous obtenez la réponse suivante:

Au même moment, une demande classée comme faible priorité et donnant lieu à une décision « auto_respond » déclenchera une réponse similaire à la suivante:

Alors... Est-ce que tout est rose?

Pas tout à fait. Il y a quelques obstacles à éviter:

• Confidentialité des données: Soyez prudent avec les informations sensibles, ces agents nécessitent des mesures de protection.
• Coûts informatiques: Certaines configurations avancées nécessitent des ressources importantes.
• Hallucinations: Les LLM peuvent parfois inventer des choses (même s'ils restent plus intelligents que la plupart des stagiaires).
• Non-déterminisme: Une même saisie peut donner des résultats différents, ce qui est excellent pour la créativité, mais problématique pour les processus rigoureux.

Cependant, la plupart de ces lacunes peuvent être comblées grâce à une bonne planification, aux bons outils et, bien sûr, à un peu de réflexion.

LangGraph transforme les agents IA, qui ne sont encore que des mots à la mode, en solutions fonctionnelles et tangibles. Que vous souhaitiez automatiser votre service client, traiter vos tickets informatiques ou créer des applications autonomes, ce framework rend tout cela possible et même agréable.

Avez-vous des questions ou des commentaires? Parlons-en. La révolution de l'IA a besoin de créateurs comme vous.

Salut la Communauté!
Dans cet article, je présenterai le framework web Python Streamlit.
Ci-dessous, vous trouverez les sujets que nous aborderons:

• 1-Introduction au framework web Streamlit
• 2-Installation du module Streamlit
• 3-Lancement de l'application Streamlit
• 4-Commandes de base de Streamlit
• 5-Affichage du contenu multimédia 
• 6-Widgets d'input
• 7-Affichage des progrès et de l'état
• 8-Barre latérale et conteneur
• 9-Visualisation des données
• 10-Affichage de DataFrame

Commençons donc par le premier sujet.
1-Introduction au framework web Python Streamlit 

Streamlit est un framework Python open-source qui permet aux data scientists et aux ingénieurs en apprentissage automatique de créer des applications web interactives de manière simple et rapide.
Grâce à sa syntaxe simple et à son intégration facile avec les bibliothèques de science des données les plus répandues, Streamlit est devenu la référence en matière de prototypage et de partage de projets.

Pour plus de détails, veuillez consulterDocumentations Streamlit

2-Installation du module Streamlit

Pour commencer à construire notre application Web Streamlit, il est nécessaire d'installer le module à l'aide du programme d'installation de paquets pip.

Pour installer Streamlit, exécutez la commande suivante:

pip install streamlit

La commande pour tester l'installation se trouve ci-dessous: 

streamlit hello

Lorsque la commande mentionnée ci-dessus est saisissée dans le terminal, la page suivante s'ouvre automatiquement:

3-Lancement de l'application Streamlit

Streamlit est simple à utiliser. Tout d'abord, on ajoute quelques commandes Streamlit à un script Python ordinaire, puis on le lance à l'aide de streamlit run:

streamlit run your_python_file.py 

Aussitôt que vous exécutez le script, un serveur Streamlit local s'active et votre application s'ouvre dans un nouvel onglet de votre navigateur web par défaut.  Notez que l'application est votre canevas, où vous dessinerez des graphiques, des textes, des widgets, des tableaux, etc.

Une autre façon d'exécuter Streamlit est de le faire en tant que module Python. Cela peut s'avérer utile pour configurer un IDE, par exemple PyCharm, afin qu'il fonctionne avec Streamlit:

python -m streamlit run your_python_file.py

N'oubliez pas de sauvegarder le fichier source chaque fois que vous souhaitez mettre à jour votre application. Dans ce cas, Streamlit détecte les changements éventuels et vous demande si vous souhaitez réexécuter votre application. Sélectionnez "Always rerun" (toujours réexécuter) en haut à droite de votre écran pour mettre à jour automatiquement votre application à chaque fois que vous modifiez son code source. Cela vous permettra de travailler dans une boucle interactive rapide : vous saisissez du code, vous l'enregistrez, vous l'essayez en direct, puis vous saisissez à nouveau du code, vous l'enregistrez, vous l'essayez, et ainsi de suite jusqu'à ce que vous soyez satisfait des résultats. Cette boucle étroite entre le codage et la visualisation des résultats en direct est l'une des façons dont Streamlit vous facilite la vie.

4-Commandes de base de Streamlit

Cette fonction permet d'ajouter à une application web des chaînes formatées, des graphiques de Matplotlib, des diagrammes d'Altair, des graphiques de Plotly, des cadres de données, des modèles de Keras et beaucoup d'autres.

Créons le fichier main.py ci-dessous:

import streamlit as st
st.write("Hello ,let's learn how to build a streamlit app together")

Lancez le fichier main.py en exécutant la commande suivante:

streamlit run main.py

st.title() : Cette fonction permet d'ajouter un titre à l'application.
st.header() : Cette fonction est utilisée pour attribuer l'en-tête d'une section.
st.markdown() : Cette fonction est utilisée pour définir la démarque d'une section. 
st.subheader(): Cette fonction est utilisée pour définir le sous-titre d'une section.
st.caption(): Cette fonction est utilisée pour écrire des légendes.
st.code(): Cette fonction est utilisée pour définir un code.  
st.latex(): Cette fonction affiche des expressions mathématiques formatées en LaTeX. 

import streamlit as st
st.title("This is the app title")
st.header("This is the header")
st.markdown("This is the markdown")
st.subheader("This is the subheader")
st.caption("This is the caption")
st.code("x = 2021")
st.latex(r''' a+a r^1+a r^2+a r^3 ''')

5-Affichage du contenu multimédia 

Nous avons énuméré ci-dessous quelques fonctions permettant d'afficher des images, des vidéos et des fichiers audio.

st.image(): Cette fonction est utilisée pour représenter une image.
st.audio(): Cette fonction est utilisée pour afficher un fichier audio. 
st.video(): Cette fonction est utilisée pour afficher une vidéo.

import streamlit as st
st.subheader("Image :")
st.image("kid.jpg")
st.subheader("Audio :")
st.audio("audio.mp3")
st.subheader("Video :")
st.video("video.mp4")

6-Widgets d'input

Les widgets sont les composants les plus importants de l'interface utilisateur. Streamlit dispose de plusieurs widgets qui vous permettent de créer de l'interactivité directement dans vos applications grâce à des boutons, des curseurs, des saisies de texte, etc.

st.checkbox(): Cette fonction renvoie une valeur booléenne. Lorsque la case est cochée, elle renvoie la valeur True (vrai). Sinon, elle renvoie une valeur False (Faux).
st.button(): Cette fonction permet d'afficher un widget de type bouton. 
st.radio(): Cette fonction permet d'afficher un widget de type bouton radio 
st.selectbox(): Cette fonction permet d'afficher un widget de type sélection. 
st.multiselect(): Cette fonction est utilisée pour afficher un widget de sélection multiple. 
st.select_slider(): Cette fonction est utilisée pour afficher un widget de sélection. 
st.slider(): Cette fonction est utilisée pour afficher un widget de courseur.

import streamlit as st
st.checkbox('Yes')
st.button('Click Me')
st.radio('Pick your gender', ['Male', 'Female'])
st.selectbox('Pick a fruit', ['Apple', 'Banana', 'Orange'])
st.multiselect('Choose a planet', ['Jupiter', 'Mars', 'Neptune'])
st.select_slider('Pick a mark', ['Bad', 'Good', 'Excellent'])
st.slider('Pick a number', 0, 50)

st.number_input(): Cette fonction affiche un widget de saisie numérique..
st.text_input(): Cette fonction expose un widget de saisie de texte.
st.date_input(): Cette fonction affiche un widget de saisie de date pour choisir une date..
st.time_input(): Cette fonction affiche un widget de saisie de l'heure pour choisir une heure.
st.text_area(): Cette fonction montre un widget de saisie de texte avec plus d'une ligne de texte.
st.file_uploader(): Cette fonction est exploitée pour démontrer un widget de téléchargement de fichiers.
st.color_picker(): Cette fonction est exploitée pour démontrer un widget de téléchargement de fichiers.

import streamlit as st
st.number_input('Pick a number', 0, 10)
st.text_input('Email address')
st.date_input('Traveling date')
st.time_input('School time')
st.text_area('Description')
st.file_uploader('Upload a photo')
st.color_picker('Choose your favorite color')

7-Affichage des progrès et de l'état

Nous allons maintenant expliquer comment ajouter une barre de progression et des messages d'état tels qu'erreur et succès à notre application.

st.balloons(): Cette fonction est utilisée pour afficher des ballons de célébration. 
st.progress(): Cette fonction est utilisée pour afficher une barre de progression. 
st.spinner(): Cette fonction est utilisée pour afficher un message d'attente temporaire pendant l'exécution.

import streamlit as st
import time
st.balloons()  # Ballons pour une célébration
st.subheader("Progress bar")
st.progress(10)  # Barre de progression
st.subheader("Wait the execution")
with st.spinner('Wait for it...'):
time.sleep(10)  # Simulation d'un délai de processus

st.success(): Cette fonction affiche un message de succès.
st.error(): Cette fonction est utilisée pour afficher un message d'erreur. 
st.warning(): Cette fonction est utilisée pour afficher un message d'avertissement.
st.info(): Cette fonction révèle un message d'information.<
st.exception(): Cette fonction est utilisée pour afficher un message d'exception.

import streamlit as st
st.success("You did it!")
st.error("Error occurred")
st.warning("This is a warning")
st.info("It's easy to build a Streamlit app")
st.exception(RuntimeError("RuntimeError exception"))

8-Barre latérale et conteneur

Nous pouvons également créer une barre latérale ou un conteneur sur votre page pour organiser votre application. La hiérarchie et la disposition des pages de votre application peuvent avoir un impact considérable sur le confort d'utilisation. L'organisation de votre contenu permet aux visiteurs de mieux comprendre votre site et d'y naviguer plus facilement. Cela les aide également à trouver plus rapidement ce qu'ils cherchent et augmente la probabilité qu'ils reviennent. 

Barre latérale

Transmettre un élément à st.sidebar()&nbsp permet d'épingler cet élément à gauche, ce qui permet aux utilisateurs de se concentrer sur le contenu et rend l'application plus organisée et plus facile à gérer.

import streamlit as st
st.sidebar.title("This is writter inside sidebar")
st.sidebar.button("Click")
st.sidebar.radio("Pick your gender",["Male","Female"])

Conteneur

st.container() ;est utilisé pour construire un conteneur invisible dans lequel vous pouvez placer des éléments créant une disposition et une hiérarchie utiles.

import streamlit as st
container = st.container()
container.write("This is written inside the container")
st.write("This is written outside the container")

import streamlit as st
import numpy as np
with st.container():
st.write("This is inside the container")
st.bar_chart(np.random.randn(<span class="hljs-number">50</span>, <span class="hljs-number">3</span>))
st.write("This is outside the container")

9-Visualisation des données

La visualisation des données simplifie la narration en rassemblant les données dans un format plus simple, en mettant en évidence les tendances et les valeurs aberrantes. Une bonne visualisation transmet un message narratif, en éliminant le bruit des données et en mettant l'accent sur les informations utiles. Cependant, c'est bien plus compliqué que de simplement habiller un graphique pour l'embellir ou d'ajouter la partie "info" d'une infographie.
Une visualisation de données efficace est un délicat exercice d'équilibre entre la forme et la fonction. Un graphique simple pourrait être trop ennuyeux pour attirer l'attention ou communiquer un message puissant, tandis que la visualisation la plus étonnante pourrait ne pas réussir à transmettre la bonne idée. Les données et les éléments visuels doivent fonctionner ensemble. Cependant, combiner une bonne analyse avec une excellente narration est un art. 

st.pyplot(): Cette fonction est utilisée pour afficher une graphique matplotlib.pyplot.

import streamlit as st
import matplotlib.pyplot as plt
import numpy as np
rand = np.random.normal(1, 2, size=20)
fig, ax = plt.subplots()
ax.hist(rand, bins=15)
st.pyplot(fig)

st.line_chart(): Cette fonction permet d'afficher un graphique linéaire.

import streamlit as st
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 2), columns=['x', 'y'])
st.line_chart(df)

st.bar_chart(): Cette fonction permet d'afficher un diagramme à barres.

import streamlit as st
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 2), columns=['x', 'y'])
st.bar_chart(df)

st.map(): Cette fonction permet d'afficher des cartes dans l'application. Cependant, elle nécessite les valeurs de latitude et de longitude qui ne peuvent pas être nulles/NA.

import pandas as pd
import numpy as np
import streamlit as st
df = pd.DataFrame(
    np.random.randn(500, 2) / [50, 50] + [37.76, -122.4], columns=['lat', 'lon']
)
st.map(df)

10-Affichage de DataFrame

st.dataframe(): Cette commande permet d'afficher un DataFrame sous forme de table interactive. Elle fonctionne avec une variété d'objets de type collection et DataFrame.

import streamlit as st
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(50, 20), columns=("col %d" % i for i in range(20)))
st.dataframe(df)  # Identique à st.write(df)

Vous pouvez également passer un objet Pandas Styler pour modifier le style du DataFrame rendu:

import streamlit as st
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 20),
columns=("col %d" % i for i in range(20)))
st.dataframe(df.style.highlight_max(axis=0))

Summary

Dans cet article, après avoir présenté le framework web Streamlit, j'ai montré comment installer l'application Streamlit et la faire fonctionner. Nous avons également exploré quelques commandes de base, des widgets et des fonctionnalités de visualisation de données.

Dans mon prochain article, nous créerons une application web Streamlit pour nous connecter au jeu de données IRIS et nous explorerons ensemble les concepts avancés de Streamlit.

Merci!

L'accès à un stockage cloud Azure pour charger/télécharger des blobs est assez simple à l'aide des méthodes API de classe %Net.Cloud.Storage.Client désignées ou des adaptateurs entrants/sortants EnsLib.CloudStorage.*.

Notez que vous devez avoir le serveur de %JavaServer External Language opérationnel pour utiliser l'API ou les adaptateurs de stockage cloud, car ils utilisent tous deux le framework PEX à l'aide du serveur Java.

Voici un bref résumé :

L'accès à Azure Blob Storage s'effectue à l'aide d'une chaîne de connexion qui ressemble à celle-ci :

Cela fait maintenant plus de 2 ans que j'utilise quotidiennement Embedded Python. Il est peut-être temps de partager un retour d'expérience sur ce parcours.

Pourquoi écrire ce commentaire de retour d'expérience? Parce que, je suppose, je suis comme la plupart de mes collègues ici, un développeur ObjectScript, et je pense que la communauté bénéficierait de ce retour d'expérience et pourrait mieux comprendre les avantages et les inconvénients du choix de Embedded Python pour développer quelque chose dans IRIS. Et aussi éviter certains pièges.

• Commentaire de retour d'expérience : Utilisation quotidienne de Embedded Python pendant 2 ans](#feedback--using-embedded-python-daily-for-2-years)
• Introduction
• Débuter avec Python
  • Python n'est pas ObjectScript
    • Pep8
    • Modules
    • Dunders
  • Conclusion
• Embedded Python
  • Qu'est-ce que Embedded Python ?
  • Comment utiliser Embedded Python ?
  • Comment j'utilise Embedded Python
    • Utilisation des bibliothèques et le code Python comme s'il s'agissait de classes ObjectScript
      • Avec la balise de langue
      • Sans de balise de langue
      • Conclusion
    • Utilisation d'une première approche en python
      • Exemple : iris-fhir-python-strategy
      • Remarques(#remarks)
      • Où trouver le code
        • Comment mettre en œuvre une Stratégie
        • Mise en œuvre d'InteractionsStrategy
        • Mise en œuvre des Interactions
        • Interactions en Python
        • IMise en œuvre de la classe abstraite python
      • Trop long, faisons un résumé

Introduction

Je suis développeur depuis 2010, et j'ai travaillé avec ObjectScript depuis 2013.

Donc, c'est à peu près 10 ans d'expérience avec ObjectScript.

Depuis 2021, et la sortie de Embedded Python dans IRIS, je me suis lancé un défi :

• Apprendre Python
• Faire autant que possible tout ce qui est en Python.

Quand j'ai commencé ce parcours, je n'avais aucune idée de ce qu'était Python. J'ai donc commencé par les bases, et je continue d'apprendre chaque jour.

Débuter avec Python

L'avantage de Python est sa facilité d'apprentissage. C'est encore plus facile quand on connaît déjà ObjectScript.

Pourquoi ? Ils ont beaucoup de choses en commun.

Donc, si vous connaissez ObjectScript, vous en savez déjà beaucoup sur Python.

Mais il y a quelques différences, et certaines d'entre elles ne sont pas faciles à comprendre.

Python n'est pas ObjectScript

Mais il y a quelques différences, et certaines d'entre elles ne sont pas faciles à comprendre.

Pour moi il y a principalement 3 différences :

• Pep8
• Modules
• Dunders

Pep8

Mais qu'est-ce que Pep8 ?

Il s'agit d'un ensemble de règles pour écrire du code Python.

pep8.org

Quelques-unes d'entre elles sont :

• convention de nommage
• noms de variables
  • snake_case
• noms de classes
  • CamelCase
• indentation
• longueur de ligne
• etc.

Pourquoi est-ce important ?

Parce que c'est la façon d'écrire du code Python. Et si vous ne suivez pas ces règles, vous aurez du mal à lire le code écrit par d'autres personnes, et elles auront du mal à lire le vôtre.

En tant que développeurs ObjectScript, nous avons aussi quelques règles à suivre, mais elles ne sont pas aussi strictes que Pep8.

J'ai appris Pep8 à la dure.

Je voudrais vous raconter petite histoire, je suis ingénieur commercial chez InterSystems et je fais beaucoup de démonstrations. Et un jour, que je faisais une démo de Embedded Python à un client, et ce client était un développeur Python, la conversation a tourné court lorsqu'il a vu mon code. Il m'a dit que mon code n'était pas du tout Python (il avait raison), je codais en Python comme je codais en ObjectScript. Et à cause de cela, il m'a dit qu'il n'était plus intéressé par Embedded Python. J'ai été choqué, et j'ai décidé d'apprendre Python de la bonne manière.

Donc, si vous voulez apprendre Python, apprenez d'abord Pep8.

Modules

Les modules sont quelque chose que nous n'avons pas en ObjectScript.

Habituellement, dans les langages orientés objet, vous avez des classes et des paquetages. En Python, vous avez des classes, des paquetages et des modules.

Qu'est-ce qu'un module ?

C'est un fichier avec une extension .py. Et c'est la façon d'organiser votre code.

Vous n'avez pas compris? Moi non plus au début. Prenons un exemple.

Habituellement, quand on veut créer une classe en ObjectScript, on crée un fichier .cls, et on y met sa classe. Et si vous voulez créer une autre classe, vous créez un autre fichier .cls. Et si vous voulez créer un paquetage, vous créez un dossier et vous y placez vos fichiers .cls.

En Python, c'est la même chose, mais Python apporte la possibilité d'avoir plusieurs classes dans un seul fichier. Ce fichier s'appelle un module. Pour information, c'est Pythonic quand il y a plusieurs classes dans un seul fichier.

Prévoyez donc comment vous allez organiser votre code, et comment vous allez nommer vos modules pour ne pas vous retrouver comme moi avec un tas de modules portant le même nom que vos classes.

Un mauvais exemple :

MyClass.py

class MyClass:
    def __init__(self):
        pass

    def my_method(self):
        pass

Pour instancier cette classe, vous allez faire :

import MyClass.MyClass # weird right ?

my_class = MyClass()

Bizarre, hein ?

Dunders

Les dunders sont des méthodes spéciales en Python. Elles sont appelées dunder parce qu'elles commencent et se terminent par un double soulignement.

Ce sont en quelque sorte nos méthodes % en ObjectScript.

Elles sont utilisées pour ce qui suit :

• constructeur
• surcharge d'opérateur
• représentation d'objet
• etc.

Exemple :

class MyClass:
    def __init__(self):
        pass

    def __repr__(self):
        return "MyClass"

    def __add__(self, other):
        return self + other

Ici, nous avons 3 méthodes de dunder :

• __init__ : constructeur
• __repr__ : représentation d'objet
• __add__ : surcharge d'opérateur

Les méthodes Dunders sont partout en Python. C'est une partie importante de la langue, mais ne vous inquiétez pas, vous les apprendrez rapidement.

Conclusion

Python n'est pas ObjectScript, et vous devrez l'apprendre. Mais ce n'est pas si difficile, et vous l'apprendrez rapidement. Gardez simplement à l'esprit qu'il vous faudra apprendre Pep8, et comment organiser votre code avec des modules et des méthodes dunder.

De bons sites pour apprendre Python :

• geeksforgeeks.org
• w3schools.com
• realpython.com

Embedded Python

Maintenant que vous en savez un peu plus sur Python, parlons de Embedded Python.

Qu'est-ce que Embedded Python ?

Embedded Python est un moyen d'exécuter du code Python dans IRIS. C'est une nouvelle fonctionnalité d' IRIS 2021.2+. Cela signifie que votre code Python sera exécuté dans le même processus qu'IRIS. Par ailleurs, chaque classe ObjectScript est une classe Python, de même pour les méthodes et les attributs et vice versa. 🥳 C'est génial !

Comment utiliser Embedded Python ?

Il y a 3 façons principales d'utiliser Embedded Python :

• Utilisation la balise de langue dans ObjectScript
  • Méthode Foo() As %String [ Language = python ]
• Utilisation de la fonction ##class(%SYS.Python).Import()
• Utilisation de l'interpréteur python
  • python3 -c "import iris; print(iris.system.Version.GetVersion())"

Mais si vous voulez vous intéresser sérieusement à Embedded Python, vous aurez à éviter d'utiliser la balise de langue.

Pourquoi ?

• Parce que ce n'est pas Pythonic
• Parce que ce n'est pas ObjectScript non plus
• Parce que vous n'avez pas de débogueur
• Parce que vous n'avez pas de linter
• Parce que vous n'avez pas de formateur
• Parce que vous n'avez pas de cadre de test
• Parce que vous n'avez pas de gestionnaire de paquets
• Parce que vous mélangez 2 langues dans le même fichier
• Parce que lorsque votre processus plante, vous n'avez pas de trace de pile
• Parce que vous ne pouvez pas utiliser d'environnements virtuels ou d'environnements conda
• ...

Ne vous méprenez pas, ça marche, ça peut être utile, si vous voulez tester quelque chose rapidement, mais à mon avis, ce n'est pas une bonne pratique.

Alors, qu'est-ce que j'ai appris de ces 2 années de Embedded Python, et comment l'utiliser de la bonne manière ?

Comment j'utilise Embedded Python

Je crois que vous avez deux options :

• Utiliser les bibliothèques Python comme s'il s'agissait de classes ObjectScript
  • withqvec ##class(%SYS.Python).Import() function
• Utiliser une première approche en python

Utilisation des bibliothèques et le code Python comme s'il s'agissait de classes ObjectScript

Vous voulez toujours utiliser Python dans votre code ObjectScript, mais vous ne voulez pas utiliser la balise de langue. Alors, que pouvez-vous faire ?

"Tout simplement" utilisez les bibliothèques et le code Python comme s'il s'agissait de classes ObjectScript. Prenons un exemplee :

Vous voulez utiliser la bibliothèque 'requests' ( c'est une bibliothèque pour faire des requêtes HTTP ) dans votre code ObjectScript.

Avec la balise de langue

ClassMethod Get() As %Status [ Language = python ]
{
	import requests

	url = "https://httpbin.org/get"
	# faire une requête d'obtention
	response = requests.get(url)
	# récupérer les données json de la réponse
	data = response.json()
	# itérer sur les données et imprimer les paires clé-valeur
	for key, value in data.items():
		print(key, ":", value)
}

Pourquoi je pense que ce n'est pas une bonne idée ?

Parce que vous mélangez 2 langues dans le même fichier, et que vous n'avez pas de débogueur, de linter, de formateur, etc. Si ce code plante, vous aurez du mal à le déboguer. Vous n'avez pas de trace de pile, et vous ne savez pas d'où vient l'erreur. Et vous n'avez pas d'auto-complétion.

Sans de balise de langue

ClassMethod Get() As %Status
{
	set status = $$$OK
    set url = "https://httpbin.org/get"
    // Importation du module Python "requests" en tant que classe ObjectScript
    set request = ##class(%SYS.Python).Import("requests")
    // Appel de la méthode get de la classe de requête
    set response = request.get(url)
    // Appel de la méthode json de la classe de réponse
	set data = response.json()
    // Ici, les données sont un dictionnaire Python
    // Pour parcourir un dictionnaire Python, vous devez utiliser la méthode dunder et items()
	// Importation du module Embedded Python
	set builtins = ##class(%SYS.Python).Import("builtins")
    // Ici, nous utilisons len du module intégré pour obtenir la longueur du dictionnaire
    For i = 0:1:builtins.len(data)-1 {
        // Maintenant, nous convertissons les éléments du dictionnaire en une liste, et nous obtenons la clé et la valeur en utilisant la méthode dunder __getitem__
		Write builtins.list(data.items())."__getitem__"(i)."__getitem__"(0),": ",builtins.list(data.items())."__getitem__"(i)."__getitem__"(1),!
	}
	quit status
}

Pourquoi je pense que c'est une bonne idée ?

Parce que vous utilisez Python comme s'il s'agissait d'ObjectScript. Vous importez la bibliothèque de requêtes comme une classe ObjectScript et vous l'utilisez comme une classe ObjectScript. Toute la logique est en ObjectScript, et vous utilisez Python comme une bibliothèque. Même pour la maintenance, c'est plus facile à lire et à comprendre, n'importe quel développeur ObjectScript peut comprendre ce code. L'inconvénient est que vous avez à savoir comment utiliser les méthodes de duners, et comment utiliser Python comme s'il s'agissait d'ObjectScript.

Conclusion

Croyez-moi, de cette manière vous obtiendrez un code plus robuste, et vous pourrez le déboguer facilement. Au début, cela semble difficile, mais vous découvrirez les avantages de l'apprentissage de Python plus rapidement que vous ne le pensez.

Utilisation de première approche en python

C'est la façon dont je préfère utiliser Embedded Python.

J'ai construit beaucoup d'outils en utilisant cette approche, et j'en suis très satisfait.

Quelques exemples :

• iop
• iris-python-interoperability-template
• iris-imap-adapter
• iris-chemicals-properties
• rest-to-dicom
• iris-fhir-python-strategy

Qu'est-ce qu'une première approche python ?

TIl n'y a qu'une seule règle : Le code Python doit être dans des fichiers .py, le code ObjectScript doit être dans des fichiers .cls

Comment y parvenir ?

L'idée est de créer des classes de wrappers ObjectScript pour appeler le code Python.

Prenons l'exemple de iris-fhir-python-strategy :

Exemple : iris-fhir-python-strategy

Tout d'abord, nous avons à comprendre comment fonctionne le serveur IRIS FHIR.

Chaque serveur IRIS FHIR met en œuvre une Stratégie.

Une Stratégie est un ensemble de deux classes :

Ces deux classes sont des classes abstraites Abtract Abstract.

• HS.FHIRServer.API.InteractionsStrategy est une classe Abstract qui doit être mise en œuvre pour personnaliser le comportement du serveur FHIR.
• HS.FHIRServer.API.RepoManager est une classe Abstract qui doit être mise en œuvre pour personnaliser le stockage du serveur FHIR.

Remarques

Pour notre exemple, nous nous concentrerons uniquement sur la classe HS.FHIRServer.API.InteractionsStrategy même si la classe HS.FHIRServer.API.RepoManager est également implémentée et obligatoire pour personnaliser le serveur FHIR. La classe HS.FHIRServer.API.RepoManager est mise en œuvre par HS.FHIRServer.Storage.Json.RepoManager qui est la mise en œuvre par défaut du serveur FHIR.

Où trouver le code

Tout le code source peut être trouvé dans le référentiel : iris-fhir-python-strategy Le dossier src contient les dossiers suivants :

• python : contient le code python
• cls : contient le code ObjectScript utilisé pour appeler le code python

Comment mettre en œuvre une Stratégie

Dans cette démonstration de faisabilité, nous nous intéresserons uniquement à la manière d'implémenter une Strategie en Python, et non à la manière de mettre en œuvre un RepoManager.

Pour mettre en œuvre une Strategie vous devez créer au moins deux classes :

• Une classe qui hérite de la classe HS.FHIRServer.API.InteractionsStrategy
• Une classe qui hérite de la classe HS.FHIRServer.API.Interactions

Mise en œuvre d'InteractionsStrategy

La classe HS.FHIRServer.API.InteractionsStrategy vise à personnaliser le comportement du serveur FHIR en remplaçant les méthodes suivantes :

• GetMetadataResource : appelé pour récupérer les métadonnées du serveur FHIR
  • C'est la seule méthode que nous remplacerons dans cette preuve de concept

HS.FHIRServer.API.InteractionsStrategy a également deux paramètres :

• StrategyKey : un identifiant unique pour la stratégie InteractionsStrategy
• InteractionsClass : le nom de votre sous-classe Interactions

Mise en œuvre des Interactions

La classe HS.FHIRServer.API.Interactions vise à personnaliser le comportement du serveur FHIR en remplaçant les méthodes suivantes :

• OnBeforeRequest : appelée avant l'envoi de la requête au serveur
• OnAfterRequest : appelée après l'envoi de la requête au serveur
• PostProcessRead : appelée une fois l'opération de lecture terminée
• PostProcessSearch : appelée une fois l'opération de recherche terminée
• Read : appelée pour lire une ressource
• Add : appelée pour ajouter une ressource
• Update : appelée pour mettre à jour une ressource
• Delete : appelée pour supprimer une ressource
• et bien d'autres...

Nous mettons en œuvre la classe HS.FHIRServer.API.Interactions dans la classe src/cls/FHIR/Python/Interactions.cls.

Class FHIR.Python.Interactions Extends (HS.FHIRServer.Storage.Json.Interactions, FHIR.Python.Helper)
{
Parameter OAuth2TokenHandlerClass As%String = "FHIR.Python.OAuth2Token";
Method %OnNew(pStrategy As HS.FHIRServer.Storage.Json.InteractionsStrategy) As%Status
{
// %OnNew est appelé lors de la création de l'objet.// Le paramètre pStrategy est l'objet de stratégie qui a créé cet objet.// La mise en œuvre par défaut ne fait rien// D'abord, le chemin d'accès à python est défini à partir d'une variable d'environnementset..PythonPath = $system.Util.GetEnviron("INTERACTION_PATH")
// Définissez ensuite le nom de la classe python à partir de la variable d'environnementset..PythonClassname = $system.Util.GetEnviron("INTERACTION_CLASS")
// Puis définissez le nom du module python à partir de la variable d'environnementset..PythonModule = $system.Util.GetEnviron("INTERACTION_MODULE")
<span class="hljs-keyword">if</span> (<span class="hljs-built_in">..PythonPath</span> = <span class="hljs-string">""</span>) || (<span class="hljs-built_in">..PythonClassname</span> = <span class="hljs-string">""</span>) || (<span class="hljs-built_in">..PythonModule</span> = <span class="hljs-string">""</span>) {
	<span class="hljs-comment">//quit ##super(pStrategy)</span>
	<span class="hljs-keyword">set</span> <span class="hljs-built_in">..PythonPath</span> = <span class="hljs-string">"/irisdev/app/src/python/"</span>
	<span class="hljs-keyword">set</span> <span class="hljs-built_in">..PythonClassname</span> = <span class="hljs-string">"CustomInteraction"</span>
	<span class="hljs-keyword">set</span> <span class="hljs-built_in">..PythonModule</span> = <span class="hljs-string">"custom"</span>
}


<span class="hljs-comment">// Définissez ensuite la classe python</span>
<span class="hljs-keyword">do</span> <span class="hljs-built_in">..SetPythonPath</span>(<span class="hljs-built_in">..PythonPath</span>)
<span class="hljs-keyword">set</span> <span class="hljs-built_in">..PythonClass</span> = <span class="hljs-keyword">##class</span>(FHIR.Python.Interactions).GetPythonInstance(<span class="hljs-built_in">..PythonModule</span>, <span class="hljs-built_in">..PythonClassname</span>)

<span class="hljs-keyword">quit</span> <span class="hljs-keyword">##super</span>(pStrategy)
}
Method OnBeforeRequest(
pFHIRService As HS.FHIRServer.API.Service,
pFHIRRequest As HS.FHIRServer.API.Data.Request,
pTimeout As%Integer)
{
// OnBeforeRequest est appelée avant le traitement de chaque demande.if$ISOBJECT(..PythonClass) {
set body = ##class(%SYS.Python).None()
if pFHIRRequest.Json '= "" {
set jsonLib = ##class(%SYS.Python).Import("json")
set body = jsonLib.loads(pFHIRRequest.Json.%ToJSON())
}
do..PythonClass."on_before_request"(pFHIRService, pFHIRRequest, body, pTimeout)
}
}
Method OnAfterRequest(
pFHIRService As HS.FHIRServer.API.Service,
pFHIRRequest As HS.FHIRServer.API.Data.Request,
pFHIRResponse As HS.FHIRServer.API.Data.Response)
{
// OnAfterRequest est appelée après le traitement de chaque demande.if$ISOBJECT(..PythonClass) {
set body = ##class(%SYS.Python).None()
if pFHIRResponse.Json '= "" {
set jsonLib = ##class(%SYS.Python).Import("json")
set body = jsonLib.loads(pFHIRResponse.Json.%ToJSON())
}
do..PythonClass."on_after_request"(pFHIRService, pFHIRRequest, pFHIRResponse, body)
}
}
Method PostProcessRead(pResourceObject As%DynamicObject) As%Boolean
{
// PostProcessRead est appelée après la lecture d'une ressource dans la base de données.// Renvoyez 1 pour indiquer que la ressource doit être incluse dans la réponse.// Renvoyez 0 pour indiquer que la ressource doit être exclue de la réponse.if$ISOBJECT(..PythonClass) {
if pResourceObject '= "" {
set jsonLib = ##class(%SYS.Python).Import("json")
set body = jsonLib.loads(pResourceObject.%ToJSON())
}
return..PythonClass."post_process_read"(body)
}
quit1
}
Method PostProcessSearch(
pRS As HS.FHIRServer.Util.SearchResult,
pResourceType As%String) As%Status
{
// PostProcessSearch est appelée après l'exécution d'une recherche.// Renvoyez $$$OK pour indiquer que la recherche a abouti.// Renvoyez un code d'erreur pour indiquer que la recherche a échoué.if$ISOBJECT(..PythonClass) {
return..PythonClass."post_process_search"(pRS, pResourceType)
}
quit$$$OK
}
Method Read(
pResourceType As%String,
pResourceId As%String,
pVersionId As%String = "") As%DynamicObject
{
return##super(pResourceType, pResourceId, pVersionId)
}
Method Add(
pResourceObj As%DynamicObject,
pResourceIdToAssign As%String = "",
pHttpMethod = "POST") As%String
{
return##super(pResourceObj, pResourceIdToAssign, pHttpMethod)
}
/// Renvoie de VersionId pour la version "supprimée"
Method Delete(
pResourceType As%String,
pResourceId As%String) As%String
{
return##super(pResourceType, pResourceId)
}
Method Update(pResourceObj As%DynamicObject) As%String
{
return##super(pResourceObj)
}
}

La classe FHIR.Python.Interactions hérite de la classe HS.FHIRServer.Storage.Json.Interactions et de la classe FHIR.Python.Helper

La classe HS.FHIRServer.Storage.Json.Interactions est la mise en œuvre par défaut du serveur FHIR.

La classe FHIR.Python.Helper vise à aider à appeler du code Python à partir d'ObjectScript.

La classe FHIR.Python.Interactions remplacent les méthodes suivantes :

• %OnNew : appelée lors de la création de l'objet
  • nous utilisons cette méthode pour définir le chemin python, le nom de la classe python et le nom du module python à partir des variables d'environnement
  • si les variables d'environnement ne sont pas définies, nous utilisons les valeurs par défaut
  • nous définissons également la classe python
  • nous appelons la méthode %OnNew de la classe parente

Method %OnNew(pStrategy As HS.FHIRServer.Storage.Json.InteractionsStrategy) As %Status
{
	// Définissez d'abord le chemin python à partir d'une variable d'environnement
	set ..PythonPath = $system.Util.GetEnviron("INTERACTION_PATH")
	// Puis définissez le nom de la classe python à partir de la variable d'environnement
	set ..PythonClassname = $system.Util.GetEnviron("INTERACTION_CLASS")
	// Puis définissez le nom du module python à partir de la variable d'environnement
	set ..PythonModule = $system.Util.GetEnviron("INTERACTION_MODULE")

	if (..PythonPath = "") || (..PythonClassname = "") || (..PythonModule = "") {
		// utilisez les valeurs par défaut
		set ..PythonPath = "/irisdev/app/src/python/"
		set ..PythonClassname = "CustomInteraction"
		set ..PythonModule = "custom"
	}

	// Ensuite, définissez la classe python
	do ..SetPythonPath(..PythonPath)
	set ..PythonClass = ..GetPythonInstance(..PythonModule, ..PythonClassname)

	quit ##super(pStrategy)
}

• OnBeforeRequest : appelée avant l'envoi de la requête au serveur
  • nous appelons la méthode on_before_request de la classe python
  • nous passons l'objet HS.FHIRServer.API.Service, l'objet HS.FHIRServer.API.Data.Request, le corps de la requête et le timeout

Method OnBeforeRequest(
	pFHIRService As HS.FHIRServer.API.Service,
	pFHIRRequest As HS.FHIRServer.API.Data.Request,
	pTimeout As %Integer)
{
	// OnBeforeRequest est appelée avant le traitement de chaque requête.
	if $ISOBJECT(..PythonClass) {
		set body = ##class(%SYS.Python).None()
		if pFHIRRequest.Json '= "" {
			set jsonLib = ##class(%SYS.Python).Import("json")
			set body = jsonLib.loads(pFHIRRequest.Json.%ToJSON())
		}
		do ..PythonClass."on_before_request"(pFHIRService, pFHIRRequest, body, pTimeout)
	}
}

• OnAfterRequest : appelée après l'envoi de la requête au serveur
  • nous appelons la méthode on_after_request de la classe python
  • nous passons l'objet HS.FHIRServer.API.Service, l'objet HS.FHIRServer.API.Data.Request, l'objet HS.FHIRServer.API.Data.Response et le corps de la réponse

Method OnAfterRequest(
	pFHIRService As HS.FHIRServer.API.Service,
	pFHIRRequest As HS.FHIRServer.API.Data.Request,
	pFHIRResponse As HS.FHIRServer.API.Data.Response)
{
	// OnAfterRequest est appelée après le traitement de chaque requête.
	if $ISOBJECT(..PythonClass) {
		set body = ##class(%SYS.Python).None()
		if pFHIRResponse.Json '= "" {
			set jsonLib = ##class(%SYS.Python).Import("json")
			set body = jsonLib.loads(pFHIRResponse.Json.%ToJSON())
		}
		do ..PythonClass."on_after_request"(pFHIRService, pFHIRRequest, pFHIRResponse, body)
	}
}

• Et ainsi de suite...

Interactions en Python

La classeFHIR.Python.Interactions appelle les méthodes on_before_request, on_after_request, ... de la classe python.

Voici la classe python abstraite :

import abc
import iris

class Interaction(object):
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def on_before_request(self, 
                          fhir_service:'iris.HS.FHIRServer.API.Service',
                          fhir_request:'iris.HS.FHIRServer.API.Data.Request',
                          body:dict,
                          timeout:int):
        """
        on_before_request is called before the request is sent to the server.
        param fhir_service: the fhir service object iris.HS.FHIRServer.API.Service
        param fhir_request: the fhir request object iris.FHIRServer.API.Data.Request
        param timeout: the timeout in seconds
        return: None
        """
        

    @abc.abstractmethod
    def on_after_request(self,
                         fhir_service:'iris.HS.FHIRServer.API.Service',
                         fhir_request:'iris.HS.FHIRServer.API.Data.Request',
                         fhir_response:'iris.HS.FHIRServer.API.Data.Response',
                         body:dict):
        """
        on_after_request is called after the request is sent to the server.
        param fhir_service: the fhir service object iris.HS.FHIRServer.API.Service
        param fhir_request: the fhir request object iris.FHIRServer.API.Data.Request
        param fhir_response: the fhir response object iris.FHIRServer.API.Data.Response
        return: None
        """
        

    @abc.abstractmethod
    def post_process_read(self,
                          fhir_object:dict) -> bool:
        """
        post_process_read is called after the read operation is done.
        param fhir_object: the fhir object
        return: True the resource should be returned to the client, False otherwise
        """
        

    @abc.abstractmethod
    def post_process_search(self,
                            rs:'iris.HS.FHIRServer.Util.SearchResult',
                            resource_type:str):
        """
        post_process_search is called after the search operation is done.
        param rs: the search result iris.HS.FHIRServer.Util.SearchResult
        param resource_type: the resource type
        return: None
        """

Mise en œuvre de la classe abstraite python

from FhirInteraction import Interaction

class CustomInteraction(Interaction):

    def on_before_request(self, fhir_service, fhir_request, body, timeout):
        #Extract the user and roles for this request
        #so consent can be evaluated.
        self.requesting_user = fhir_request.Username
        self.requesting_roles = fhir_request.Roles

    def on_after_request(self, fhir_service, fhir_request, fhir_response, body):
        #Clear the user and roles between requests.
        self.requesting_user = ""
        self.requesting_roles = ""

    def post_process_read(self, fhir_object):
        #Evaluate consent based on the resource and user/roles.
        #Returning 0 indicates this resource shouldn't be displayed - a 404 Not Found
        #will be returned to the user.
        return self.consent(fhir_object['resourceType'],
                        self.requesting_user,
                        self.requesting_roles)

    def post_process_search(self, rs, resource_type):
        #Iterate through each resource in the search set and evaluate
        #consent based on the resource and user/roles.
        #Each row marked as deleted and saved will be excluded from the Bundle.
        rs._SetIterator(0)
        while rs._Next():
            if not self.consent(rs.ResourceType,
                            self.requesting_user,
                            self.requesting_roles):
                #Mark the row as deleted and save it.
                rs.MarkAsDeleted()
                rs._SaveRow()

    def consent(self, resource_type, user, roles):
        #Example consent logic - only allow users with the role '%All' to see
        #Observation resources.
        if resource_type == 'Observation':
            if '%All' in roles:
                return True
            else:
                return False
        else:
            return True

Trop long, faisons un résumé

La classeFHIR.Python.Interactions est un wrapper pour appeler la classe python.

Les classes abstraites IRIS sont implémentées pour envelopper les classes abstraites python 🥳.

Cela nous aide à séparer le code python et le code ObjectScript et à bénéficier ainsi du meilleur des deux mondes.

Dans cet article, nous aborderons les sujets ci-dessous :

• Qu’est-ce que Kubernetes ?
• Principaux composants Kubernetes (K8s)

Qu’est-ce que Kubernetes?

Kubernetes est un framework d'orchestration de conteneurs open source développé par Google. Essentiellement, il contrôle la vitesse des conteneurs et vous aide à gérer des applications composées de plusieurs conteneurs. De plus, il vous permet de les exploiter dans différents environnements, par exemple des machines physiques, des machines virtuelles, des environnements Cloud ou même des environnements de déploiement hybrides.

Dans cet article, je partagerai le thème que nous avons présenté lors du Global Summit 2023, dans la salle Tech Exchange. Moi et @Rochael Ribeiro

Lors de cette présentation, nous abordons les sujets suivants :

• Outils Open Exchange pour des API rapides
• Spécification de l'Open API
• Développement d'API traditionnel ou Fast
• API composite (interopérabilité)
• Approche Spec-First ou Api-First
• Gouvernance et surveillance des API
• Démo (vidéo)

Outils Exchange ouverts pour des API Fast

Comment déployer les productions IRIS sereinement et plus rapidement ?

L'objectif des productions d'interopérabilité est de vous permettre de connecter des systèmes afin de transformer et d'acheminer des messages entre eux. Pour connecter des systèmes, vous développez, configurez, déployez et gérez des productions qui intègrent plusieurs solutions.

C’est ce que nous dit la documentation InterSystems sur son site de référence, mais que faut-il réellement faire pour déployer une production ?

On peut composer les productions, selon les usages, pour connecter des systèmes externes à IRIS Data Platform. Il est pour cela nécessaire de créer un environnement propre à chaque production à savoir les composants suivants :

• un Business service 📨
• un Business processus (facultatif) 📘
• une Business opération 💉
• des schémas de définition de table (.cls; classes) 📅
• un fichier d’initialisation d’espace de noms (.cpf) 📋

Bien sûr l’importance d’employer les productions pour traiter les messages réside dans le fait de pouvoir tracer chaque message et remonter ainsi la trace des accidents de parcours de chaque événement indésirable.

Et si je vous disais qu’il est possible de déployer vos productions à l’aide de notre framework d’interopérabilité IRIS d’un coup de baguette magique ?🪄

Explications

L’approche mainframe de laquelle provient notre framework permet de déployer à vitesse grand « V » des productions IRIS InterSystems® sans devoir recréer tous les composants à la main.

L’emploi du framework permet d’ajouter une fonctionnalité intéressante autorisant la lecture des données des tables à déployer avec la production : l’ajout d’une API sortante (RestForms2).

➡️Les données deviennent ainsi interrogeables et restituables dans un format JSON.

Le framework va générer tous les composants en se basant sur un fichier de spécifications fonctionnelles rempli en accord avec le métier et notre chef de projet (dont le rôle est de veiller à ce que chaque information nécessaire trouve sa place).

Le script agit en deux temps à savoir : la construction du flux ETL et du point de chute des données. 📦🪂

Une fois rempli conformément à ce qui est attendu, le fichier de spécifications fonctionnelles permet de générer dans un premier temps : le fichier de sérialisation des messages (classes de données ; obj.py), le fichier de structure des données dans chaque message (msg.py), le fichier de génération de messages (bs.py) et le fichier d’ingestion des messages dans la base de données correspondante (bo.py); dans un second temps : il sert à créer/supprimer les tables dans la base de données sous forme d’un script SQL comprenant des instructions DDL (Data Definition Language).

De quoi vous faire gagner beaucoup de temps ! ⌚ Le plus beau dans tout cela, c’est que le framework est déployable facilement depuis un container Docker ! 🐳

Intérêts

Toujours pas convaincu(e) ? En quoi utiliser ce framework vous ferait gagner 80% du temps ?⏱️

Et si je vous disais que le code déployé par le framework est validé par l’éditeur InterSystems®, qu’il permet à votre équipe de travailler sur du code uniformisé, que lors de campagnes de maintenance cette possibilité vous incite à être plus efficace en cas de mise à jour de code ou de recherche de bug, qu’il vous permet d’interagir avec vos données à l’aide d’un mécanisme de REST API (issu du dépôt des paquets compatibles InterSystems IRIS toutes versions confondues). Cela fait sens pour vous ? 👌

Qu’entend-on par « le code est validé par l’éditeur » ? ✅ Simplement qu’il respecte les standards Python et ceux de l’éditeur en matière d’architecture, d’appels aux mécanismes internes d’IRIS InterSystems® également qu’il sait s’interfacer avec le langage ObjectScript et vice versa.

La suite

Si cet article fait écho à vos besoins ou si vous êtes simplement curieux de voir comment ce framework pourrait révolutionner votre manière de travailler sous IRIS InterSystems® : rendez vous sur notre site web et/ou demander un accès à notre pour discuter avec l’un de nos experts.

Suivez-nous aussi sur

Prochainement, nous vous ferons découvrir un cas d’usage du framework en environnement opérationnel 😉 !

InterSystems a le plaisir d'annoncer que le composant central d'InterSystems Supply Chain Orchestrator™, la version 2023.1 d'InterSystems IRIS for Supply Chain, est désormais généralement disponible (GA).

Créer un Chatbot avec IRIS et Python

Dans cet article, je vais montrer comment intégrer la base de données IRIS d'InterSystems avec Python pour servir un Modèle d'apprentissage automatique du traitement du langage naturel (NLP).

Pourquoi Python ?

Avec une large adoption et utilisation dans le monde, Python a une grande communauté et un grand nombre d'accélérateurs et de bibliothèques pour déployer n'importe quel type d'application. Vous pouvez également consulter : https://www.python.org/about/apps/ pour en savoir plus.

Globales Iris

Lorsque j'ai commencé à me familiariser avec les globales (^globals), leur utilisation m'est devenue familière en tant que moyen rapide d'ingérer des données dans un modèle de données prêt à l'emploi. Dans un premier temps, je vais donc utiliser les globales (^globals) pour stocker les données d'entraînement et les conversations pour enregistrer le comportement du chatbot.

Traitement du langage naturel

Le traitement du langage naturel ou NLP (Natural Language Processing) est un domaine de l'IA qui crée la capacité de lire et de comprendre le sens de nos langues pour les machines. Comme vous pouvez l'imaginer, ce n'est pas très simple, mais je vais vous montrer comment faire vos premiers pas dans ce vaste et beau domaine.

Démo - Essayez-le vous-même

J'ai déployé l'application Chatbot en tant que démonstration ici : http://iris-python-suite.eastus.cloudapp.azure.com:8080

Comment ça marche?

Apprentissage automatique

Il est tout d'abord bon de savoir que l'apprentissage automatique a un paradigme différent de celui du développement de logiciels courants. Le point principal qui est difficile à comprendre est le cycle de développement des modèles d'apprentissage automatique.

Alerte aux explications superficielles

Le cycle de développement d'une application standard est le suivant :

Développer le code->Tester (avec des données de développement)->Déployer (en utilisant des données réelles)

L'apprentissage automatique du code en lui-même n'a pas la même valeur. La responsabilité est partagée avec les données ! Et pas n'importe quelles données, mais de vraies données ! Car le code final à exécuter est généré par une fusion entre les concepts de développement et les données utilisées. Un cycle d'application de l'apprentissage automatique devrait donc se dérouler de la manière suivante :

Développer (Former) Modèle+Données réelles->Valider->Déployer le résultat de ceci (un Modèle)

Comment former le modèle?

Il existe de nombreuses techniques pour entraîner les modèles et chaque cas et objectif nécessite une courbe d'apprentissage importante. Dans ce cas, j'utilise la bibliothèque ChatterBot qui encapsule certaines techniques et fournit des méthodes d'entraînement et des données d'entraînement prétraitées pour nous aider à nous concentrer sur les résultats.

Langages de modèles pré-entraînés et modèles personnalisés

Vous pouvez commencer par cela pour avoir un chatbot conversationnel de base. Vous pouvez également créer toutes les données nécessaires à l'entraînement de votre chatbot, et cela peut être parfait pour vos besoins, mais terriblement difficile à réaliser en un temps limité. Dans ce projet, j'utilise en_core_web_sm comme base de conversation et je la fusionne avec des données d'entraînement personnalisées que vous pouvez créer à l'aide d'un formulaire

Architecture de base

Qu'ai-je utilisé en Python ?

Dans cet environnement d'application, j'utilise Python 3.7 avec les modules suivants :

• PyYAML<=5.0.0
• dash==1.12.0
• dash-bootstrap-components==0.10.1
• dash-core-components==1.10.0
• dash-html-components==1.0.3
• dash-renderer==1.4.1
• dash-table==4.7.0
• plotly==4.7.1
• numpy==1.18.4
• networkx==2.4
• Flask>=1.0.0
• chatterbot>=1.0.0
• chatterbot-corpus>=1.2.0
• SQLAlchemy>=1.2
• ./nativeAPI_wheel/irisnative-1.0.0-cp34-abi3-linux_x86_64.whl

Structure de projet

Ce projet a une structure simple et facile à comprendre. Dans le dossier principal, nous avons trois sous-dossiers importants :

• ./app: avec tout le code d'application et la configuration d'installation.
• ./iris: avec InterSystems IRIS dockerfile préparant à servir l'application.
• ./data: Pour relier l'hôte à l'environnement du conteneur par un volume

Structure de l'application

À l'intérieur du répertoire ./app, nous trouvons quelques fichiers :

• chatbot.py : avec la mise en œuvre de l'application web
• iris_python_suite.py : une classe avec quelques accélérateurs à utiliser avec IRIS Database et Python par l'API native d'IRIS.

Structure de la base de données

Cette application utilise Intersystems IRIS comme référentiel, les globales utilisées sont :

• ^chatbot.training.data : stocke toutes les données d'entraînement personnalisées sous forme de questions et de réponses.
• ^chatbot.conversation : stocke toutes les données de conversation.
• ^chatbot.training.isupdated : contrôle le pipeline de formation.

Produits de mon autre solution

Je n'ai pas créé de rapport pour toutes les conversations mais ce n'est pas un problème, grâce à mon visualiseur de graphes globaux je peux suivre les conversations.

Exécution de l'application par vous-même

Conditions préalables

• git
• docker et docker-compose (et plus de paramètres de mémoire dans docker au moins 4 Go)
• accès à un terminal dans votre environnement

Étapes

Avec docker-compose, vous pouvez facilement mettre en place un environnement avec toutes les pièces et configurations. Allez dans le dossier iris-python-covid19 et tapez ce texte :

$ docker compose build
$ docker compose up

Durée estimée de mise en place des conteneurs

La première exécution dépendra de votre lien internet pour télécharger les images et les dépendances. Si la durée est supérieure à 15 minutes, il est probable que quelque chose ne fonctionne pas, n'hésitez pas à nous en faire part ici. Après la première exécution, les exécutions suivantes seront plus performantes et prendront moins de 2 minutes.

Si tout est correct

Après un certain temps, vous pouvez ouvrir votre navigateur et aller à l'adresse :

La forme des données d'apprentissage

http://localhost:8050/chatbot-training-data

Le chatbot

http://localhost:8080

Vous devriez consulter le portail d'administration d'IRIS

Pour le moment, j'utilise l'espace de noms USER.

http://localhost:9092
user: _SYSTEM
pass: theansweris42

Si cet article vous est utile ou si vous en aimez le contenu, votez :

Cette application est au concours actuel sur open exchange, vous pouvez voter pour mon application iris-python-suite ici (https://openexchange.intersystems.com/contest/current)

Bonjour à tous !

Je partage avec vous un outil d'ingestion de données que nous avons utilisé dans certains projets.

DataPipe est un framework d'interopérabilité pour l'ingestion de données dans InterSystems IRIS de manière flexible. Il vous permet de recevoir des données de sources externes, de normaliser et de valider les informations et enfin d'effectuer toutes les opérations dont vous avez besoin avec vos données.

Modèle

En premier lieu, vous devez définir un modèle. Un modèle est simplement une classe qui s'étend à partir de DataPipe.Model où vous devez implémenter quelques méthodes :

Dans le modèle, vous spécifiez comment vous allez sérialiser / désérialiser les données, comment vous les normalisez et les validez et enfin quelle opération vous voulez effectuer avec vos données une fois qu'elles sont normalisées et validées.

Here you can find a full example of a DataPipe model.

Composants d'interopérabilité

Après avoir défini le modèle, vous pouvez ajouter les composants dont vous avez besoin à une production d'interopérabilité.

Vous devez mettre en place un processus d'ingestion qui doit comprendre les éléments suivants :

• La transformation Input > InboxAttributes où vous spécifiez comment extraire les attributs qui décrivent vos données d'entrée. Ces attributs peuvent être utilisés pour rechercher les données traitées.
• La transformation Input > Model où vous implémentez comment convertir les données entrantes dans votre modèle DataPipe.

Les autres composantes sont déjà préconstruites dans DataPipe. Vous avez un exemple de production ici.

DatapipeUI

Il existe également une interface utilisateur que vous pouvez utiliser pour gérer les données que vous ingérez dans le système.

Déploiement

Pour le déployer, vous avez besoin d'une instance IRIS d'InterSystems, où vous installez DataPipe (et RESTForms2 pour les API REST) et une application web externe (UI) qui interagira avec cette instance.

Si vous êtes intéressé et que vous souhaitez jeter un coup d'œil et tester cette solution, vous trouverez toutes les informations nécessaires dans le lien Open Exchange.

Bonjour à tous, 

Nous voici de nouveau réunis. Nouvelle année, nouveau concours, nouveau projet, vieilles raisons.

Triple barre oblique "Triple Slash" est dans la place" !

1999, c'était l'année où j'ai appris à coder, mon premier "IF", mon premier "Bonjour le monde"

Je me souviens encore de mon professeur expliquant à tout le monde dans cette classe le simple "while" et comment nous pouvons déterminer si une condition spécifique a été atteinte @Renato Banzai vous en souvenez vous ? Le professeur Barbosa, quel homme unique.   

Depuis lors, j'aime l'idée de coder, de transformer des idées en projets, en quelque chose d'utile. Mais nous savons tous que pour créer quelque chose, nous devons nous assurer que cela fonctionne ; nous ne nous contentons pas de créer mais nous testons si cela fonctionne et si cela continue à fonctionner si nous ajoutons quelque chose de nouveau.

Et pour être honnête avec chacun d'entre vous, créer des tests, c'est ennuyeux. Du moins pour moi, mais si vous aimez le faire, je n'ai rien contre vous.

En utilisant une mauvaise analogie, je peux dire que la création de méthodes d'essai est comme le nettoyage de votre maison ou le repassage de vos vêtements. C'est ennuyeux, mais c'est nécessaire si vous voulez quelque chose de mieux.  

En gardant cela à l'esprit, pourquoi ne pas créer un moyen meilleur et plus facile pour les tests ? 

Ainsi, inspirés par le style elixir style and in et par cette idée d' InterSystems Ideas (Merci @Evgeny Shvarov)! Nous avons essayé d'améliorer le processus de test et de le transformer à nouveau en une tâche agréable.

Nous simplifions le %UnitTest et pour vous montrer comment utiliser TripleSlash pour créer vos tests unitaires, utilisons un exemple simple.

Disons que vous avez la classe et la méthode suivantes, pour lesquelles vous souhaitez écrire un test unitaire :

Class dc.sample.ObjectScript
{
ClassMethod TheAnswerForEverything() As%Integer
{

   Set a = 42Write"Bonjour le monde !",!

   Write"C'est InterSystems IRIS avec la version ",$zv,!

   Write"L'heure actuelle est : "_$zdt($h,2)

   Return a

}
}

Comme vous pouvez le constater, la méthode TheAnswerForEverything() ne fait que retranscrire le nombre 42. Indiquons donc dans la documentation de la méthode comment TripleSlash doit créer un test unitaire pour cette méthode :

/// Une méthode simple à des fins de tests./// /// /// Ecrivez ##class(dc.sample.ObjectScript).Test()/// 42/// ClassMethod TheAnswerForEverything() As%Integer
{
    ...
}

Les tests unitaires doivent être entourés de la balise <exemple></exemple>. Vous pouvez ajouter tout type de documentation, mais tous les tests doivent être contenus dans une telle balise.

Maintenant, démarrez une session de terminal IRIS, allez dans l'espace de noms IRISAPP créez une instance de la classe Core en passant le nom de la classe (ou son nom de paquet pour toutes ses classes) et exécutez ensuite la méthode Execute() :

USER>ZN"IRISAPP"
IRISAPP>Do##class(iris.tripleSlash.Core).%New("dc.sample.ObjectScript").Execute()

TripleSlash interprétera ceci comme "Étant donné le résultat de la méthode Test(), affirme qu'il est égal à 42". Ainsi, une nouvelle classe sera créée dans le test unitaire :

Class iris.tripleSlash.tst.ObjectScript Extends%UnitTest.TestCase
{

Method TestTheAnswerForEverything()
{
    Do$$$AssertEquals(##class(dc.sample.ObjectScript).TheAnswerForEverything(), 42)
}

}

Ajoutons maintenant une nouvelle méthode pour tester les autres moyens permettant d'indiquer à TripleSlash comment écrire vos tests unitaires.

Class dc.sample.ObjectScript
{

ClassMethod GuessTheNumber(pNumber As%Integer) As%Status
{
    Set st = $$$OKSet theAnswerForEveryThing = 42Try {
        Throw:(pNumber '= theAnswerForEveryThing) ##class(%Exception.StatusException).%New("Sorry, wrong number...")
    } Catch(e) {
        Set st = e.AsStatus()
    }

    Return st

}

}

Comme vous pouvez le constater, la méthode GuessTheNumber() attend un nombre, renvoie $$$OK uniquement si le nombre 42 est transmis ou une erreur pour toute autre valeur. Il faut donc indiquer dans la documentation de la méthode comment TripleSlash doit créer un test unitaire pour cette méthode :

/// Une autre méthode simple à des fins de test./// /// /// Exécutez ##class(dc.sample.ObjectScript).GuessTheNumber(42)/// $$$OK/// Do ##class(dc.sample.ObjectScript).GuessTheNumber(23)/// $$$NotOK/// ClassMethod GuessTheNumber(pNumber As%Integer) As%Status
{
    ...
}

Exécutez à nouveau la méthode Execute() et vous verrez une nouvelle méthode de test dans la classe de test unitaire iris.tripleSlash.tst.ObjectScript:

Class iris.tripleSlash.tst.ObjectScript Extends%UnitTest.TestCase
{

La méthode TestGuessTheNumber()
{

    Do$$$AssertStatusOK(##class(dc.sample.ObjectScript).GuessTheNumber(42))
    Do$$$AssertStatusNotOK(##class(dc.sample.ObjectScript).GuessTheNumber(23))
}

}

Actuellement, les assertions suivantes sont disponibles : $$$AssertStatusOK, $$$AssertStatusNotOK et $$$AssertEquals. 

TripleSlash nous permet de générer des tests à partir d'exemples de code trouvés dans les descriptions de méthodes. Il vous permet de faire d'une pierre deux coups, en améliorant la documentation de vos classes et en créant l'automatisation des tests. 

Remerciements

Une fois encore, nous vous remercions pour tout le soutien de la communauté dans chacune des applications que nous créons.

Si vous avez trouvé notre application intéressante et avez apporté votre contribution, veuillez voter pour iris-tripleslash et nous aider dans cette aventure !

Avec les dernières améliorations concernant le support de Python dans IRIS, et la poursuite du travail sur le support de Python DB-API par InterSystems. J'ai implémenté le support IRIS dans le projet Django où Python DB-API est utilisé pour travailler avec d'autres bases de données.

Essayons une application simple sur Django, qui stocke ses données dans IRIS.

git clone https://github.com/caretdev/django-iris-todo
cd django-iris-todo

Et nous pouvons le construire et le démarrer avec Docker-compose

docker-compose up -d --build

Cela prendra un certain temps, quand IRIS sera démarré, et l'application Django l'attrapera, migrez les modèles là et lancez l'application aussi, une fois qu'elle est démarrée, elle sera disponible par http://localhost:8000/ et vous devriez avoir l'image comme ci-dessus.

Mais, comment cela fonctionne-t-il ?

Pour le faire fonctionner, il faut que l'interface InterSystems Python DB-API soit installée, elle est livrée avec la dernière version de l'aperçu, vous devez donc avoir la version 2022.1.0.114.0 ou une version supérieure et elle se trouve dans le dossier de l'instance <INSTALL_DIR>/dev/python/. Ce fichier peut également être téléchargé à partir de ce depôt GitHub 

pip3 install intersystems_irispython-3.2.0-py3-none-any.whl

Le back-end IRIS de Django est implémenté par un autre projet, et qui peut être installé avec pip, et pour sûr nous avons besoin de django lui-même, installons-les

pip3 install django django-iris

Une autre façon d'installer les paquets requis dans Python est d'utiliser le fichier requirements.txt

pip3 install -r requirements.txt

Alors que ce fichier contient, les lignes suivantes

https://raw.githubusercontent.com/intersystems-community/iris-driver-distribution/main/intersystems_irispython-3.2.0-py3-none-any.whl
Django~=4.0.2
django-iris~=0.1.5

Connectons notre application Django à l'IRIS, ouvrons le fichier todoApp/settings.py

DATABASES définit les paramètres de connexion à la base de données

ENGINE doit être django_IRIS

NAME doit pointer vers l'espace de nom Namespace dans IRIS.

Il suffit de le changer en quelque chose, où il peut se connecter. Par exemple

DATABASES = {
    'default': {
        'ENGINE': 'django_iris',
        'NAME': 'DJANGOTODO',
        'HOST': 'localhost',
        'PORT': 1972,
        'USER': '_SYSTEM',
        'PASSWORD': 'SYS',
    }
}

Et lançons la migration

python3 manage.py migrate

Aucune erreur, tous les tableaux du côté d'IRIS sont créés.

Et nous sommes prêts à démarrer notre application

python3 manage.py runserver

Django est livré avec un panneau d'administration

python3 manage.py createsuperuser

Et le panneau d'administration est disponible par le lien http://localhost:8000/admin/, 

Et comment il est stocké dans IRIS

  Le travail est toujours en cours pour le pilote Python DB-API d'InterSystems, et aussi pour ce projet django-iris.

Soyez conscient que cela ne fonctionnera pas aussi bien sur la version Community Edition, en raison de la façon dont Django se connecte à la base de données, il peut utiliser toutes les licences très rapidement.

Si vous aimez le projet, et son impact futur sur l'utilisation d'IRIS, veuillez voter sur Compétition OpenExchange

Bonjour

J'espère être dans le bon forum. Notre entreprise-mère basée aux Etats-Unis m'a chargé de télécharger la documentation InterSystems pour la gestion des finances de notre succursale en France. Je dois avouer que j'ai du mal à m'y retrouver, mon niveau d'anglais étant médiocre. Nous travaillons dans la livraison de fleurs et notre société-mère souhaite unifier nos systèmes de reporting en utilisant InterSystems aux USA et ici en France. Existe-t-il une documentation en français pour les débutants?

Introduction

Nous sommes à l'ère de l'économie multiplateforme et les API sont la "colle " de ce scénario numérique. Étant donné leur importance, les développeurs les considèrent comme un service ou un produit à consommer. Par conséquent, l'expérience d'utilisation est un facteur crucial de leur succès.

Afin d'améliorer cette expérience, des normes de spécification telles que la spécification OpenAPI (OAS) sont de plus en plus adoptées dans le développement des API RESTFul.

IRIS ApiPub - qu'est-ce que c'est ?

IRIS ApiPub est un projet de type code source ouvert Open Source dont l'objectif principal est de publier automatiquement les API RESTful créées avec la technologie Intersystems IRIS, de la manière la plus simple et la plus rapide possible en utilisant la norme Open Specification API (OAS) standard, version 3.0.

Il permet à l'utilisateur de se concentrer sur la mise en œuvre et les règles métier (méthodes Web) de l'API, en abstrayant et en automatisant les autres aspects liés à la documentation, l'exposition, l'exécution et la surveillance des services.

Ce projet comprend également un exemple complet de mise en œuvre (apiPub.samples.api) de la Swagger Petstore, qui est l'échantillon officiel de swagger.

Testez-le avec vos services SOAP actuels

Si vous avez déjà publié des services SOAP, vous pouvez les tester en utilisant Rest/JSON avec OAS 3.0.

Lors de la publication de méthodes avec des types complexes, la classe de l'objet doit être une sous-classe de %XML.Adapter. De cette manière, les services SOAP précédemment installés sont rendus automatiquement compatibles.

Surveillez vos API avec IRIS Analytics

Activez la surveillance des API pour gérer et suivre tous vos Appels Rest. Vous pouvez également configurer vos propres indicateurs.

Installation

1. Effectuez un clone/git pull depuis le dépôt dans le répertoire local.

$ git clone https://github.com/devecchijr/apiPub.git

2. Ouvrez le terminal dans ce répertoire et exécutez la commande suivante :

$ docker-compose up -d

3. Exécutez le conteneur IRIS avec le projet :

$ docker-compose up -d

Test de l'application

Ouvrez l'URL http://localhost:52773/swagger-ui/index.html de swagger

Essayez d'exécuter une opération à l'aide de l'API Petstore, par exemple en effectuant un postage d'un nouveau pet.

Consultez la table de bord du moniteur apiPub. Essayez d'explorer le domaine petStore pour explorer et analyser les messages.

Modifiez ou créez des méthodes dans la classe apiPub.samples.api et revenez à la documentation générée. Notez que toutes les modifications sont automatiquement reflétées dans la documentation OAS ou dans les schémas.

Publiez votre API selon la norme OAS 3.0 en seulement 3 étapes :

Étape 1

Définissez la classe d'implémentation de votre API et balises les méthodes avec l'attribut [WebMethod]

Cette étape n'est pas nécessaire si vous disposez déjà d'une mise en œuvre de WebServices.

Étape 2

Créez une sous-classe de apiPub.core.service et définissez sa propriété DispatchClass comme la classe Implementation créée précédemment. Incluez également le chemin de la documentation OAS 3.0. Si vous le souhaitez, pointez vers la classe apiPub.samples.api (PetStore).

Étape 3

Créez une application Web et définissez la classe de répartition comme la classe de service créée ci-dessus.

Utilisation de Swagger

Avec iris-web-swagger-ui vous pouvez exposer votre spécification de service. Il vous suffit de pointer vers le chemin de la documentation et... VOILÁ!!

Définition de l'en-tête de la spécification OAS

Il existe deux façons de définir l'en-tête OAS 3.0 :

La première consiste à créer un bloc JSON XDATA nommé apiPub dans la classe d'implémentation. Cette méthode autorise plus d'une balise et la modélisation est compatible avec la norme OAS 3.0. Les propriétés qui peuvent être personnalisées sont info, tags et servers.

XData apiPub [ MimeType = application/json ]
{
    {
        "info" : {
            "description" : "Il s'agit d'un exemple de serveur Petstore.  Vous pouvez en savoir plus sur Swagger à l'adresse suivante\n[http://swagger.io](http://swagger.io) or on\n[irc.freenode.net, #swagger](http://swagger.io/irc/).\n",
            "version" : "1.0.0",
            "title" : "IRIS Petstore (Dev First)",
            "termsOfService" : "http://swagger.io/terms/",
            "contact" : {
            "email" : "apiteam@swagger.io"
            },
            "license" : {
            "name" : "Apache 2.0",
            "url" : "http://www.apache.org/licenses/LICENSE-2.0.html"
            }
        },
        "tags" : [ {
            "name" : "pet",
            "description" : "Tout sur vos Pets",
            "externalDocs" : {
            "description" : "Pour en savoir plus",
            "url" : "http://swagger.io"
            }
        }, {
            "name" : "store",
            "description" : "Accès aux commandes du Petstore"
        }, {
            "name" : "user",
            "description" : "Opérations sur l'utilisateur",
            "externalDocs" : {
            "description" : "En savoir plus sur notre magasin",
            "url" : "http://swagger.io"
            }
        } ]
    }
}

La seconde méthode consiste à définir des paramètres dans la classe d'implémentation, comme dans l'exemple suivant :

Parameter SERVICENAME = "My Service";

Parameter SERVICEURL = "http://localhost:52776/apipub";

Parameter TITLE As %String = "REST aux API SOAP";

Parameter DESCRIPTION As %String = "API pour le proxy des services Web SOAP via REST";

Parameter TERMSOFSERVICE As %String = "http://www.intersystems.com/terms-of-service/";

Parameter CONTACTNAME As %String = "John Doe";

Parameter CONTACTURL As %String = "https://www.intersystems.com/who-we-are/contact-us/";

Parameter CONTACTEMAIL As %String = "support@intersystems.com";

Parameter LICENSENAME As %String = "Copyright InterSystems Corporation, tous droits réservés.";

Parameter LICENSEURL As %String = "http://docs.intersystems.com/latest/csp/docbook/copyright.pdf";

Parameter VERSION As %String = "1.0.0";

Parameter TAGNAME As %String = "Services";

Parameter TAGDESCRIPTION As %String = "Services d'héritage";

Parameter TAGDOCSDESCRIPTION As %String = "Pour en savoir plus";

Parameter TAGDOCSURL As %String = "http://intersystems.com";

Personnalisez vos API

Vous pouvez personnaliser plusieurs aspects de l'API, tels que les balises, les chemins et les verbes. Pour cela, vous devez utiliser une notation spéciale, déclarée dans le commentaire de la méthode personnalisée.

Syntaxe:

/// @apiPub[assignment clause]
[Method/ClassMethod] methodName(params as type) As returnType {

}

Toutes les personnalisations présentées à titre d'exemple dans cette documentation se trouvent dans la classe apiPub.samples.api.

Personnalisation des verbes

Lorsqu'aucun type complexe n'est utilisé comme paramètre d'entrée, apiPub attribue automatiquement le verbe Get. Dans le cas contraire, le verbe Post sera attribué.

Si vous souhaitez personnaliser la méthode, ajoutez la ligne suivante aux commentaires de la méthode.

/// @apiPub[verb="verb"]

Où verbe peut être get, post, put, delete ou patch.

Exemple:

/// @apiPub[verb="put"]

Personnalisation des chemins

Cet outil attribue automatiquement des chemins ou des routages aux Méthodes Web. Il utilise le nom de la méthode comme chemin, par défaut.

Si vous souhaitez personnaliser le chemin, ajoutez la ligne suivante aux commentaires de la méthode.

/// @apiPub[path="path"]

Où chemin peut être n'importe quelle valeur précédée d'un slash, tant qu'il n'entre pas en conflit avec un autre chemin dans la même classe d'implémentation.

Exemple:

/// @apiPub[path="/pet"]

Une autre utilisation très courante du chemin est de définir un ou plusieurs paramètres dans le chemin lui-même. Pour cela, le nom du paramètre défini dans la méthode doit être entouré d'accolades.

Exemple:

/// @apiPub[path="/pet/{petId}"]
Method getPetById(petId As %Integer) As apiPub.samples.Pet [ WebMethod ]
{
}

Lorsque le nom du paramètre interne diffère du nom du paramètre affiché, le nom peut être égalisé selon l'exemple suivant :

/// @apiPub[path="/pet/{petId}"]
/// @apiPub[params.pId.name="petId"]
Method getPetById(pId As %Integer) As apiPub.samples.Pet [ WebMethod ]
{
}

Dans l'exemple ci-dessus, le paramètre interne pId est affiché sous la forme petId.

Personnalisation des balises

Il est possible de définir le tag (regroupement) de la méthode lorsque plus d'un tag est défini dans l'en-tête.

/// @apiPub[tag="value"]

Exemple:

/// @apiPub[tag="user"]

Personnalisation du succès Code d'état

Si vous souhaitez modifier le Code d'état de réussite de la méthode, qui est 200 par défaut, il convient d'utiliser la notation suivante.

/// @apiPub[successfulCode="code"]

Exemple:

/// @apiPub[successfulCode="201"]

Personnalisation de l'exception Code d'état

Cet outil traite toutes les exceptions comme Code d'état 500 par défaut. Si vous souhaitez ajouter de nouveaux codes d'exception à la documentation, utilisez la notation suivante.

/// @apiPub[statusCodes=[{code:"code",description:"description"}]]

Où la propriété statusCodes est un tableau d'objets contenant le code et la description.

Exemple:

/// @apiPub[statusCodes=[
/// {"code":"400","description":"Invalid ID supplied"}
/// ,{"code":"404","description":"Pet not found"}]
/// ]

Lorsque vous soulevez l'exception, incluez Code d'état dans la description de l'exception entre les caractères "<" et ">".

Exemple:

Throw ##Class(%Exception.StatusException).CreateFromStatus($$$ERROR($$$GeneralError, "<400> Invalid ID supplied"))}

Voir la méthode getPetById de la classe apiPub.samples.api

Marquer l'API comme déconseillé

Pour que l'API soit affichée comme déconseillée, la notation suivante doit être utilisée :

/// @apiPub[deprecated="true"]

Personnalisation de l'operationId

Selon la spécification OAS, operationId est une chaîne unique utilisée pour identifier une API ou une opération. Dans cet outil, il est utilisé dans le même but lors des opérations de surveillance et suivi operations.

Par défaut, elle porte le même nom que la méthode de la classe d'implémentation.

Si vous souhaitez le modifier, utilisez la notation suivante

/// @apiPub[operationId="updatePetWithForm"]

Modification du jeu de caractères de la méthode

Le jeu de caractères par défaut est généralement défini à l'aide du paramètre CHARSET de la classe de service, décrit dans étape 2. Si vous souhaitez personnaliser le jeu de caractères d'une méthode, vous devez utiliser la notation suivante ::

/// @apiPub[charset="value"]

Exemple:

/// @apiPub[charset="UTF-8"]

Personnalisation des noms et autres caractéristiques des paramètres

Vous pouvez personnaliser plusieurs aspects des paramètres d'entrée et de sortie de chaque méthode, tels que les noms et les descriptions qui seront affichés pour chaque paramètre.

Pour personnaliser un paramètre spécifique, utilisez la notation suivante

/// @apiPub[params.paramId.property="value"]

ou pour des réponses :

/// @apiPub[response.property="value"]

Exemple:

/// @apiPub[params.pId.name="petId"]
/// @apiPub[params.pId.description="ID of pet to return"]

Dans ce cas, le nom petId et la description ID du pet à rendre sont attribués au paramètre défini comme pId

Lorsque la personnalisation n'est pas spécifique à un paramètre donné, la notation suivante est utilisée

/// @apiPub[params.property="value"]

Dans l'exemple suivant, la description Ceci ne peut être fait que par l'utilisateur connecté est attribuée à l'ensemble de la demande, et pas seulement à un seul paramètre :

/// @apiPub[params.description="Ceci ne peut être fait que par l'utilisateur connecté."]

Autres propriétés qui peuvent être personnalisées pour des paramètres spécifiques

Utilisez la notation suivante pour les paramètres d'entrée ou de sortie :

/// @apiPub[params.paramId.property="value"]

Pour les reponses:

/// @apiPub[response.property="value"]

Relier des schémas analysables à des types JSON dynamiques (%Library.DynamicObject)

Vous pouvez relier les schémas OAS 3.0 aux types dynamiques internes

L'avantage d'associer le schéma au paramètre, outre le fait d'informer l'utilisateur sur une spécification d'objet requise, est l'analyse automatique de la demande, qui est effectuée pendant l'appel API. Si l'utilisateur de l'API, par exemple, soumet une propriété qui ne figure pas dans le schéma, ou envoie une date dans un format non valide, ou n'inclut pas une propriété obligatoire, une ou plusieurs erreurs seront renvoyées à l'utilisateur contenant des informations sur ces problèmes.

La première étape consiste à inclure le schéma souhaité dans le bloc XDATA, comme indiqué ci-dessous. Dans ce cas, le schéma appelé User peut être utilisé par n'importe quelle méthode. Il doit suivre les mêmes règles que celles utilisées dans la modélisation [OAS 3.0] (https://swagger.io/docs/specification/data-models/).

XData apiPub [ MimeType = application/json ]
{
    {
        "schemas": {
            "User": {
                "type": "object",
                "required": [
                    "id"
                ],
                "properties": {
                    "id": {
                        "type": "integer",
                        "format": "int64"
                    },
                    "username": {
                        "type": "string"
                    },
                    "firstName": {
                        "type": "string"
                    },
                    "lastName": {
                        "type": "string"
                    },
                    "email": {
                        "type": "string"
                    },
                    "password": {
                        "type": "string"
                    },
                    "phone": {
                        "type": "string"
                    },
                    "userStatus": {
                        "type": "integer",
                        "description": "(short) User Status"
                    }
                }
            }            
        }
    }
}

La deuxième étape consiste à associer le nom du schéma renseigné à l'étape précédente au paramètre interne de type %Library.DynamicObject en utilisant la notation suivante :

/// @apiPub[params.paramId.schema="schema name"]

Exemple associant le paramètre user au schéma User :

/// @apiPub[params.user.schema="User"]
Method updateUserUsingOASSchema(username As %String, user As %Library.DynamicObject) As %Status [ WebMethod ]
{
    code...
}

Exemple de soumission d'une requête avec une erreur. La propriété username2 n'existe pas dans le schéma User. La propriété id n'est pas non plus définie alors qu'elle est requise :

{
  "username2": "devecchijr",
  "firstName": "claudio",
  "lastName": "devecchi junior",
  "email": "devecchijr@gmail.com",
  "password": "string",
  "phone": "string",
  "userStatus": 0
}

Exemple d'une réponse avec une erreur :

{
  "statusCode": 0,
  "message": "ERROR #5001: <Bad Request> Path User.id is required; Invalid path: User.username2",
  "errorCode": 5001
}

Voir les méthodes updateUserUsingOASSchema et getInventory de la classe apiPub.samples.api. La méthode getInventory est un exemple de schéma associé à la sortie de la méthode (réponse), elle n'est donc pas analysable.

Générer le schéma OAS 3.0 à partir d'un objet JSON

Pour faciliter la génération du schéma OAS 3.0, vous pouvez utiliser les éléments suivants ::

Définissez une variable avec un échantillon de l'objet JSON.

set myObject = {"prop1":"2020-10-15","prop2":true, "prop3":555.55, "prop4":["banana","orange","apple"]}

Utilisez la méthode utilitaire de la classe apiPub.core.publisher pour générer le schéma :

do ##class(apiPub.core.publisher).TemplateToOpenApiSchema(myObject,"objectName",.schema)

Copiez et collez le schéma renvoyé dans le bloc XDATA :

Exemple:

XData apiPub [ MimeType = application/json ]
{
    {
        "schemas": {
            {
                "objectName":   
                {
                    "type":"object",
                    "properties":{
                        "prop1":{
                            "type":"string",
                            "format":"date",
                            "example":"2020-10-15"      
                        },
                        "prop2":{
                            "type":"boolean",
                            "example":true
                        },
                        "prop3":{
                            "type":"number",
                            "example":555.55
                        },
                        "prop4":{
                            "type":"array",
                            "items":{
                                "type":"string",
                                "example":"apple"
                            }
                        }
                    }
                }
            }
        }
    }
}

Activer la surveillance (facultatif)

1 - Ajoutez et activez les composants suivants dans votre Production (IRIS Interopérabilité)

2 - Activez la surveillance de la classe décrite dans [l'étape 2] (https://github.com/devecchijr/apiPub#passo-2)

Le paramètre Traceable doit être activé.

Parameter Traceable As %Boolean = 1;

Parameter TracerBSName = "apiPub.tracer.bs";

Parameter APIDomain = "samples";

Le paramètre APIDomain est utilisé pour regrouper les API à surveiller.

3 - Importez les tableaux de bord

zn "IRISAPP"
Set sc = ##class(%DeepSee.UserLibrary.Utils).%ProcessContainer("apiPub.tracer.dashboards",1)

Vous pouvez également créer d'autres tableaux de bord, basés sur le cube apiPub Monitor.

Utilisez cet outil conjointement avec Intersystems API Manager

Acheminez vos API générées et bénéficiez de l'[Intersystems API Manager] (https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=AFL_IAM)

Compatibilité

ApiPub est compatible avec Intersystems IRIS ou Intersystems IRIS pour la santé, à partir de la version 2018.1.

Dépôt

Github: apiPub

Cette formation s'adresse aux débutants qui souhaitent découvrir le framework IRIS Interoperability. Nous utiliserons Docker et VSCode.

GitHub : https://github.com/grongierisc/formation-template

1. Formation Ensemble / Interoperability

Le but de cette formation est d'apprendre le cadre d'interopérabilité d'InterSystems, et en particulier l'utilisation de :

• Productions
• Messages
• Opérations commerciales
• Adaptateurs
• Processus métier
• Services commerciaux
• Services et opérations REST

TABLE DES MATIÈRES :

• 1. **Ensemble / Formation Interoperability **
• 2. Framework
• 3. Adapter le framework
• 4. Prérequis
• 5. Mise en place
  • 5.1. Conteneurs Docker
  • 5.2. Portail de gestion
  • 5.3. Sauvegarde de la progression
• 6. Productions
• 7. Opérations
  • 7.1. Création de notre classe de stockage
  • 7.2. Création de notre classe de messages
  • 7.3. Création de notre opération
  • 7.4. Ajout de l'opération à la production
  • 7.5. Test
• 8. Processus métier
  • 8.1. BP simple
    • 8.1.1. Création du processus
    • 8.1.2. Modifier le contexte d'un BP
  • 8.2. BP lisant les lignes CSV
    • 8.2.1. Création d'une carte d'enregistrement
    • 8.2.2. Création d'une transformation de données
    • 8.2.3. Ajout de la transformation des données au processus métier
    • 8.2.4. Configuration de la production
    • 8.2.5. Test de
• 9. Accéder à une base de données externe à l'aide de JDBC
  • 9.1. Création de notre nouvelle opération
  • 9.2. Configurer la production
  • 9.3. Test
  • 9.4. Exercice
  • 9.5. Solution
• 10. Service REST
  • 10.1. Créer le service
  • 10.2. Ajouter notre BS
  • 10.3. Tester
• Conclusion

2. Cadre de travail

Voici le Framework IRIS.

Les composants à l'intérieur d'IRIS représentent une production. Les adaptateurs entrants et les adaptateurs sortants nous permettent d'utiliser différents types de formats comme entrée et sortie pour notre base de données. Les applications composites nous donneront accès à la production via des applications externes comme les services REST.

Les flèches entre tous ces composants sont des messages. Ils peuvent être des demandes ou des réponses.

3. Adapter le framework

Dans notre cas, nous allons lire des lignes dans un fichier csv et les enregistrer dans la base de données IRIS.

Nous ajouterons ensuite une opération qui nous permettra de sauvegarder également des objets dans une base de données externe, en utilisant JDBC. Cette base de données sera située dans un conteneur docker, en utilisant postgre.

Enfin, nous verrons comment utiliser des applications composites pour insérer de nouveaux objets dans notre base de données ou pour consulter cette base (dans notre cas, via un service REST).

Le framework adapté à notre objectif nous donne :

4. Prérequis

Pour cette formation, vous aurez besoin de :

• VSCode : https://code.visualstudio.com/
• La suite d'addons InterSystems pour vscode : https://intersystems-community.github.io/vscode-objectscript/installation/
• Docker : https://docs.docker.com/get-docker/
• L'addon docker pour VSCode.

5. Mise en place

5.1. Conteneurs Docker

Afin d'avoir accès aux images InterSystems, nous devons nous rendre à l'url suivante : http://container.intersystems.com. Après nous être connectés avec nos identifiants InterSystems, nous obtiendrons notre mot de passe pour nous connecter au registre. Dans l'addon docker VScode, dans l'onglet image, en appuyant sur connect registry et en entrant la même url que précédemment (http://container.intersystems.com) comme registre générique, il nous sera demandé de donner nos identifiants. L'identifiant est l'identifiant habituel mais le mot de passe est celui que nous avons obtenu sur le site Web.

De là, nous devrions pouvoir construire et composer nos conteneurs (avec les fichiers docker-compose.yml et Dockerfile donnés).

5.2. Portail de gestion

Nous allons ouvrir un portail de gestion. Il nous donnera accès à une page web où nous pourrons créer notre production. Le portail devrait être situé à l'url : http://localhost:52775/csp/sys/UtilHome.csp?$NAMESPACE=IRISAPP. Vous aurez besoin des informations d'identification suivantes :

IDENTIFIANT : SuperUser

MOT DE PASSE : SYS

5.3. Sauvegarde de la progression

Une partie des choses que nous allons faire sera sauvegardée localement, mais tous les processus et productions sont sauvegardés dans le conteneur docker. Afin de persister tout notre progrès, nous devons exporter chaque classe qui est créée par le portail de gestion avec l'addon InterSystems ObjectScript :

Nous devrons sauvegarder notre production, le plan d'enregistrement, les processus métier et le transfert de données de cette manière. Après cela, lorsque nous fermerons notre conteneur docker et le recomposerons, nous aurons toujours toute notre progression sauvegardée localement (c'est, bien sûr, à faire après chaque changement via le portail). Pour le rendre à nouveau accessible à IRIS, nous devons compiler les fichiers exportés (en les sauvegardant, les addons InterSystems s'occupent du reste).

6. Productions

Nous pouvons maintenant créer notre première production. Pour cela, nous allons passer par les menus [Interoperability] et [Configurer] :

Nous devons ensuite appuyer sur [Nouveau], sélectionner le paquet [Formation] et choisir un nom pour notre production :

Immédiatement après avoir créé notre production, nous devons cliquer sur [Paramètres de production] juste au-dessus de la section [Opérations]. Dans le menu latéral de droite, nous devrons activer [Test activé] dans la partie [Développement et débogage] de l'onglet [Paramètres] (n'oubliez pas de cliquer sur [Appliquer]).

Dans cette première production, nous allons maintenant ajouter des opérations commerciales.

7. Opérations

Une Business Operation (BO) est une opération spécifique qui nous permettra d'envoyer des requêtes depuis IRIS vers une application / un système externe. Elle peut également être utilisée pour enregistrer directement dans IRIS ce que nous voulons.

Nous allons créer ces opérations en local, c'est-à-dire dans le fichier Formation/BO/. En sauvegardant les fichiers, nous les compilerons dans IRIS.

Pour notre première opération, nous allons sauvegarder le contenu d'un message dans la base de données locale.

Nous devons d'abord avoir un moyen de stocker ce message.

7.1. Création de notre classe de stockage

Les classes de stockage dans IRIS étendent le type %Persistent. Elles seront enregistrées dans la base de données interne.

Dans notre fichier Formation/Table/Formation.cls nous avons :

Class Formation.Table.Formation Extends %Persistent
{

Property Name As %String;

Property Salle As %String;

}

Notez que lors de l'enregistrement, des lignes supplémentaires sont automatiquement ajoutées au fichier. Elles sont obligatoires et sont ajoutées par les addons InterSystems.

7.2. Création de notre classe de messages

Ce message contient un objet Formation, situé dans le fichier Formation/Obj/Formation.cls :

Class Formation.Obj.Formation Extends (%SerialObject, %XML.Adaptor)
{

Property Nom As %String;

Property Salle As %String;

}

La classe Message utilisera cet objet Formation, src/Formation/Msg/FormationInsertRequest.cls :

Class Formation.Msg.FormationInsertRequest Extends Ens.Request
{

Property Formation As Formation.Obj.Formation;

}

7.3. Création de notre opération

Maintenant que nous avons tous les éléments dont nous avons besoin, nous pouvons créer notre opération, dans le fichier Formation/BO/LocalBDD.cls :

Class Formation.BO.LocalBDD Extends Ens.BusinessOperation
{

Parameter INVOCATION = "Queue";

Method InsertLocalBDD(pRequest As Formation.Msg.FormationInsertRequest, Output pResponse As Ens.StringResponse) As %Status
{
    set tStatus = $$$OK

    try{
        set pResponse = ##class(Ens.Response).%New()
        set tFormation = ##class(Formation.Table.Formation).%New()
        set tFormation.Name = pRequest.Formation.Nom
        set tFormation.Salle = pRequest.Formation.Salle
        $$$ThrowOnError(tFormation.%Save())
    }
    catch exp
    {
        Set tStatus = exp.AsStatus()
    }

    Quit tStatus
}

XData MessageMap
{
<MapItems>
    <MapItem MessageType="Formation.Msg.FormationInsertRequest"> 
        <Method>InsertLocalBDD</Method>
    </MapItem>
</MapItems>
}

}

La MessageMap nous donne la méthode à lancer en fonction du type de demande (le message envoyé à l'opération).

Comme nous pouvons le voir, si l'opération a reçu un message du type Formation.Msg.FormationInsertRequest, la méthode InsertLocalBDD sera appelée. Cette méthode enregistrera le message dans la base de données locale d'IRIS.

7.4. Ajout de l'opération à la production

Nous devons maintenant ajouter cette opération à la production. Pour cela, nous utilisons le portail de gestion. En appuyant sur le signe [+] à côté de [Opérations], nous avons accès à l'[Assistant d'opérations commerciales]. Là, nous choisissons la classe d'opération que nous venons de créer dans le menu déroulant.

9.3. Test

Un double clic sur l'opération nous permettra de l'activer. Après cela, en sélectionnant l'opération et en allant dans les onglets [Actions] dans le menu latéral droit, nous devrions être en mesure de tester l'opération (si ce n'est pas le cas, consultez la partie création de la production pour activer les tests / vous devrez peut-être démarrer la production si elle est arrêtée).

En faisant cela, nous allons envoyer à l'opération un message du type que nous avons déclaré plus tôt. Si tout se passe bien, les résultats devraient être comme indiqué ci-dessous :

L'affichage de la trace visuelle nous permettra de voir ce qui s'est passé entre les processus, les services et les opérations. Ici, nous pouvons voir le message envoyé à l'opération par le processus, et l'opération renvoyant une réponse (qui est juste une chaîne vide).

8. Processus métier

Les processus métier (BP) sont la logique métier de notre production. Ils sont utilisés pour traiter les demandes ou relayer ces demandes à d'autres composants de la production.

Les processus métier sont créés dans le portail de gestion :

8.1. BP simple

8.1.1. Création du processus

Nous sommes maintenant dans le concepteur de processus métier. Nous allons créer un BP simple qui appellera notre opération :

8.1.2. Modifier le contexte d'un BP

Un BP possède un Contexte. Il est composé d'une classe de requête, la classe de l'entrée, et d'une classe de réponse, la classe de la sortie. Les processus métier n'ont qu'une entrée et une sortie. Il est également possible d'ajouter des propriétés.

Puisque notre BP ne sera utilisé que pour appeler notre BO, nous pouvons mettre comme classe de requête la classe de message que nous avons créée (nous n'avons pas besoin d'une sortie puisque nous voulons juste insérer dans la base de données).

Nous avons ensuite choisi la cible de la fonction d'appel : notre BO. Cette opération, étant appelée a une propriété callrequest. Nous devons lier cette callrequest à la requête de la BP (elles sont toutes deux de la classe Formation.Msg.FormationInsertRequest), nous faisons cela en cliquant sur la fonction d'appel et en utilisant le constructeur de requête :

Nous pouvons maintenant sauvegarder cette BP (dans le package « Formation.BP » et sous le nom « InsertLocalBDD » ou « Main », par exemple). Tout comme les opérations, les processus peuvent être instanciés et testés via la configuration de production, pour cela ils doivent être compilés au préalable (sur l'écran Concepteur de processus métier).

Pour l'instant, notre processus ne fait que transmettre le message à notre opération. Nous allons le complexifier pour que le BP prenne en entrée une ligne d'un fichier CSV.

8.2. Lecture de lignes CSV par un BP

8.2.1. Création d'une carte d'enregistrement

Afin de lire un fichier et de mettre son contenu dans un fichier, nous avons besoin d'une Carte d'enregistrement (RM). Il existe un Record Mapper spécialisé pour les fichiers CSV dans le menu [Interoperability > Build] du portail de gestion :

Nous créerons le mapper comme suit :

Nous allons créer le mappeur comme ceci :

Maintenant que la carte est créée, nous devons la générer (avec le bouton Générer). Nous devons maintenant avoir une Transformation de données à partir du format de la carte des enregistrements et un message d'insertion.

8.2.2. Création d'une transformation de données

Nous trouverons le créateur de transformations de données (DT) dans le menu [Interoperability > Builder]. Nous allons créer notre DT comme ceci (si vous ne trouvez pas Formation.RM.Csv.Record, peut-être que vous n'avez pas généré la carte d'enregistrement) :

Nous pouvons pouvons maintenant mapper les différents champs ensemble :

8.2.3. Ajout de la transformation des données au processus métier

La première chose que nous devons changer est la classe de requête de la BP, puisque nous devons avoir en entrée la carte d'enregistrement que nous avons créée.

Nous pouvons alors ajouter notre transformation (le nom du processus ne change rien, d'ici nous avons choisi de le nommer Main) :

L'activité de transformation va prendre la requête de la BP (un enregistrement du fichier CSV, grâce à notre Record Mapper), et la transformer en un message FormationInsertRequest. Afin de stocker ce message pour l'envoyer à la BO, nous devons ajouter une propriété au contexte de la BP.

Nous pouvons maintenant configurer notre fonction de transformation pour qu'elle prenne l'entrée du BP et enregistre sa sortie dans la propriété nouvellement créée. La source et la cible de la transformation RmToMsg sont respectivement request et context.Msg :

Nous devons faire de même pour Call BO. Son entrée, ou callrequest, est la valeur stockée dans context.msg :

Au final, le flux dans la BP peut être représenté comme ceci :

8.2.4. Configuration de la production

Avec le signe [+], nous pouvons ajouter notre nouveau processus à la production (si ce n'est pas déjà fait). Nous avons également besoin d'un service générique pour utiliser le record map, nous utilisons EnsLib.RecordMap.Service.FileService (nous l'ajoutons avec le bouton [+] à côté des services). Nous paramétrons ensuite ce service :

Nous devrions maintenant être en mesure de tester notre BP.

8.2.5. Test

Nous testons l'ensemble de la production comme suit :

Dans le menu Explorateur système > SQL, vous pouvez exécuter la commande

SELECT 
ID, Name, Salle
FROM Formation_Table.Formation

pour voir les objets que nous venons d'enregistrer.

9. Accéder à une base de données externe à l'aide de JDBC

Dans cette section, nous allons créer une opération pour sauvegarder nos objets dans une base de données externe. Nous utiliserons l'API JDBC, ainsi que l'autre conteneur docker que nous avons mis en place, avec postgre dessus.

9.1. Création de notre nouvelle opération

Notre nouvelle opération, dans le fichier Formation/BO/RemoteBDD.cls est la suivante :

Include EnsSQLTypes

Class Formation.BO.RemoteBDD Extends Ens.BusinessOperation
{

Parameter ADAPTER = "EnsLib.SQL.OutboundAdapter";

Property Adapter As EnsLib.SQL.OutboundAdapter;

Parameter INVOCATION = "Queue";

Method InsertRemoteBDD(pRequest As Formation.Msg.FormationInsertRequest, Output pResponse As Ens.StringResponse) As %Status
{
    set tStatus = $$$OK

    try{
        set pResponse = ##class(Ens.Response).%New()
        set ^inc = $I(^inc)
        set tInsertSql = "INSERT INTO public.formation (id, nom, salle) VALUES(?, ?, ?)"
        $$$ThrowOnError(..Adapter.ExecuteUpdate(.nrows,tInsertSql,^inc,pRequest.Formation.Nom, pRequest.Formation.Salle ))
    }
    catch exp
    {
        Set tStatus = exp.AsStatus()
    }

    Quit tStatus
}

XData MessageMap
{
<MapItems>
    <MapItem MessageType="Formation.Msg.FormationInsertRequest"> 
        <Method>InsertRemoteBDD</Method>
    </MapItem>
</MapItems>
}

}

Cette opération est similaire à la première que nous avons créée. Lorsqu'elle recevra un message du type Formation.Msg.FormationInsertRequest, elle utilisera un adaptateur pour exécuter des requêtes SQL. Ces requêtes seront envoyées à notre base de données postgre.

9.2. Configurer la production

Maintenant, via le portail de gestion, nous allons instancier cette opération (en l'ajoutant avec le signe [+] dans la production).

Nous devrons également ajouter le JavaGateway pour le pilote JDBC dans les services. Le nom complet de ce service est EnsLib.JavaGateway.Service.

Nous devons maintenant configurer notre opération. Puisque nous avons mis en place un conteneur postgre, et connecté son port 5432, les valeurs dont nous avons besoin dans les paramètres suivants sont :

DSN : jdbc:postgresql://db:5432/DemoData

Pilote JDBC : org.postgresql.Driver

JDBC Classpath : /tmp/iris/postgresql-42.2.14.jar

Enfin, nous devons configurer les informations d'identification pour avoir accès à la base de données distante. Pour cela, nous devons ouvrir la visionneuse d'identifiants :

L'identifiant et le mot de passe sont tous deux DemoData, comme nous l'avons configuré dans le fichier docker-compose.yml.

De retour à la production, nous pouvons ajouter « Postgre » dans le champ [Identifiant] dans les paramètres de notre opération (il devrait être dans le menu déroulant). Avant de pouvoir le tester, nous devons ajouter le JGService à l'opération. Dans l'onglet [Paramètres], dans les [Paramètres supplémentaires] :

7.5. Test

Lors du test, la trace visuelle doit indiquer un succès :

Lors du test, la trace visuelle doit montrer un succès :

9.4. Exercice

À titre d'exercice, il pourrait être intéressant de modifier BO.LocalBDD afin qu'il renvoie un booléen qui indiquera au BP d'appeler BO.RemoteBDD en fonction de la valeur de ce booléen.

Indice : cela peut être fait en changeant le type de réponse que LocalBDD renvoie et en ajoutant une nouvelle propriété au contexte et en utilisant l'activité if dans notre BP.

9.5. Solution

Tout d'abord, nous devons avoir une réponse de notre opération LocalBDD. Nous allons créer un nouveau message, dans le fichier Formation/Msg/FormationInsertResponse.cls :

Class Formation.Msg.FormationInsertResponse Extends Ens.Response
{

Property Double As %Boolean;

}

Ensuite, nous modifions la réponse de LocalBDD par cette réponse, et définissons la valeur de son booléen de manière aléatoire (ou non) :

Method InsertLocalBDD(pRequest As Formation.Msg.FormationInsertRequest, Output pResponse As Formation.Msg.FormationInsertResponse) As %Status
{
    set tStatus = $$$OK

    try{
        set pResponse = ##class(Formation.Msg.FormationInsertResponse).%New()
        if $RANDOM(10) < 5 {
            set pResponse.Double = 1
        } 
        else {
            set pResponse.Double = 0
        }
...

Nous allons maintenant créer un nouveau processus (copié sur celui que nous avons fait), où nous ajouterons une nouvelle propriété de contexte, de type %Boolean :

Cette propriété sera remplie avec la valeur du callresponse.Double de notre appel d'opération (nous devons définir la [Classe de message de réponse] à notre nouvelle classe de message) :

Nous ajoutons ensuite une activité if, avec la propriété context.Double comme condition :

TRÈS IMPORTANT : nous devons décocher Asynchrone dans les paramètres de notre appel LocallBDD, ou l'activité if se déclenchera avant de recevoir la réponse booléenne.

Enfin, nous configurons notre activité d'appel avec comme cible le BO RemoteBDD :

Pour compléter l'activité if, nous devons faire glisser un autre connecteur de la sortie du if vers le triangle join ci-dessous. Comme nous ne ferons rien si le booléen est faux, nous laisserons ce connecteur vide. Après avoir compilé et instancié, nous devrions être en mesure de tester notre nouveau processus. Pour cela, nous devons changer le Target Config Name de notre File Service.

Dans la trace, nous devrions avoir environ la moitié des objets lus dans le csv enregistrés également dans la base de données distante.

10. Service REST

Dans cette partie, nous allons créer et utiliser un service REST.

10.1. Créer le service

Pour créer un service REST, nous avons besoin d'une classe qui étend %CSP.REST, dans Formation/REST/Dispatch.cls nous avons :

Class Formation.REST.Dispatch Extends %CSP.REST
{

/// Ignore any writes done directly by the REST method.
Parameter IgnoreWrites = 0;

/// Convertir par défaut le flux d'entrée en Unicode
Parameter CONVERTINPUTSTREAM = 1;

/// Le jeu de caractères par défaut est utf-8
Parameter CHARSET = "utf-8";

Parameter HandleCorsRequest = 1;

XData UrlMap [ XMLNamespace = "http://www.intersystems.com/urlmap" ]
{
<Routes>
  <!-- Get this spec -->
  <Route Url="/import" Method="post" Call="import" />
</Routes>
}

/// Obtenir cette spécification
ClassMethod import() As %Status
{
  set tSc = $$$OK

  Try {

      set tBsName = "Formation.BS.RestInput"
      set tMsg = ##class(Formation.Msg.FormationInsertRequest).%New()

      set body = $zcvt(%request.Content.Read(),"I","UTF8")
      set dyna = {}.%FromJSON(body)

      set tFormation = ##class(Formation.Obj.Formation).%New()
      set tFormation.Nom = dyna.nom
      set tFormation.Salle = dyna.salle

      set tMsg.Formation = tFormation

      $$$ThrowOnError(##class(Ens.Director).CreateBusinessService(tBsName,.tService))

      $$$ThrowOnError(tService.ProcessInput(tMsg,.output))

  } Catch ex {
      set tSc = ex.AsStatus()
  }

  Quit tSc
}

}

Cette classe contient une route pour importer un objet, liée au verbe POST :

<Routes>
  <!-- Obtenir cette spécification -->
  <Route Url="/import" Method="post" Call="import" />
</Routes>

La méthode d'importation va créer un message qui sera envoyé à un service métier.

10.2. Ajouter notre BS

Nous allons créer une classe générique qui va router toutes ses sollicitations vers TargetConfigNames. Cette cible sera configurée lorsque nous instancierons ce service. Dans le fichier Formation/BS/RestInput.cls nous avons :

Class Formation.BS.RestInput Extends Ens.BusinessService
{

Property TargetConfigNames As %String(MAXLEN = 1000) [ InitialExpression = "BuisnessProcess" ];

Parameter SETTINGS = "TargetConfigNames:Basic:selector?multiSelect=1&context={Ens.ContextSearch/ProductionItems?targets=1&productionName=@productionId}";

Method OnProcessInput(pDocIn As %RegisteredObject, Output pDocOut As %RegisteredObject) As %Status
{
    set status = $$$OK

    try {

        for iTarget=1:1:$L(..TargetConfigNames, ",") {
            set tOneTarget=$ZStrip($P(..TargetConfigNames,",",iTarget),"<>W")  Continue:""=tOneTarget
            $$$ThrowOnError(..SendRequestSync(tOneTarget,pDocIn,.pDocOut))
        }
    } catch ex {
        set status = ex.AsStatus()
    }

    Quit status
}

}

De retour à la configuration de production, nous ajoutons le service de la manière habituelle. Dans le champ [Target Config Names], nous mettons notre BO LocalBDD :

Pour utiliser ce service, nous devons le publier. Pour cela, nous utilisons le menu [Modifier l'application Web] :

10.3. Test

Enfin, nous pouvons tester notre service avec n'importe quel type de client REST :

Conclusion

Grâce à cette formation, nous avons créé une production capable de lire les lignes d'un fichier csv et de sauvegarder les données lues à la fois dans la base de données IRIS et dans une base de données externe en utilisant JDBC. Nous avons également ajouté un service REST afin d'utiliser le verbe POST pour sauvegarder de nouveaux objets.

Nous avons découvert les principaux éléments du cadre d'interopérabilité d'InterSystems.

Nous l'avons fait en utilisant docker, vscode et le portail de gestion IRIS d'InterSystems.