Salut,

Peux-tu essayer cette commande :

python -m grongier.pex._cli

Je vais regarder en parallèle, le problème avec windows (pas facile, j'ai pas de VM windows à disposition :()

Si tu peux changer de namespace quand tu le souhaites pour ca deux facons :

• avant d'executer iop tu changes la variable d'environnement IRISNAMESPACE.

export IRISNAMESPACE=TEST
iop -m path/to/my_settings.py

• dans ton fichier my_settings.py tu peux changer le namespace avec la fonction suivante :

import iris
# switch namespace to the TEST namespace
iris.system.Process.SetNamespace("TEST")

# print the current namespace
print(iris.system.Process.NameSpace())

from TEST.bo import MyBo

CLASSES = {
    "MyIRIS.MyBo": MyBo
}

PRODUCTIONS = [
    {
        "MyIRIS.Production": {
            "@TestingEnable": "true",
            "@Name": "MyIRIS.Production",
            "Item": [
                {
                    "@Name": "Instance.Of.MyBo",
                    "@ClassName": "MyIRIS.MyBo",
                }
            ]
        }
    }
]

humm, ne pas confondre la PWG (Private WebGateway) et la WebGateway.

La private webgateway est un mini apache qui est embarqué dans iris.
Il n'a pas a etre configuré.

De plus, dans la configue pour acceder à ce portail il ne faut pas oublier d'ajouter ton ip en white list

System_Manager=*.*.*.*

Pourquoi souhaites-tu le configurer ?

Salut,

il manque un d à @TestingEnable

@TestingEnable != @TestingEnabled

Super :

Pour information, les métrics interop ne sont pas activés par default.

Pour les activer :

do ##class(Ens.Util.Statistics).EnableSAMForNamespace()

Plus d'information ici sur la doc

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.

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,

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,

Pour se connecter à IRIS, il est recommandé d'utiliser un login/password.
A ma connaissance, il n'y a pas de moyen de se connecter avec des certificats.

Pour se connecter avec un login/password dans le cas d'une connexion à IRIS en TCP, il est recommandé d'utiliser des variables d'environnement.

Example en python avec le module sqlachemy:

import os
from sqlalchemy import create_engine,text

engine = create_engine(
    "iris://",
    connect_args={
        "hostname": os.environ.get("IRIS_HOST", "localhost"),
        "port": os.environ.get("IRIS_PORT", 1972),
        "username": os.environ.get("IRIS_USERNAME", "SuperUser"),
        "password": os.environ.get("IRIS_PASSWORD", "SYS"),
        "namespace": os.environ.get("IRIS_DATABASE", "USER"),
    },
)

with engine.connect() as conn:
    result = conn.execute(text("SELECT 1"))
    print(result.fetchall())

Le cas d'embedded Python est un peu différent car la connexion ne se fait pas par TCP, la connexion se fait par "shared memory".

La connexion dans ce cas est définie par le service "%Service_CallIn" (pour information, les connexions TCP sont définies par le service "%Service_Bindings").

Regardons maintenant les possibilités de connexion offert par le service "%Service_CallIn".

• Unauthenticated
  • L'utilisateur par défault sera alors "UnknownUser"
• Operating System
  • Connexion avec l'utilisateur du système d'exploitation
  • Ce doit etre le même user que celui qui a lancé le processus IRIS
• Password
  • Connexion classique d'embedded Python avec les variables d'environnement suivantes:
  • IRISUSERNAME
  • IRISPASSWORD
  • IRISNAMESPACE
• Kerberos
  • Authentification Kerberos
• Kerberos Credentials Cache
  • Authentification Kerberos avec un cache de credentials

Dans votre cas, peut etre que Operating System est la meilleure solution. Kerberos est aussi une bonne solution mais il faut que votre environnement soit configuré pour.

Pour plus d'information, je vous invite à suivre la discution suivante :

https://fr.community.intersystems.com/post/acc%C3%A8s-au-terminal-iris-s...

Pour information :

Ce depot git fait exatement ce que vous chercher à faire.

Il implemente `djangorestframework` pour des tables pré-existante.

https://github.com/grongierisc/django-iris-template

Vous pouvez utiliser Django pour créer des API sur votre base de données.

Les options avec inspectdb ou la création manuelle de modèles sont possibles et ne dupliqueront pas votre base de données.

Elles sont là pour creer un mapping entre votre base de données et des objets Python (les modèles Django).
Vous etes donc dans un contexte "MVC" (en fait MTV pour Model Template View si vous utilisez Django en tant que framework web).

Si vous utilisez uniquement Django pour créer des API, vous n'avez pas besoin de templates et de vues, mais vous pouvez utiliser les modèles Django pour créer des objets Python qui représentent vos tables de base de données et donc utiliser les capacités d'ORM (Object Relational Mapping) de Django pour manipuler vos données.