iris-pex-embedded-python 3.5.5b4__py3-none-any.whl

iop/_generator_request.py

@@ -0,0 +1,30 @@
+from typing import Any, Optional, Union
+
+from . import _iris
+from ._dispatch import dispatch_serializer
+
+class _GeneratorRequest:
+    """Generator class to interetate over responses from a request.
+    This class is used to handle the responses from a request in a generator-like manner."""
+
+    def __init__(self, host: Any, target: str, request: Any, 
+                 timeout: int = -1, description: Optional[str] = None) -> None:
+        self.host = host
+        self.target = target
+        self.request = request
+
+        ack_response = self.host.send_request_sync(self.target, dispatch_serializer(self.request, is_generator=True),
+                                                  timeout=timeout, description=description)
+        
+        if ack_response is None or not ack_response._IsA("IOP.Generator.Message.Ack"):
+            raise RuntimeError("Failed to send request, no acknowledgment received.")
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        poll = _iris.get_iris().IOP.Generator.Message.Poll._New()
+        rsp = self.host.send_request_sync(self.target, poll)
+        if rsp is None or (hasattr(rsp, '_IsA') and rsp._IsA("IOP.Generator.Message.Stop")):
+            raise StopIteration("No more responses available.")
+        return rsp

iop/_inbound_adapter.py

@@ -0,0 +1,34 @@
+from ._common import _Common
+
+class _InboundAdapter(_Common):
+    """ Responsible for receiving the data from the external system, validating the data, 
+    and sending it to the business service by calling the BusinessHost.ProcessInput() method.
+    """
+    BusinessHost = business_host = business_host_python = None
+
+    def on_task(self): 
+        """ Called by the production framework at intervals determined by the business service CallInterval property.
+        It is responsible for receiving the data from the external system, validating the data, and sending it in a message to the business service OnProcessInput method.
+        The message can have any structure agreed upon by the inbound adapter and the business service.
+        """
+        return self.OnTask()
+
+    def _set_iris_handles(self, handle_current, handle_partner):
+        """ For internal use only. """
+        self.iris_handle = handle_current
+        self.BusinessHost = handle_partner
+        self.business_host = handle_partner
+        try:
+            self.business_host_python = handle_partner.GetClass()
+        except:
+            pass
+        return
+
+
+    def OnTask(self):
+        """  DEPRECATED : use on_task
+        Called by the production framework at intervals determined by the business service CallInterval property.
+        It is responsible for receiving the data from the external system, validating the data, and sending it in a message to the business service OnProcessInput method.
+        The message can have any structure agreed upon by the inbound adapter and the business service.
+        """
+        return 

iop/_iris.py

@@ -0,0 +1,8 @@
+import os
+from typing import Optional
+
+def get_iris(namespace: Optional[str]=None)->'iris': # type: ignore
+    if namespace:
+        os.environ['IRISNAMESPACE'] = namespace
+    import iris
+    return iris

iop/_log_manager.py

@@ -0,0 +1,100 @@
+import logging
+
+from . import _iris
+
+class LogManager:
+    """Manages logging integration between Python's logging module and IRIS."""
+
+    @staticmethod
+    def get_logger(class_name: str, to_console: bool = False) -> logging.Logger:
+        """Get a logger instance configured for IRIS integration.
+        
+        Args:
+            class_name: Name of the class logging the message
+            method_name: Optional name of the method logging the message
+            to_console: If True, log to the console instead of IRIS
+            
+        Returns:
+            Logger instance configured for IRIS integration
+        """
+        logger = logging.Logger(f"{class_name}")
+        
+        # Only add handler if none exists
+        if not logger.handlers:
+            handler = IRISLogHandler(to_console=to_console)
+            formatter = logging.Formatter('%(message)s')
+            handler.setFormatter(formatter)
+            logger.addHandler(handler)
+            # Set the log level to the lowest level to ensure all messages are sent to IRIS
+            logger.setLevel(logging.DEBUG)
+        
+        return logger
+
+class IRISLogHandler(logging.Handler):
+    """Custom logging handler that routes Python logs to IRIS logging system."""
+
+    def __init__(self, to_console: bool = False):
+        """Initialize the IRIS logging handler."""
+        super().__init__()
+        self.to_console = to_console
+
+        # Map Python logging levels to IRIS logging methods
+        self.level_map = {
+            logging.DEBUG: 5,
+            logging.INFO: 4,
+            logging.WARNING: 3,
+            logging.ERROR: 2,
+            logging.CRITICAL: 6,
+        }
+        # Map Python logging levels to IRIS logging Console level
+        self.level_map_console = {
+            logging.DEBUG: -1,
+            logging.INFO: 0,
+            logging.WARNING: 1,
+            logging.ERROR: 2,
+            logging.CRITICAL: 3,
+        }
+
+    def format(self, record: logging.LogRecord) -> str:
+        """Format the log record into a string.
+        
+        Args:
+            record: The logging record to format
+            
+        Returns:
+            Formatted log message
+        """
+        return record.getMessage()
+
+    def emit(self, record: logging.LogRecord) -> None:
+        """Route the log record to appropriate IRIS logging method.
+        
+        Args:
+            record: The logging record to emit
+        """
+        # Extract class and method names with fallbacks
+        class_name = getattr(record, "class_name", record.name)
+        method_name = getattr(record, "method_name", record.funcName)
+        
+        # Format message and get full method path
+        message = self.format(record)
+        method_path = f"{class_name}.{method_name}"
+        
+        # Determine if console logging should be used
+        use_console = self.to_console or getattr(record, "to_console", False)
+        
+        if use_console:
+            _iris.get_iris().cls("%SYS.System").WriteToConsoleLog(
+                message,
+                0,
+                self.level_map_console.get(record.levelno, 0),
+                method_path
+            )
+        else:
+            log_level = self.level_map.get(record.levelno, 4)
+            _iris.get_iris().cls("Ens.Util.Log").Log(
+                log_level,
+                class_name,
+                method_name,
+                message
+            )

iop/_message.py

@@ -0,0 +1,40 @@
+from typing import Any, Optional
+
+from pydantic import BaseModel
+
+class _Message:
+    """ The abstract class that is the superclass for persistent messages sent from one component to another.
+    This class has no properties or methods. Users subclass Message and add properties.
+    The IOP framework provides the persistence to objects derived from the Message class.
+    """
+    _iris_id: Optional[str] = None
+    
+    def get_iris_id(self) -> Optional[str]:
+        """Get the IRIS ID of the message."""
+        return self._iris_id
+
+class _PickleMessage(_Message):
+    """ The abstract class that is the superclass for persistent messages sent from one component to another.
+    This class has no properties or methods. Users subclass Message and add properties.
+    The IOP framework provides the persistence to objects derived from the Message class.
+    """
+    pass
+
+class _PydanticMessage(BaseModel):
+    """Base class for Pydantic-based messages that can be serialized to IRIS."""
+    
+    _iris_id: Optional[str] = None
+
+    def __init__(self, **data: Any):
+        super().__init__(**data)
+
+    def get_iris_id(self) -> Optional[str]:
+        """Get the IRIS ID of the message."""
+        return self._iris_id
+
+class _PydanticPickleMessage(_PydanticMessage):
+    """Base class for Pydantic-based messages that can be serialized to IRIS."""
+
+    def __init__(self, **data: Any):
+        super().__init__(**data)
+

iop/_message_validator.py

@@ -0,0 +1,49 @@
+import dataclasses
+from typing import Any, Type
+
+from ._message import _Message, _PickleMessage, _PydanticPickleMessage, BaseModel
+
+
+def is_message_instance(obj: Any) -> bool:
+    """Check if object is a valid Message instance."""
+    if isinstance(obj, BaseModel):
+        return True
+    if is_message_class(type(obj)):
+        if not dataclasses.is_dataclass(obj):
+            raise TypeError(f"{type(obj).__module__}.{type(obj).__qualname__} must be a dataclass")
+        return True
+    return False
+
+
+def is_pickle_message_instance(obj: Any) -> bool:
+    """Check if object is a PickleMessage instance."""
+    if isinstance(obj, _PydanticPickleMessage):
+        return True
+    if is_pickle_message_class(type(obj)):
+        return True
+    return False
+
+
+def is_iris_object_instance(obj: Any) -> bool:
+    """Check if object is an IRIS persistent object."""
+    return (obj is not None and 
+            type(obj).__module__.startswith('iris') and 
+            (obj._IsA("%Persistent") or obj._IsA("%Stream.Object"))) 
+            # Stream.Object are used for HTTP InboundAdapter/OutboundAdapter
+
+
+def is_message_class(klass: Type) -> bool:
+    """Check if class is a Message type."""
+    if issubclass(klass, _Message):
+        return True
+    return False
+
+
+
+def is_pickle_message_class(klass: Type) -> bool:
+    """Check if class is a PickleMessage type."""
+    if issubclass(klass, _PickleMessage):
+        return True
+    if issubclass(klass, _PydanticPickleMessage):
+        return True
+    return False

iop/_outbound_adapter.py

@@ -0,0 +1,23 @@
+from ._common import _Common
+
+class _OutboundAdapter(_Common):
+    """ Responsible for sending the data to the external system."""
+    BusinessHost = business_host = business_host_python = None
+
+    def on_keepalive(self):
+        """
+        > This function is called when the server sends a keepalive message
+        """
+        return
+
+    def _set_iris_handles(self, handle_current, handle_partner):
+        """ For internal use only. """
+        self.iris_handle = handle_current
+        self.BusinessHost = handle_partner
+        self.business_host = handle_partner
+        try:
+            self.business_host_python = handle_partner.GetClass()
+        except:
+            pass
+        return
+

iop/_private_session_duplex.py

@@ -0,0 +1,103 @@
+import importlib
+
+from ._business_host import _BusinessHost
+from ._decorators import input_deserializer, input_serializer_param, output_serializer, input_serializer, output_deserializer
+from ._dispatch import create_dispatch, dispach_message
+
+class _PrivateSessionDuplex(_BusinessHost):
+    
+    Adapter = adapter = None
+    _wait_for_next_call_interval = False
+    DISPATCH = []
+
+    def on_message(self, request):
+        """ Called when the business operation receives a message from another production component.
+        Typically, the operation will either send the message to the external system or forward it to a business process or another business operation.
+        If the operation has an adapter, it uses the Adapter.invoke() method to call the method on the adapter that sends the message to the external system.
+        If the operation is forwarding the message to another production component, it uses the SendRequestAsync() or the SendRequestSync() method
+
+        Parameters:
+        request: An instance of either a subclass of Message or of IRISObject containing the incoming message for the business operation.
+
+        Returns:
+        The response object
+        """
+        pass
+
+    @input_deserializer
+    @output_serializer
+    def _dispatch_on_message(self, request):
+        """ For internal use only. """
+        return dispach_message(self,request)
+
+    def _set_iris_handles(self, handle_current, handle_partner):
+        """ For internal use only. """
+        self.iris_handle = handle_current
+        if type(handle_partner).__module__.find('iris') == 0:
+            if (handle_partner._IsA("Grongier.PEX.InboundAdapter") or handle_partner._IsA("Grongier.PEX.OutboundAdapter")
+                or handle_partner._IsA("IOP.InboundAdapter") or handle_partner._IsA("IOP.OutboundAdapter")):
+                module = importlib.import_module(handle_partner.GetModule())
+                handle_partner = getattr(module, handle_partner.GetClassname())()
+        self.Adapter = self.adapter = handle_partner
+        return
+
+    @input_deserializer
+    @output_serializer
+    def _dispatch_on_process_input(self, request):
+        """ For internal use only. """
+        return self.on_process_input(request)
+
+    def on_process_input(self, message_input):
+        """ Receives the message from the inbond adapter via the PRocessInput method and is responsible for forwarding it to target business processes or operations.
+        If the business service does not specify an adapter, then the default adapter calls this method with no message 
+        and the business service is responsible for receiving the data from the external system and validating it.
+
+        Parameters:
+        message_input: an instance of IRISObject or subclass of Message containing the data that the inbound adapter passes in.
+            The message can have any structure agreed upon by the inbound adapter and the business service. 
+        """
+        return 
+
+    @input_serializer_param(0,'document')
+    @output_deserializer
+    def send_document_to_process(self, document):
+        """ Send the specified message to the target business process or business operation synchronously.
+            
+        Parameters:
+        target: a string that specifies the name of the business process or operation to receive the request. 
+            The target is the name of the component as specified in the Item Name property in the production definition, not the class name of the component.
+        request: specifies the message to send to the target. The request is either an instance of a class that is a subclass of Message class or of IRISObject class.
+            If the target is a build-in ObjectScript component, you should use the IRISObject class. The IRISObject class enables the PEX framework to convert the message to a class supported by the target.
+        timeout: an optional integer that specifies the number of seconds to wait before treating the send request as a failure. The default value is -1, which means wait forever.
+        description: an optional string parameter that sets a description property in the message header. The default is None.
+        Returns:
+            the response object from target.
+        Raises:
+        TypeError: if request is not of type Message or IRISObject.
+        """
+
+        return self.iris_handle.dispatchSendDocumentToProcess(document)
+
+    @input_deserializer
+    @output_serializer
+    def _dispatch_on_private_session_started(self, source_config_name,self_generated):
+        """ For internal use only. """
+
+        return_object = self.on_private_session_started(source_config_name,self_generated)
+
+        return return_object
+
+    def on_private_session_started(self,source_config_name,self_generated):
+        pass
+
+    @input_deserializer
+    @output_serializer
+    def _dispatch_on_private_session_stopped(self, source_config_name,self_generated,message):
+        """ For internal use only. """
+
+        return_object = self.on_private_session_stopped(source_config_name,self_generated,message)
+
+        return return_object
+
+    def on_private_session_stopped(self,source_config_name,self_generated,message):
+        pass

iop/_private_session_process.py

@@ -0,0 +1,41 @@
+from ._business_process import _BusinessProcess
+from ._decorators import input_deserializer, output_serializer, input_serializer, output_deserializer
+
+class _PrivateSessionProcess(_BusinessProcess):
+    
+    @input_deserializer
+    @output_serializer
+    def _dispatch_on_document(self, host_object,source_config_name, request):
+        """ For internal use only. """
+        self._restore_persistent_properties(host_object)
+        return_object = self.on_document(source_config_name,request)
+        self._save_persistent_properties(host_object)
+        return return_object
+
+    def on_document(self,source_config_name,request):
+        pass
+
+
+    @input_deserializer
+    @output_serializer
+    def _dispatch_on_private_session_started(self, host_object, source_config_name,self_generated):
+        """ For internal use only. """
+        self._restore_persistent_properties(host_object)
+        return_object = self.on_private_session_started(source_config_name,self_generated)
+        self._save_persistent_properties(host_object)
+        return return_object
+
+    def on_private_session_started(self,source_config_name,self_generated):
+        pass
+
+    @input_deserializer
+    @output_serializer
+    def _dispatch_on_private_session_stopped(self, host_object, source_config_name,self_generated,message):
+        """ For internal use only. """
+        self._restore_persistent_properties(host_object)
+        return_object = self.on_private_session_stopped(source_config_name,self_generated,message)
+        self._save_persistent_properties(host_object)
+        return return_object
+
+    def on_private_session_stopped(self,source_config_name,self_generated,message):
+        pass

iop/_remote.py

@@ -0,0 +1,91 @@
+# This module provides a REST API for remote I/O operations
+# It uses Flask to handle incoming requests and route them to the appropriate I/O functions
+# It should be able to help the migrate command of IoP Cli to work remotely:
+# this means copy all the .py files from the current directory of (settings.py) to the remote server
+# and run the api migrate from the remote server
+# the default folder is based on the NAMESPACE variable in settings.py
+from flask import Flask, request, jsonify
+
+@app.route('/remote_io', methods=['POST'])
+def remote_io():
+    data = request.json
+    if not data or 'operation' not in data:
+        return jsonify({'error': 'Invalid request'}), 400
+    
+    operation = data['operation']
+    # Here you would implement the logic to handle the operation
+    # For example, you could call a function that performs the I/O operation
+    # and return the result as JSON.
+    
+    # Placeholder response for demonstration purposes
+    response = {'status': 'success', 'operation': operation}
+    return jsonify(response), 200
+
+# ClassMethod UploadPackage(
+# 	namespace As %String,
+# 	body As %DynamicArray) As %DynamicObject
+# {
+#     // check for namespace existence and user permissions against namespace
+# 	If '..NamespaceCheck(namespace) {
+# 		Return ""
+# 	}
+# 	New $NAMESPACE
+# 	Set $NAMESPACE = namespace
+	
+# 	//Create directory for custom packages
+# 	Do ##class(%ZHSLIB.HealthShareMgr).GetDBNSInfo(namespace,.out)
+# 	Set customPackagesPath = ##class(%Library.File).NormalizeDirectory("fhir_packages", out.globalsDatabase.directory)
+# 	If '##class(%Library.File).DirectoryExists(customPackagesPath) {
+# 		If '##class(%Library.File).CreateDirectory(customPackagesPath) {
+# 			$$$ThrowStatus($$$ERROR($$$DirectoryCannotCreate, customPackagesPath))
+# 		}
+# 	}
+	
+# 	//Find package name
+# 	Set iterator =  body.%GetIterator()
+# 	Set packageName = ""
+# 	While iterator.%GetNext(, .fileObject ) {
+# 		If fileObject.name = "package.json" {
+# 			Set packageName = fileObject.data.name_"@"_fileObject.data.version
+# 		}	
+# 	}
+# 	If packageName = "" {
+# 		Do ..%ReportRESTError($$$HTTP400,$$$ERROR($$$HSFHIRErrPackageNotFound))
+# 		Return ""
+# 	}
+	
+# 	Set packagePath = ##class(%Library.File).NormalizeDirectory(packageName, customPackagesPath)
+# 	// If the package already exists then we must be meaning to re-load it. Delete files/directory/metadata and recreate fresh.
+# 	If ##class(%Library.File).DirectoryExists(packagePath) {
+# 		If '##class(%Library.File).RemoveDirectoryTree(packagePath) {
+# 			$$$ThrowStatus($$$ERROR($$$DirectoryPermission , packagePath))
+# 		}
+# 	}
+# 	If '##class(%Library.File).CreateDirectory(packagePath) {
+# 		$$$ThrowStatus($$$ERROR($$$DirectoryCannotCreate, customPackagesPath))
+# 	}
+# 	Set pkg = ##class(HS.FHIRMeta.Storage.Package).FindById(packageName)
+# 	If $ISOBJECT(pkg) {
+# 		// Will fail and throw if the package is in-use or has dependencies preventing it from being deleted.
+# 		Do ##class(HS.FHIRServer.ServiceAdmin).DeleteMetadataPackage(packageName)
+# 	}
+# 	Kill pkg
+
+# 	//Unpack JSON objects		
+# 	Set iterator = body.%GetIterator()
+# 	While iterator.%GetNext(.key , .fileObject ) {
+# 		Set fileName = ##class(%Library.File).NormalizeFilename(fileObject.name,packagePath)
+# 		Set fileStream = ##class(%Stream.FileCharacter).%New()
+# 		Set fileStream.TranslateTable = "UTF8"
+# 		$$$ThrowOnError(fileStream.LinkToFile(fileName))
+# 		Do fileObject.data.%ToJSON(.fileStream)
+# 		$$$ThrowOnError(fileStream.%Save())
+# 	}
+	
+# 	//Import package
+# 	Do ##class(HS.FHIRMeta.Load.NpmLoader).importPackages(packagePath)
+# 	Set pkg = ..GetOnePackage(packageName, namespace)
+# 	Do ..%SetStatusCode($$$HTTP201)
+# 	Do ..%SetHeader("location", %request.Application _ "packages/" _ packageName _ "?namespace=" _ namespace)
+# 	Return pkg
+# }