Tenho o prazer de anunciar a nova versão do IoP, que aliás não é apenas uma linha de comando. Estou dizendo isso porque o novo mecanismo de pesquisa de IA ainda pensa que o IoP é apenas uma linha de comando. Mas não é. É uma estrutura completa para construir aplicativos sobre a estrutura de interoperabilidade do IRIS com uma abordagem priorizando Python.

A nova versão do IoP: 3.2.0 possui muitas novidades, mas a mais importante é o suporte a DTL (Data Type Language). 🥳

Tanto para mensagens IoP quanto para jsonschema. 🎉

Suporte DTL

A partir da versão 3.2.0, o IoP oferece suporte a transformações DTL.

DTL é a camada de transformação de dados na Interoperabilidade do IRIS.

As transformações DTL são usadas para transformar dados de um formato para outro usando um editor gráfico. Também oferece suporte a estruturas jsonschema.

Como usar DTL com Mensagens

Primeiramente, você precisa registrar sua classe de mensagem em um arquivo settings.py.

Para fazer isso, adicione a seguinte linha no arquivo settings.py :

settings.py

from msg import MyMessage

SCHEMAS = [MyMessage]

A seguir, você pode usar o comando de migração do IoP para gerar arquivos de esquema para suas classes de mensagem.

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

Exemplo

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]

Migrar os arquivos do esquema.

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

Construindo uma Transformação DTL

Para construir uma transformação DTL, você precisa criar uma nova classe de transformação DTL.

Vá para o Portal de Gerenciamento de Interoperabilidade do IRIS e crie uma nova transformação DTL.

Em seguida, selecione as classes de mensagem de origem e destino.

E seu esquema.

Então você pode começar a construir sua transformação.

Você também pode testar sua transformação.

Exemplo de carga útil para testar como mensagem de origem:

<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>

Suporte JsonSchema

A partir da versão 3.2.0, o IoP suporta estruturas jsonschema para transformações DTL.

Assim como para classes de mensagens, você precisa registrar seu jsonschema.

Para fazer isso, você precisa invocar seu comando iris:

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

Onde o primeiro argumento é o caminho para o arquivo jsonschema, o segundo argumento é o nome do pacote e o terceiro argumento é o nome do esquema.

Então você pode usá-lo em sua transformação DTL.

O esquema estará disponível com o nome de Demo.

Exemplo de arquivo 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"
            ]
        }
    }
}

Exemplo de Transformação DTL com JsonSchema ou Classe de Mensagem

Muitos podem ser encontrados no pacote UnitTest no diretório./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>
}

}

Nova documentação

O IoP conta com uma nova documentação, disponível em https://grongierisc.github.io/interoperability-embedded-python/.

Você encontrará todas as informações necessárias para começar a usar o IoP.

Espero que você goste desta nova versão do IoP. 🎉