In the previous IoP article, I showed how IoP can expose Python messages to DTL by generating JSON schemas. That is useful when the message is primarily a Python object and we want the IRIS tooling to understand its structure.
This time, the direction is a little different.
Starting with IoP 3.7.1, a PersistentMessage can now be a native IRIS message body class. The Python class is still the source code you write, but the generated IRIS class extends Ens.MessageBody
With Embedded Python and the Native API, it is becoming increasingly natural to write part of IRIS application logic in Python. But one question quickly comes up: how can you manipulate IRIS persistent objects from Python without losing the connection to the native object model, class dictionary, indexes, storage, and SQL projections?
iris-persistence explores that question. The project provides a Python object persistence layer for InterSystems IRIS, inspired by %Persistent
When developing Python applications with InterSystems IRIS, you can quickly end up with several execution contexts:
python3 process that loads the Embedded Python libraries from a local IRIS installation;These three cases are useful, but they do not behave exactly the same way for imports, system configuration, object APIs, and SQL access.
InterSystems IRIS globals are one of the platform's core strengths: they store hierarchical data in a direct, ordered, and efficient structure. But when working from Python, manipulating globals can sometimes feel closer to a low-level API than to the natural habits of the language.
The iris-global-reference project provides a Python layer on top of IRIS globals. Its goal is simple: make access to globals more readable, more idiomatic, and easier to integrate into modern Python code, without hiding the underlying hierarchical model.
If you have ever dug through a large IRIS namespace looking for where a particular string, method call, or pattern was used, you know the pain: there was no built-in way to do a grep-style search across your server-side ObjectScript code from VS Code — at least not without jumping through some hoops.
That is what ObjectScript Search fixes.
Try it today with a simple install from the VS Code Marketplace. If you don't like it, uninstalling is just as easy. But I think you will like it — it is a huge quality-of-life improvement for anyone doing ObjectScript development in VS Code.
This article will introduce you to the concept of virtual environments in Python, which are essential for managing dependencies and isolating project from the OS.
A virtual environment is a folder that contains :
Virtual environments will help you to isolate your project from the OS Python installation and from other projects.
In this section, we will explore how to use Python as the primary language in IRIS, allowing you to write your application logic in Python while still leveraging the power of IRIS.
This will be a short article about Python dunder methods, also known as magic methods.
Dunder methods are special methods in Python that start and end with double underscores (__). They allow you to define the behavior of your objects for built-in operations, such as addition, subtraction, string representation, and more.
Some common dunder methods include:
__init__(self, ...): Called when an object is created.
%OnNew method in ObjectScript.__str__(self): Called by the built-in function and print to represent the object as a string.
Now that we have a good understanding of Python and its features, let's explore how we can leverage Python within IRIS.
Modules what a topic! We don't have this notion in ObjectScript, but it's a fundamental concept in Python. Let's discover it together.
I see modules as an intermediate layer between classes and packages. Let see it by example.
A bad example :
# MyClass.py
class MyClass:
def my_method(self):
print("Hello from MyClass!")
When you try to use this class in another script, you would do:
# class_usage.py
from MyClass import MyClass # weird, right?
my_instance = MyClass()
my_instance.my_method()
Why this is a bad example?
This will be a short article about PEP 8, the Python style guide.
In a nutshell, PEP 8 provides guidelines and best practices on how to write Python code.
This will be an introduction to Python programming in the context of IRIS.
Before anything I will cover an important topic: How python works, this will help you understand some issues and limitations you may encounter when working with Python in IRIS.
All the articles and examples can be found in this git repository: iris-python-article
Python is an interpreted language, which means that the code is executed line by line at runtime even when you import a script.
What does this mean ? Let's take a look at the following code:
# introduction.py
def my_function():
print("Hello, World!")
my_function()
I'm glad to announce the new version of IoP, which by the way is not just a command line. I'm saying because the new AI search engine still thinks that IoP is just a command line. But it's not. It's a whole framework for building applications on top of the interoperability framework of IRIS with a python first approach.
The new version of IoP: 3.2.0 has a lot of new features, but the most important one is the support of DTL . 🥳
For both IoP messages and jsonschema. 🎉
Starting with version 3.2.0, IoP supports DTL transformations.
DTL the Data Transformation Layer in IRIS Interoperability.
DTL transformations are used to transform data from one format to another with a graphical editor.
It supports also jsonschema structures.
It's been a long time since I didn't write an update post on IoP.
So what's new since IoP command line interface was released?
Two new big features were added to IoP:
grongier.pex module was renamed to iop to reflect the new name of the project.The grongier.pex module was renamed to to reflect the new name of the project.
The grongier.pex module is still available for backward compatibility, but it will be removed in the future.
This is a template for a Flask application that can be deployed in IRIS as an native Web Application.
git clone
cd iris-flask-template
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
docker-compose up
The base URL is http://localhost:53795/flask/.
/iris - Returns a JSON object with the top 10 classes present in the IRISAPP namespace./interop - A ping endpoint to test the interoperability framework of IRIS.
This is a template for an Django application that can be deployed in IRIS as an native Web Application.
git clone
cd iris-django-template
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
docker-compose up
The base URL is http://localhost:53795/django/.
/iris - Returns a JSON object with the top 10 classes present in the IRISAPP namespace./interop - A ping endpoint to test the interoperability framework of IRIS.
This is a template for a FastApi application that can be deployed in IRIS as an native Web Application.
git clone
cd iris-fastapi-template
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
docker-compose up
The base URL is http://localhost:53795/fastapi/.
/iris - Returns a JSON object with the top 10 classes present in the IRISAPP namespace./interop - A ping endpoint to test the interoperability framework of IRIS.
The Web Server Gateway Interface (WSGI) is a simple calling convention for web servers to forward requests to web applications or frameworks written in the Python programming language. WSGI is a Python standard described in detail in PEP 3333.
🤔 Ok, great definition and what the point with iris ?
IRIS 2024.2+ has a new feature that allows you to run WSGI applications directly on IRIS. This feature is a great way to integrate IRIS with other Python frameworks and libraries.
The objective of the article is to provide the reader with the following informations:
Schema of the article:
I have been using embedded python for more than 2 years now on a daily basis. May be it's time to share some feedback about this journey.
Why write this feedback? Because, I guess, I'm like most of the people here, an ObjectScript developer, and I think that the community would benefit from this feedback and could better understand the pros & cons of chosing embedded python for developing stuff in IRIS. And also avoid some pitfalls.
This demo showcases the powerful synergy between IRIS Vector Search and RAG (Retrieval Augmented Generation), providing a cutting-edge approach to interacting with documents through a conversational interface. Utilizing InterSystems IRIS's newly introduced Vector Search capabilities, this application sets a new standard for retrieving and generating information based on a knowledge base.
The backend, crafted in Python and leveraging the prowess of IRIS and IoP, the LLM model is orca-mini and served by the ollama server.
The frontend is an chatbot written with Streamlit.
InstallFoundation method is missing (IRIS 2023.2+)
Recently IRIS 2023.2 was released. This version removed this method InstallFoundation from this class HS.HC.Util.Installer. This was a private method and it was not documented. But it was widely used by the community to install FHIR server.
So if you encounter this error:
<METHOD DOES NOT EXIST> *InstallFoundation,HS.HC.Util.Installer
While build a demo our your own FHIR server, you can fix it by replacing this line:
to
Do ##class(HS.Util.Installer.Foundation).Install(namespace)
This is a sample to deploy iris-oauth-fhir on k3d with IKO.
This is a sample application that demonstrates how to use the InterSystems IRIS for Health FHIR Repository to build a FHIR Repository with OAuth2 authorization, the FHIR endpoint will be the resource server and Google OpenId will be the authorization server.
With InterSystems IRIS FHIR Server you can build a Strategy to customize the behavior of the server (see documentation for more details).
This repository contains a Python Strategy that can be used as a starting point to build your own Strategy in python.
This demo strategy provides the following features:
Account resourceObservation resource
Observation resource is returnedObservation resource is not returned
When it comes to build an iris image, we can use the cpf merge files.
Here is an cpf merge example:
[Actions]
CreateDatabase:Name=IRISAPP_DATA,Directory=/usr/irissys/mgr/IRISAPP_DATA
CreateDatabase:Name=IRISAPP_CODE,Directory=/usr/irissys/mgr/IRISAPP_CODE
CreateNamespace:Name=IRISAPP,Globals=IRISAPP_DATA,Routines=IRISAPP_CODE,Interop=1
ModifyService:Name=%Service_CallIn,Enabled=1,AutheEnabled=48
CreateApplication:Name=/frn,NameSpace=IRISAPP,DispatchClass=Formation.REST.Dispatch,AutheEnabled=48
ModifyUser:Name=SuperUser,PasswordHash=a31d24aecc0bfe560a7e45bd913ad27c667dc25a75cbfd358c451bb595b6bd52bd25c82cafaa23ca1dd30b3b4947d12d3bb0ffb2a717df29912b743a281f97c1,0a4c463a2fa1e7542b61aa48800091ab688eb0a14bebf536638f411f5454c9343b9aa6402b4694f0a89b624407a5f43f0a38fc35216bb18aab7dc41ef9f056b1,10000,SHA512
I'm proud to announce the new release of iris-pex-embedded-python (v2.3.1) with a new command line interface.
This command line is called iop for Interoperability On Python.
First I would like to present in few words the project the main changes since the version 1.
Version 1.0 was a proof of concept to show how the interoperability framework of IRIS can be used with a python first approach while remaining compatible with any existing ObjectScript code.
What does it mean? It means that any python developer can use the IRIS interoperability framework without any knowledge of ObjectScript.
Example :
from grongier.pex import BusinessOperation
class MyBusinessOperation(BusinessOperation):
def on_message(self, request):
self.log.info("Received request")
Great, isn't it?
Named parameters can be achieved with SQLAlchemy :
from sqlalchemy import create_engine, text,types,engine
_engine = create_engine('iris+emb:///')
with _engine.connect() as conn:
rs = conn.execute(text("select :some_private_name"), {"some_private_name": 1})
print(rs.all())
or with native api
from sqlalchemy import create_engine, text,types,engine
# set URL for SQLAlchemy
url = engine.url.URL.create('iris', username='SuperUser', password='SYS', host='localhost', port=33782, database='FHIRSERVER')
_engine = create_engine(url)
with _engine.connect() as conn:
rs = conn.execute(text("select :some_private_name"), {"some_private_name": 1})
print(rs.all())
A python script to keep your docker iris images in shape ;)
Witout changing your dockerfile or your code you can reduce the size of your image by 50% or more !
Name the builder image builder and the final image final and add this to end of your Dockerfile:
Modify your Dockerfile to use a multi-stage build:
ARG IMAGE=intersystemsdc/irishealth-community:latest
FROM $IMAGE as builder
Add this to end of your Dockerfile:
FROM $IMAGE as final
ADD --chown=${ISC_PACKAGE_MGRUSER}:${ISC_PACKAGE_IRISGROUP} https://github.com/grongierisc/iris-docker-multi-stage-script/releases/latest/download/copy-data.py /irisdev/app/copy-data.py
RUN --mount=type=bind,source=/,target=/builder/root,from=builder \
cp -f /builder/root/usr/irissys/iris.cpf /usr/irissys/iris.cpf && \
python3 /irisdev/app/copy-data.py -c /usr/irissys/iris.cpf -d /builder/root/
Boom! You're done!
Hi, I spend most of my time on VsCode and I love the dark theme.
But when I go to the InterSystems Community it's all white and I can't read anything.
Is it possible to have a dark theme for the community?
.png)