Les versions client d'IRIS/ HealthShare sont fournis avec l'installation du Serveur dans le dossier suivant :

<dossier d'install>/dev

example sous linux :

/usr/irissys/dev/dotnet/
`-- bin
    |-- InterSystems.Data.Bindings.2.0.0.nupkg
    |-- InterSystems.Data.IRISClient.2.0.0.nupkg
    |-- InterSystems.Data.Utils.2.0.0.nupkg
    |-- InterSystems.Data.XEP.2.0.0.nupkg
    |-- net5.0
    |   |-- InterSystems.Data.Gateway.pdb
    |   |-- InterSystems.Data.Gateway.xml
    |   |-- InterSystems.Data.GatewayArm
    |   |-- InterSystems.Data.GatewayLinux
    |   |-- InterSystems.Data.GatewayOSX
    |   |-- InterSystems.Data.IRISClient.dll
    |   |-- InterSystems.Data.IRISClient.xml
    |   |-- InterSystems.Data.Utils.dll
    |   |-- InterSystems.Data.Utils.xml
    |   `-- Newtonsoft.Json.dll
    `-- net6.0
        |-- InterSystems.Data.Gateway.pdb
        |-- InterSystems.Data.Gateway.xml
        |-- InterSystems.Data.GatewayArm
        |-- InterSystems.Data.GatewayLinux
        |-- InterSystems.Data.GatewayOSX
        |-- InterSystems.Data.IRISClient.dll
        |-- InterSystems.Data.IRISClient.xml
        |-- InterSystems.Data.Utils.dll
        |-- InterSystems.Data.Utils.xml
        `-- Newtonsoft.Json.dll

Toutes ces libraires peuvent etre utilisées sur une autre machine, elles ouvreront une socket TCP pour effectuer la connection sur le superserver port (1972 par default, 51773 pour HealthShare, enfin je crois).

Bonjour,

%Net.HttpRequest n'est pas une classe de type message (Ens.Request).

Il faut encapsuler le JSON en provenance du Service dans une classe qui herite de Ens.Request.

Bonjour,

Je ne peux pas reproduire votre erreur. Il me manque quelques informations.

Ce que j'ai fait jusqu'à présent est :

• ajouter les imports manquants
• ajouter la classe DFrameRequest manquante
  • je suppose que c'est une dataclass avec un champ nommé dframe de type pd.DataFrame
  • je suppose que c'est une sous-classe de Message
• j'ai ajouté une fonction main pour exécuter le code
  • je ne suis pas sûr du format du dataframe et des données qu'il contient

from dataclasses import dataclass
import pandas as pd
from grongier.pex import BusinessOperation,Message
from sqlalchemy import create_engine, types

@dataclass
class DFrameRequest(Message):
    dframe: pd.DataFrame

class FileOperationEmbedded(BusinessOperation):
    tablename = None
    engine = None

    def on_init(self):
        if not hasattr(self, "dsnIris"):
            self.dnsIris = 'iris+emb:///'
        if not hasattr(self, "schema"):
            self.schema = 'Toto'

        self.engine = create_engine(self.dnsIris)
        return None

    def on_message(self, request:DFrameRequest):
        df = pd.DataFrame(request.dframe.col)

        for row in request.dframe.col:
            df = pd.DataFrame.from_dict(row, orient='index').T.reset_index(drop=True)
            try:
                df.to_sql(name=self.tablename, con=self.engine, if_exists='append', index=False, schema=self.schema,
                          dtype={'id': types.INTEGER, 'col_type': types.VARCHAR(50), 'col_center': types.VARCHAR(50),
                                 'col_name': types.VARCHAR(50), 'col_issue_name': types.VARCHAR(50),
                                 'col_model': types.VARCHAR(50), 'col_treatment': types.VARCHAR(50),
                                 'source': types.VARCHAR(50), 'filename': types.VARCHAR(100), 'created_at': types.TIMESTAMP})
            except Exception as e:
                self.log_info(f"Une erreur s'est produite : {e}")

        return None
    
if __name__ == '__main__':
    # create a new instance of the business operation
    bo = FileOperationEmbedded()
    # initialize the business operation
    bo.on_init()

    # create a new message
    msg = DFrameRequest(pd.DataFrame())
    msg.dframe.col = [
            {'id': 1, 'col_type': 'type1', 'col_center': 'center1', 'col_name': 'name1', 'col_issue_name': 'issue1',
             'col_model': 'model1', 'col_treatment': 'treatment1', 'source': 'source1', 'filename': 'file1',
             'created_at': '2021-10-01 00:00:00'},
            {'id': 2, 'col_type': 'type2', 'col_center': 'center2', 'col_name': 'name2', 'col_issue_name': 'issue2',
             'col_model': 'model2', 'col_treatment': 'treatment2', 'source': 'source2', 'filename': 'file2',
             'created_at': '2021-10-02 00:00:00'}
        ]

    # send the message to the business operation
    bo.on_message(msg)
    print("Done")

Ensuite, à partir de votre code, je peux voir les problèmes suivants :

• vous utilisez le même nom de variable pour le dataframe et la liste des lignes
• la variable self.tablename n'est pas initialisée
• le nom FileOperationEmbedded n'est peut-être pas le meilleur nom pour votre classe car ce n'est pas une opération de fichier
• pourquoi utilisez-vous une boucle for pour itérer sur les lignes du dataframe ?

J'ai modifié votre code pour corriger ces problèmes :

from dataclasses import dataclass
import pandas as pd
from grongier.pex import BusinessOperation,Message
from sqlalchemy import create_engine, types

@dataclass
class DFrameRequest(Message):
    dframe: pd.DataFrame

class IrisSqlAlchmyEmbedded(BusinessOperation):
    tablename = None
    engine = None

    def on_init(self):
        if not hasattr(self, "dsnIris"):
            self.dnsIris = 'iris+emb:///'
        if not hasattr(self, "schema"):
            self.schema = 'Toto'
        if not hasattr(self, "tablename") or self.tablename is None:
            self.tablename = 'mytable'

        self.engine = create_engine(self.dnsIris)
        return None

    def on_message(self, request:DFrameRequest):

        try:
            request.dframe.to_sql(name=self.tablename, con=self.engine, if_exists='append', index=False, schema=self.schema,
                      dtype={'id': types.INTEGER, 'col_type': types.VARCHAR(50), 'col_center': types.VARCHAR(50),
                             'col_name': types.VARCHAR(50), 'col_issue_name': types.VARCHAR(50),
                             'col_model': types.VARCHAR(50), 'col_treatment': types.VARCHAR(50),
                             'source': types.VARCHAR(50), 'filename': types.VARCHAR(100), 'created_at': types.TIMESTAMP})
        except Exception as e:
            print(f"Une erreur s'est produite : {e}")

        return None

if __name__ == '__main__':
    # create a new instance of the business operation
    bo = IrisSqlAlchmyEmbedded()
    # initialize the business operation
    bo.on_init()

    # create a new message
    msg = DFrameRequest(pd.DataFrame([
            {'id': 1, 'col_type': 'type1', 'col_center': 'center1', 'col_name': 'name1', 'col_issue_name': 'issue1',
             'col_model': 'model1', 'col_treatment': 'treatment1', 'source': 'source1', 'filename': 'file1',
             'created_at': '2021-10-01 00:00:00'},
            {'id': 2, 'col_type': 'type2', 'col_center': 'center2', 'col_name': 'name2', 'col_issue_name': 'issue2',
             'col_model': 'model2', 'col_treatment': 'treatment2', 'source': 'source2', 'filename': 'file2',
             'created_at': '2021-10-02 00:00:00'}
        ]))

    # send the message to the business operation
    bo.on_message(msg)
    print("Done")

Bonjour,

Pour compléter la réponse de Lorenzo, il y aussi les librairies suivantes :

• iris_tar
• iris_zip

Ou encore utiliser du code python comme car vous utilisez iris 2021.2+:

Class ZIP.demo Extends%RegisteredObject
{

ClassMethod Demo(pFileName As%String) As%Status
{
    // Read a zip file into a streamset zipStream = ##class(%Stream.FileBinary).%New()

    // Link the stream to the filedo zipStream.LinkToFile(pFileName)

    // Call the unzip methodset sc = ##class(ZIP.demo).UnzipStream(zipStream, "/tmp/unzip")

    Quit sc
}

ClassMethod UnzipStream(
	pZipStream As%Stream.GlobalBinary,
	pDestDir As%String) As%Status
{
    // Import python lib unzipset unzip = ##class(%SYS.Python).Import("zipfile")

    // Write the stream to a temporary fileset tZipStream = ##class(%Stream.FileBinary).%New()
    do tZipStream.LinkToFile("/tmp/zipfile.zip")
    do tZipStream.CopyFromAndSave(pZipStream)

    // Create a new zip objectset zip = unzip.ZipFile("/tmp/zipfile.zip")

    // Extract the zip filedo zip.extractall(pDestDir)

    // Close the zip filedo zip.close()

    Quit$$$OK
}

}

Bonjour,

Je pense que c'est possible, cependant je n'ai pas encore eu l'occasion de le faire.

L'idée est la suivante :

Creer votre modèle Django en utilisant les classes Python qui vont bien.

example :

class MyModel(models.Model):
    # … fields …
    
    class Meta:
        managed = False # No database creation or deletion operations 
        db_table = 'MyTable'

Note : il faut bien mettre managed = False pour éviter que Django ne crée la table.

Ou alors vous pouvez utiliser la commande django inspectdb pour générer le modèle Django à partir de votre base de données.

python3 manage.py inspectdb

ou encore

python3 manage.py inspectdb > app_name/models.py

Bonjour,

Les versions LTS d'iris sont les versions en XXXX.1.

Nous appelons ces versions des Extended Maintenance (EM)

Les versions qui ne finissent pas par un 1 sont des Continus Delivery

Plus d'information sur ce post :

https://community.intersystems.com/post/updates-our-release-cadence

Ici pour suivre toutes les versions publiées ainsi que les releases notes:

https://docs.intersystems.com/iris.html

Bonjour @Moussa SAMB

Je viens de creer un projet example qui permet de se connecter à un server mail type imap en oauth2 :

https://github.com/grongierisc/iris-imap-python-adaptor

Si ca t'intéresse, je peux te le présenter en détail et l'améliorer pour qu'il corresponde à tes besoins.

Bonjour,

Effectivement, le service EnsLib.SQL.Service.GenericService est un service de type "Business Service" qui va générer un message pour chaque ligne de résultat de la requête SQL. Ce service est donc adapté pour des requêtes qui retournent un nombre limité de lignes.

Je pense que tu vas devoir passer par du code custom.

Voici un exemple en Python qui est relativement simple à mettre en oeuvre.

Le bs :

from grongier.pex import BusinessService
import pandas as pd
from sqlalchemy import create_engine


from .msg import SQLMessage

class SQLService(BusinessService):

    def __init__(self, **kwargs):
        self.sql = None
        self.conn = None
        self.target = None

    def on_init(self):
        if not hasattr(self, 'sql'):
            raise Exception('Missing sql attribute')
        if not hasattr(self, 'conn'):
            raise Exception('Missing conn attribute')
        if not hasattr(self, 'target'):
            raise Exception('Missing target attribute')
        
        self.engine = create_engine(self.conn)

        # raise an error if cannot connect to the database
        self.engine.connect()

    def get_adapter_type():
        """
        Name of the registred Adapter
        """
        return "Ens.InboundAdapter"
    
    def on_process_input(self, message_input):
        # create a dataframe from the sql query
        df = pd.read_sql(self.sql, self.engine)
        # create a message
        message = SQLMessage(dataframe=df)
        # send the message to the target
        self.send_request_sync(self.target, message)
        return

Ici on utilise la force de pandas pour créer un dataframe à partir du résultat de la requête SQL. On crée ensuite un message qui contient le dataframe et on l'envoie au target.

La configuration est faite à partir de propriétés suivantes :

• sql : la requête SQL
• conn : la connexion à la base de données
• target : le target

Le message :

from grongier.pex import Message
from dataclasses import dataclass
from pandas.core.frame import DataFrame

@dataclass
class SQLMessage(Message):
    dataframe: DataFrame = None

Le message qui contient le dataframe.

La target qui permet de créer le fichier csv :

from grongier.pex import BusinessOperation
from .msg import SQLMessage

import pandas as pd

class CSVOperation(BusinessOperation):

    def __init__(self, **kwargs):
        self.filename = None

    def on_init(self):
        if not hasattr(self, 'filename'):
            raise Exception('Missing filename attribute')
        
    def on_sql_message(self, message_input: SQLMessage):
        # get the dataframe from the message
        df = message_input.dataframe
        # create a csv file
        df.to_csv(self.filename, index=False)
        return

La configuration est faite à partir du fichier settings.py :

from sqltocsv import bo,bs
import os

CLASSES = {
    'Python.Bs.SQLService': bs.SQLService,
    'Python.Bo.CSVOperation': bo.CSVOperation
}

db_user = os.environ.get('POSTGRES_USER', 'DemoData')
db_password = os.environ.get('POSTGRES_PASSWORD', 'DemoData')
db_host = os.environ.get('POSTGRES_HOST', 'db')
db_port = os.environ.get('POSTGRES_PORT', '5432')
db_name = os.environ.get('POSTGRES_DB', 'DemoData')

PRODUCTIONS = [{
    "Python.Production": {
        "@Name": "Python.Production",
        "@LogGeneralTraceEvents": "false",
        "Description": "",
        "ActorPoolSize": "2",
        "Item": [
            {
                "@Name": "Python.Bs.SQLService",
                "@Category": "",
                "@ClassName": "Python.Bs.SQLService",
                "@PoolSize": "1",
                "@Enabled": "true",
                "@Foreground": "false",
                "@Comment": "",
                "@LogTraceEvents": "false",
                "@Schedule": "",
                "Setting": {
                    "@Target": "Host",
                    "@Name": "%settings",
                    "#text": "sql=select * from formation\nconn=postgresql://"+db_user+":"+db_password+"@"+db_host+":"+db_port+"/"+db_name+"\ntarget=Python.Bo.CSVOperation"
                }
            },
            {
                "@Name": "Python.Bo.CSVOperation",
                "@Category": "",
                "@ClassName": "Python.Bo.CSVOperation",
                "@PoolSize": "1",
                "@Enabled": "true",
                "@Foreground": "false",
                "@Comment": "",
                "@LogTraceEvents": "false",
                "@Schedule": "",
                "Setting": {
                    "@Target": "Host",
                    "@Name": "%settings",
                    "#text": "filename=/tmp/export.csv"
                }
            }
        ]
    }
}]

On utilise les variables d'environnement pour la connexion à la base de données.

Tu as l'exemple complet ici :

https://github.com/grongierisc/formation-template-python/tree/demo_sqltodb

Je laisse un autre membre de la communauté répondre avec une solution en ObjectScript.