pyprod: interoperabilidad de IRIS en Python puro

Las Producciones de InterSystems IRIS proporcionan un marco potente para conectar sistemas heterogéneos a través de distintos protocolos y formatos de mensajes de forma fiable, observable y escalable. intersystems_pyprod, abreviatura de InterSystems Python Productions, es una biblioteca de Python que permite a los desarrolladores construir estos componentes de interoperabilidad completamente en Python. Diseñada para ofrecer flexibilidad, admite un enfoque híbrido: podéis mezclar sin problemas nuevos componentes basados en Python con otros ya existentes basados en ObjectScript, aprovechando vuestra infraestructura de IRIS ya establecida. Una vez definidos, estos componentes de Python se gestionan como cualquier otro; pueden añadirse, configurarse y conectarse usando la página de configuración de Producciones de IRIS.

Una introducción rápida a las Producciones de InterSystems IRIS

Elementos clave de una producción

Imagen del material de formación de Learning Services

Una Producción de IRIS generalmente recibe datos desde interfaces externas, los procesa mediante pasos coordinados y los enruta a su destino. A medida que los mensajes avanzan por el sistema, se persisten automáticamente, lo que hace que todo el flujo sea completamente trazable a través de las herramientas de traza visual y registro de IRIS. La arquitectura se basa en ciertos elementos clave:

1. Hosts de negocio: son los bloques fundamentales —Servicios, Procesos y Operaciones— que se intercambian mensajes persistentes entre sí.
2. Adaptadores: los adaptadores de entrada y salida gestionan la interacción con el mundo externo, manejando los protocolos específicos necesarios para recibir y enviar datos.
3. Callbacks: el motor utiliza métodos de callback específicos para pasar mensajes entre hosts, ya sea de forma síncrona o asíncrona. Estos callbacks siguen firmas estrictas y devuelven un objeto Statuspara garantizar la integridad de la ejecución.
4. Helpers de configuración: objetos como Properties y Parameters exponen ajustes a la interfaz de configuración de la producción, permitiendo a los usuarios instanciar, configurar y guardar fácilmente el estado de estos componentes.

Flujo de trabajo usando pyprod

Esto es esencialmente un proceso de 3 pasos.

1. Escribid vuestros componentes de producción en un script de Python normal. En ese script, importáis las clases base necesarias desde intersystems_pyprod y definís vuestros propios componentes mediante herencia, igual que haríais con cualquier otra librería de Python.
2. Cargadlos en InterSystems IRIS ejecutando el comando intersystems_pyprod (con el mismo nombre que la librería) desde el terminal y pasando la ruta a vuestro script de Python. Este paso enlaza las clases de Python con IRIS para que aparezcan como componentes de producción y puedan configurarse y conectarse mediante la interfaz estándar de Configuración de Producciones.
3. Cread la producción usando la página de Configuración de Producciones y arrancad la producción.

NOTA: Si creáis todos vuestros componentes con todas sus Properties definidas directamente dentro del script de Python, solo tendréis que añadirlos a la producción e iniciar la producción.

Podéis conectar pyprod a vuestra instancia de IRIS realizando una configuración única.

Ejemplo simple

En este ejemplo, mostramos un flujo de mensajes síncrono en el que una petición se origina en un Service, pasa por un Process y se envía a un Operation. La respuesta resultante recorre después el mismo camino en sentido inverso, pasando del Operation al Process y de ahí al Service. Además, mostramos cómo utilizar la utilidad IRISLog para escribir entradas de log personalizadas.

Paso 1

Cread vuestros componentes de Producción usando pyprod en el archivo HelloWorld.py.

Aquí tenéis algunas partes clave del código:

• Nombre del paquete: definimos iris_package_name, que prefija todas las clases tal como aparecen en la página de Configuración de Producción (si se omite, se usa el nombre del script como prefijo por defecto).
• Mensajes persistentes: definimos MyRequest y MyResponse. Estas son las estructuras de datos esenciales para la comunicación, ya que solo los objetos persistentes pueden pasarse entre Services, Processes y Operations.
• Adaptador de entrada: nuestro adaptador pasa una cadena al Service usando el método business_host_process_input.
• Business Service: implementado con la ayuda del callback OnProcessInput. 
  • MyService recibe datos del adaptador y los convierte en un mensaje MyRequest.
  • Usamos el parámetro ADAPTERIRIS para vincular el adaptador de entrada al Service. Tened en cuenta que este atributo debe llamarse ADAPTER en mayúsculas para alinearse con las convenciones de IRIS.
  • Definimos una propiedad targetIRIS, que permite a los usuarios seleccionar el componente de destino directamente desde la interfaz de configuración.
• Business Process: implementado con la ayuda del callback OnRequest.
• Business Operation: implementado con la ayuda del callback OnMessage (también podéis definir un MessageMap).
• Lógica y callbacks: finalmente, los hosts implementan su lógica principal dentro de callbacks estándar como OnProcessInput y OnRequest, enroutando mensajes usando el método SendRequestSync.

Podéis leer más sobre cada una de estas partes en la página de referencia de la API de pyprod y también en la Guía de inicio rápido.

import time

from intersystems_pyprod import (
    InboundAdapter,BusinessService, BusinessProcess, 
    BusinessOperation, OutboundAdapter, JsonSerialize, 
    IRISProperty, IRISParameter, IRISLog, Status)

iris_package_name = "helloworld"
class MyRequest(JsonSerialize):
    content: str

class MyResponse(JsonSerialize):
    content: str

class MyInAdapter(InboundAdapter):
    def OnTask(self):
        time.sleep(0.5)
        self.business_host_process_input("request message")
        return Status.OK()

class MyService(BusinessService):
    ADAPTER = IRISParameter("helloworld.MyInAdapter")
    target = IRISProperty(settings="Target")
    def OnProcessInput(self, input):
        persistent_message = MyRequest(input)
        status, response = self.SendRequestSync(self.target, persistent_message)
        IRISLog.Info(response.content)
        return status

class MyProcess(BusinessProcess):
    target = IRISProperty(settings="Target")
    def on_request(self, input):
        status, response = self.SendRequestSync(self.target,input)
        return status, response


class MyOperation(BusinessOperation):
    ADAPTER = IRISParameter("helloworld.MyOutAdapter")
    def OnMessage(self, input):
        status = self.ADAPTER.custom_method(input)
        response = MyResponse("response message")
        return status, response


class MyOutAdapter(OutboundAdapter):
    def custom_method(self, input):
        IRISLog.Info(input.content)
        return Status.OK()

Paso 2

Una vez que vuestro código esté listo, cargad los componentes en IRIS.

$ intersystems_pyprod /full/path/to/HelloWorld.py

    Loading MyRequest to IRIS...
    ...
    Load finished successfully.
    
    Loading MyResponse to IRIS...
    ...
    Load finished successfully.
    ...
    

Paso 3

Añadid cada host a la Producción usando la página de Configuración de Producción.

La imagen de abajo muestra cómo se configura MyService y su propiedad target a través de la interfaz de usuario. Seguid el mismo proceso para añadir MyProcess y MyOperation. Una vez completada la configuración, simplemente iniciad la producción para ver vuestros mensajes en movimiento.

Reflexiones finales

Al combinar la flexibilidad del ecosistema Python con la fiabilidad de nivel industrial de InterSystems IRIS, pyprod ofrece una vía moderna para construir soluciones de interoperabilidad. Tanto si estáis desarrollando producciones completamente nuevas “Pure Python” como si estáis ampliando infraestructuras existentes en ObjectScript con bibliotecas Python especializadas, pyprod garantiza que vuestros componentes permanezcan totalmente integrados, observables y fáciles de configurar. ¡Esperamos ver lo que construís!

Enlaces rápidos

GitHub repository  

PyPi Package

Apoyad el proyecto: si os resulta útil esta librería, considerad darnos una ⭐ en GitHub y sugerir mejoras. ¡Ayuda a que el proyecto crezca y facilita que otros desarrolladores de la comunidad de InterSystems lo descubran!