Me alegra anunciar la nueva versión de IoP, que, por cierto, no es solo una línea de comandos. Lo digo porque el nuevo motor de búsqueda con IA aún cree que IoP es solo una línea de comandos. Pero no lo es. Es todo un framework para construir aplicaciones sobre las funcionalidades de interoperabilidad de IRIS con un enfoque Python.

La nueva versión de IoP: 3.2.0 viene con muchas características nuevas, pero la más importante es el soporte para DTL . 🥳

Tanto para mensajes de IoP como para jsonschema. 🎉

Soporte para DTL

A partir de la versión 3.2.0, IoP admite transformaciones DTL.

DTL es la Capa de Transformación de Datos (Data Transformation Layer) en interoperabilidad de IRIS.

Las transformaciones DTL se utilizan para convertir datos de un formato a otro mediante un editor gráfico.
También es compatible con estructuras de jsonschema.

Cómo usar DTL con Mensajes

Primero, tenéis que registrar vuestra clase de mensaje en un archivo settings.py.

Para hacerlo, debéis añadir la siguiente línea en el archivo settings.py:

settings.py

from msg import MyMessage

SCHEMAS = [MyMessage]

Luego, podéis usar el comando de migración de IoP para generar los archivos de esquema para vuestras clases de mensaje.

iop --migrate /path/to/your/project/settings.py

Ejemplo

msg.py

from iop import Message
from dataclasses import dataclass

@dataclass
class MyMessage(Message):
    name: str = None
    age: int = None

settings.py

from msg import MyMessage

SCHEMAS = [MyMessage]

Migrad los archivos de esquema

iop --migrate /path/to/your/project/settings.py

Construyendo una transformación DTL

Para construir una transformación DTL, tenéis que crear una nueva clase de transformación DTL.

Id al Portal de Gestión de Interoperabilidad de IRIS y cread una nueva transformación DTL.

Luego, seleccionad las clases de mensaje de origen y destino.

Y su esquema.

Luego, podéis comenzar a construir vuestra transformación.

Incluso podéis probar vuestra transformación.

Ejemplo de payload para probar como mensaje de origen:

<test>
  <Message>
    <json><![CDATA[
{
"list_str":["toto","titi"],
"post":{"Title":"foo","Selftext":"baz"},
"list_post":[{"Title":"bar","Selftext":"baz"},{"Title":"foo","Selftext":"foo"}]
}
]]></json>
  </Message>
</test>

Soporte para JsonSchema

A partir de la versión 3.2.0, IoP admite estructuras jsonschema para las transformaciones DTL.

Al igual que con las clases de mensaje, necesitáis registrar vuestro jsonschema.

Para hacerlo, debéis invocar este comando de Iris:

zw ##class(IOP.Message.JSONSchema).ImportFromFile("/irisdev/app/random_jsonschema.json","Demo","Demo")

Donde el primer argumento es la ruta al archivo jsonschema, el segundo argumento es el nombre del paquete y el tercer argumento es el nombre del esquema.

Luego, podéis usarlo en vuestra transformación DTL.

El esquema estará disponible con el nombre de Demo.

Ejemplo de archivo jsonschema:

{
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "type": "object",
    "title": "PostMessage",
    "properties": {
        "post": {
            "allOf": [
                {
                    "$ref": "#/$defs/PostClass"
                }
            ]
        },
        "to_email_address": {
            "type": "string",
            "default": null
        },
        "my_list": {
            "type": "array",
            "items": {
                "type": "string"
            }
        },
        "found": {
            "type": "string",
            "default": null
        },
        "list_of_post": {
            "type": "array",
            "items": {
                "allOf": [
                    {
                        "$ref": "#/$defs/PostClass"
                    }
                ]
            }
        }
    },
    "$defs": {
        "PostClass": {
            "type": "object",
            "title": "PostClass",
            "properties": {
                "title": {
                    "type": "string"
                },
                "selftext": {
                    "type": "string"
                },
                "author": {
                    "type": "string"
                },
                "url": {
                    "type": "string"
                },
                "created_utc": {
                    "type": "number"
                },
                "original_json": {
                    "type": "string",
                    "default": null
                }
            },
            "required": [
                "title",
                "selftext",
                "author",
                "url",
                "created_utc"
            ]
        }
    }
}

Ejemplo de Transformación DTL con JsonSchema o Clase de Mensaje

Muchos se pueden encontrar en el paquete UnitTest en el directorio ./src/tests/cls.

Class UnitTest.ComplexTransform Extends Ens.DataTransformDTL [ DependsOn = IOP.Message ]
{

Parameter IGNOREMISSINGSOURCE = 1;

Parameter REPORTERRORS = 1;

Parameter TREATEMPTYREPEATINGFIELDASNULL = 0;

XData DTL [ XMLNamespace = "http://www.intersystems.com/dtl" ]
{
<transform sourceClass='IOP.Message' targetClass='IOP.Message' sourceDocType='registerFilesIop.message.ComplexMessage' targetDocType='registerFilesIop.message.ComplexMessage' create='new' language='objectscript' >
<assign value='source.{post}' property='target.{post}' action='set' />
<foreach property='source.{list_str()}' key='k1' >
<assign value='source.{list_str(k1)}_"foo"' property='target.{list_str()}' action='append' />
</foreach>
<foreach property='source.{list_post()}' key='k2' >
<assign value='source.{list_post().Title}' property='target.{list_post(k2).Title}' action='append' />
</foreach>
</transform>
}

}

Nueva documentación

IoP viene con una nueva documentación, la cual está disponible en https://grongierisc.github.io/interoperability-embedded-python/.

Allí encontraréis toda la información que necesitáis para comenzar a usar IoP.

Espero que disfrutéis esta nueva versión de IoP. 🎉