sqlalchemy-iris 0.5.0b3__py3-none-any.whl → 0.6.0b1__py3-none-any.whl

intersystems_iris/pex/_BusinessService.py

@@ -0,0 +1,95 @@
+import intersystems_iris
+from intersystems_iris.pex._BusinessHost import _BusinessHost
+
+class _BusinessService(_BusinessHost):
+    """ This class is responsible for receiving the data from external system and sending it to business processes or business operations in the production.
+    The business service can use an adapter to access the external system, which is specified in the InboundAdapter property. 
+    There are three ways of implementing a business service:
+    1) Polling business service with an adapter - The production framework at regular intervals calls the adapter’s OnTask() method, 
+        which sends the incoming data to the the business service ProcessInput() method, which, in turn calls the OnProcessInput method with your code.
+    2) Polling business service that uses the default adapter - In this case, the framework calls the default adapter's OnTask method with no data. 
+        The OnProcessInput() method then performs the role of the adapter and is responsible for accessing the external system and receiving the data.
+    3) Nonpolling business service - The production framework does not initiate the business service. Instead custom code in either a long-running process 
+        or one that is started at regular intervals initiates the business service by calling the Director.CreateBusinessService() method.
+    """
+
+    def __init__(self):
+        """ The Adapter instance variable provides access to the inbound adapter associated with the business service."""
+        super().__init__()
+        self.Adapter = None
+        self._WaitForNextCallInterval = False
+    
+    def OnConnected(self):
+        """ The OnConnected() method is called when the component is connected or reconnected after being disconnected.
+        Use the OnConnected() method to initialize any structures needed by the component."""
+        pass
+
+    def OnInit(self):
+        """ The OnInit() method is called when the component is started.
+        Use the OnInit() method to initialize any structures needed by the component."""
+        pass
+
+    def OnTearDown(self):
+        """ Called before the component is terminated. Use it to freee any structures."""
+        pass
+
+    def OnProcessInput(self, messageInput):
+        """ 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:
+        messageInput: 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. 
+        """
+        pass
+
+    @staticmethod
+    def getAdapterType():
+        """ The getAdapterType() method is called when registering the business service in order to instruct the business service on what inbound adapter to use.
+        The return value from this method should be the string name of the inbound adapter class.  This may be an ObjectScript class or a PEX adapter class (Use the registered proxy name).
+        Return the empty string for adapterless business services.
+        """
+        return ""
+
+    def _setIrisHandles(self, handleCurrent, handlePartner):
+        """ For internal use only. """
+        self.irisHandle = handleCurrent
+        self.Adapter = intersystems_iris.pex.IRISInboundAdapter()
+        self.Adapter.irisHandle = handlePartner
+        return
+
+    def SendRequestAsync(self, target, request, description=None):
+        """ Send the specified message to the target business process or business operation asynchronously.
+
+        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 an instance of IRISObject or of a subclass of Message.
+            If the target is a built-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.
+        description: an optional string parameter that sets a description property in the message header. The default is None.
+        """
+        if self._is_message_instance(request):
+            serialized = self._serialize(request)
+            self.irisHandle.invokeVoid("dispatchSendRequestAsync",target,serialized,description)
+        elif isinstance(request, intersystems_iris.IRISObject):
+            self.irisHandle.invokeVoid("dispatchSendRequestAsync",target,request,description)
+        else:
+            raise TypeError(type(request))
+        return
+
+    def _dispatchOnConnected(self, hostObject):
+        """ For internal use only. """
+        self.OnConnected()
+        return
+
+    def _dispatchOnInit(self, hostObject):
+        """ For internal use only. """
+        self.OnInit()
+        return
+
+    def _dispatchOnTearDown(self, hostObject):
+        """ For internal use only. """
+        self.OnTearDown()
+        return
+    

intersystems_iris/pex/_Common.py

@@ -0,0 +1,228 @@
+import traceback
+import sys
+import inspect
+import intersystems_iris
+
+class _Common():
+    """ This is a common superclass for all component types that defines common methods."""
+
+    INFO_URL: str
+    ICON_URL: str
+
+    def __init__(self):
+        self.irisHandle = None
+    
+    def _setIrisHandles(self, handleCurrent, handlePartner):
+        pass
+
+    @classmethod
+    def _is_message_instance(cls, object):
+        return cls._is_message_class(type(object))
+
+    @classmethod
+    def _is_message_class(cls, klass):
+        name = klass.__module__ + '.' + klass.__qualname__
+        if name == "iris.pex.Message": return True
+        for c in klass.__bases__:
+            if cls._is_message_class(c): return True
+        return False
+
+    @classmethod
+    def _getInfo(cls):
+        """ Get class information to display in the Informational Settings expando for Production config items of this Business Host or Adapter.
+        This method returns a list of Superclass, Description, InfoURL, and IconURL, and possibly Adapter (if class is a Business Service or Business Operation)
+        IconURL is not yet displayed anywhere
+        """
+        ret = intersystems_iris.IRISList()
+        desc = ""
+        infoURL = ""
+        iconURL = ""
+        superClass = ""
+        adapter = ""
+        try:
+            # Get tuple of the class's base classes and loop through them until we find one of the PEX component classes
+            classes = inspect.getmro(cls)
+            for cl in classes:
+                clName = str(cl)[7:-1]
+                if clName in ["'iris.pex.BusinessService'","'iris.pex.BusinessOperation'"] :
+                    # Remove the apostrophes and set as superClass, then find if it uses an adapter
+                    superClass = clName[1:-1]
+                    adapter = cls.getAdapterType()
+                    break
+                elif clName in ["'iris.pex.BusinessProcess'","'iris.pex.InboundAdapter'","'iris.pex.OutboundAdapter'"] :
+                    # Remove the apostrophes and set as superClass
+                    superClass = clName[1:-1]
+                    break
+
+            if ""==superClass:
+                return ""
+            ret.add(superClass)
+
+            # Get the class documentation, if any
+            clsDesc = inspect.getdoc(cls)
+            superDesc = inspect.getdoc(classes[1])
+            if clsDesc!=superDesc:
+                desc = clsDesc
+            ret.add(str(desc))
+
+            infoURL = inspect.getattr_static(cls,"INFO_URL","")
+            iconURL = inspect.getattr_static(cls,"ICON_URL","")
+
+            ret.add(infoURL)
+            ret.add(iconURL)
+            
+            if ""!=adapter:
+                ret.add(adapter)
+        except:
+            pass
+        return ret
+
+    @classmethod
+    def _getProperties(cls):
+        """ Get a list of the Attributes and Properties of this Python class.
+        Return value is a list of lists of form $lb(propName,dataType,defaultVal,required,category,description).
+        which can be used by the Production Configuration to display them as settings.
+        This list will only include class attributes (no instance attributes) and properties which are not marked to be private by use of the _ prefix.
+        For class attributes, we will use the value that it is defined with as the defaultVal and its type as the dataType, or "" and String if set to None.
+        Add a function attrName_info() for a attribute or property 'attrName' in order to add more information about that attribute by using the function annotation for the return value.
+        The annotation should be a dictionary including any of 'IsRequired', 'Category', 'Description', 'DataType', or 'ExcludeFromSettings' as keys.
+        'ExcludeFromSettings' should be a boolean, and if true will exclude an attribute from being returned in the list, and so prevent it from being displayed as a setting in the Production Configuration Page
+        'DataType' does not need to be specified if it is the same as the type of the attribute definition.  Otherwise, it can be either a Python type or a string.
+        If 'IsRequired' is not specified, this will default to false.
+        If 'Category' is not specified, the attribute will be added to the Additional category.
+        """
+        ret = intersystems_iris.IRISList()
+        try:
+            # getmembers() returns all the members of an object
+            for member in inspect.getmembers(cls):
+                # remove private and protected functions
+                if not member[0].startswith('_'):
+                    # remove other methods and functions
+                    if not inspect.ismethod(member[1]) and not inspect.isfunction(member[1]) and not inspect.isclass(member[1]):
+                        if member[0] not in ('INFO_URL','ICON_URL','PERSISTENT_PROPERTY_LIST') :
+                            name = member[0]
+                            req = 0
+                            cat = "Additional"
+                            desc = ""
+                            # get value, set to "" if None or a @property
+                            val = member[1]
+                            if isinstance(val,property) or (val is None):
+                                val = ""
+                            dt = str(type(val))[8:-2]
+                            # get datatype from attribute definition, default to String
+                            dataType = {'int':'Integer','float':'Numeric','complex':'Numeric','bool':'Boolean'}.get(dt,'String')
+                            # if the user has created a attr_info function, then check the annotation on the return from that for more information about this attribute
+                            if hasattr(cls,name + '_info') :
+                                func = getattr(cls,name+'_info')
+                                if callable(func) :
+                                    annotations = func.__annotations__['return']
+                                    if annotations is not None:
+                                        if bool(annotations.get("ExcludeFromSettings")) :
+                                            # don't add this attribute to the settings list
+                                            continue
+                                        req = bool(annotations.get("IsRequired"))
+                                        cat = annotations.get("Category","Additional")
+                                        desc = annotations.get("Description")
+                                        dt = annotations.get("DataType")
+                                        # only override DataType found 
+                                        if (dt is not None) and ("" != dt):
+                                            dataType = {int:'Integer',float:'Number',complex:'Number',bool:'Boolean',str:'String'}.get(dt,str(dt))
+                                    default = func()
+                                    if default is not None:
+                                        val = default
+                            # create list of information for this specific property
+                            info = intersystems_iris.IRISList()
+                            info.add(name)    # Name        
+                            info.add(dataType) # DataType
+                            info.add(val)  # Default Value
+                            info.add(req) # Required
+                            info.add(cat) # Category
+                            info.add(desc) # Description
+                            # add this property to the list
+                            ret.add(info)
+        except:
+            pass
+        return ret
+
+    def LOGINFO(self, message):
+        """ Write a log entry of type "info". :og entries can be viewed in the management portal.
+        
+        Parameters:
+        message: a string that is written to the log.
+        """
+
+        currentClass = self.__class__.__name__
+        currentMethod = None
+        try:
+            frame = traceback.extract_stack()[-2]
+            currentMethod = frame.name
+        except:
+            pass
+        self.irisHandle._iris.classMethodVoid("Ens.Util.Log", "LogInfo", currentClass, currentMethod, message)
+        return
+
+    def LOGALERT(self, message):
+        """ Write a log entry of type "alert". :og entries can be viewed in the management portal.
+        
+        Parameters:
+        message: a string that is written to the log.
+        """
+        currentClass = self.__class__.__name__
+        currentMethod = None
+        try:
+            frame = traceback.extract_stack()[-2]
+            currentMethod = frame.name
+        except:
+            pass
+        self.irisHandle._iris.classMethodVoid("Ens.Util.Log", "LogAlert", currentClass, currentMethod, message)
+        return
+
+    def LOGWARNING(self, message):
+        """ Write a log entry of type "warning". Log entries can be viewed in the management portal.
+        
+        Parameters:
+        message: a string that is written to the log.
+        """
+        currentClass = self.__class__.__name__
+        currentMethod = None
+        try:
+            frame = traceback.extract_stack()[-2]
+            currentMethod = frame.name
+        except:
+            pass
+        self.irisHandle._iris.classMethodVoid("Ens.Util.Log", "LogWarning", currentClass, currentMethod, message)
+        return
+
+    def LOGERROR(self, message):
+        """ Write a log entry of type "error". :og entries can be viewed in the management portal.
+        
+        Parameters:
+        message: a string that is written to the log.
+        """
+        currentClass = self.__class__.__name__
+        currentMethod = None
+        try:
+            frame = traceback.extract_stack()[-2]
+            currentMethod = frame.name
+        except:
+            pass
+        self.irisHandle._iris.classMethodVoid("Ens.Util.Log", "LogError", currentClass, currentMethod, message)
+        return
+
+    def LOGASSERT(self, message):
+        """ Write a log entry of type "assert". :og entries can be viewed in the management portal.
+        
+        Parameters:
+        message: a string that is written to the log.
+        """
+        currentClass = self.__class__.__name__
+        currentMethod = None
+        try:
+            frame = traceback.extract_stack()[-2]
+            currentMethod = frame.name
+        except:
+            pass
+        self.irisHandle._iris.classMethodVoid("Ens.Util.Log", "LogAssert", currentClass, currentMethod, message)
+        return
+
+        

intersystems_iris/pex/_Director.py

@@ -0,0 +1,24 @@
+import intersystems_iris
+
+class _Director():
+    """ The Directorclass is used for nonpolling business services, that is, business services which are not automatically
+    called by the production framework (through the inbound adapter) at the call interval.
+    Instead these business services are created by a custom application by calling the Director.CreateBusinessService() method.
+    """
+
+    @staticmethod
+    def CreateBusinessService(connection, target):
+        """ The CreateBusinessService() method initiates the specifiied business service.
+
+        Parameters:
+        connection: an IRISConnection object that specifies the connection to an IRIS instance for Java.
+        target: a string that specifies the name of the business service in the production definition.
+
+        Returns:
+            an object that contains an instance of IRISBusinessService
+        """
+        irisInstance = intersystems_iris.IRIS(connection)
+        irisobject = irisInstance.classMethodObject("EnsLib.PEX.Director","dispatchCreateBusinessService",target)
+        service = intersystems_iris.pex._IRISBusinessService._IRISBusinessService()
+        service.irisHandle = irisobject
+        return service

intersystems_iris/pex/_IRISBusinessOperation.py

@@ -0,0 +1,5 @@
+class _IRISBusinessOperation:
+    """ Class for proxy objects that represent business operation instances in IRIS"""
+
+    def __init__(self):
+        self.irisHandle = None

intersystems_iris/pex/_IRISBusinessService.py

@@ -0,0 +1,18 @@
+class _IRISBusinessService:
+    """ Class for proxy objects that represent business service instances in IRIS"""
+
+    def __init__(self):
+        self.irisHandle = None
+
+    def ProcessInput(self, input):
+        """ Send an object to the business service instance.
+
+        Parameters:
+        input: an object to be sent to the business service.
+
+        Returns:
+        the object that is returned from the business service.
+        """
+        return (self.irisHandle._iris).classMethodObject("EnsLib.PEX.BusinessService", "dispatchProcessInput", self.irisHandle, input)
+
+        

intersystems_iris/pex/_IRISInboundAdapter.py

@@ -0,0 +1,5 @@
+class _IRISInboundAdapter:
+    """ Class for proxy objects that represent inbound adapter instances in IRIS."""
+    
+    def __init__(self):
+        self.irisHandle = None

intersystems_iris/pex/_IRISOutboundAdapter.py

@@ -0,0 +1,17 @@
+class _IRISOutboundAdapter:
+    """ Class for proxy objects that represent outbound adapter instances in IRIS."""
+
+    def __init__(self):
+        self.irisHandle = None
+    
+    def invoke(self, method, *args):
+        """ Invoke a method of the outbound adapter instance.
+
+        Parameters:
+        method: string, name of the method to be invoked.
+        args: arguments of the invocation.
+
+        Returns:
+        the return value of the invocation.
+        """
+        return self.irisHandle.invoke(method, *args)

intersystems_iris/pex/_InboundAdapter.py

@@ -0,0 +1,57 @@
+import intersystems_iris
+from intersystems_iris.pex._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.
+    """
+
+    def __init__(self):
+        """ The BusinessHost variable provides access to the business service associated with the inbound adapter.
+        The adapter calls the IRISBusinessService.ProcessInput() method of the business service.
+        """
+        super().__init__()
+        self.BusinessHost = None
+    
+    def OnConnected(self):
+        """ The OnConnected() method is called when the component is connected or reconnected after being disconnected.
+        Use the OnConnected() method to initialize any structures needed by the component."""
+        pass
+
+    def OnInit(self):
+        """ The OnInit() method is called when the component is started.
+        Use the OnInit() method to initialize any structures needed by the component."""
+        pass
+
+    def OnTearDown(self):
+        """ Called before the component is terminated. Use it to freee any structures."""
+        pass
+
+    def OnTask(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.
+        """
+        pass
+
+    def _setIrisHandles(self, handleCurrent, handlePartner):
+        """ For internal use only. """
+        self.irisHandle = handleCurrent
+        self.BusinessHost = intersystems_iris.pex.IRISBusinessService()
+        self.BusinessHost.irisHandle = handlePartner
+        return
+
+    def _dispatchOnConnected(self, hostObject):
+        """ For internal use only. """
+        self.OnConnected()
+        return
+
+    def _dispatchOnInit(self, hostObject):
+        """ For internal use only. """
+        self.OnInit()
+        return
+
+    def _dispatchOnTearDown(self, hostObject):
+        """ For internal use only. """
+        self.OnTearDown()
+        return

intersystems_iris/pex/_Message.py

@@ -0,0 +1,6 @@
+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 PEX framework provides the persistence to objects derived from the Message class.
+    """
+    pass

intersystems_iris/pex/_OutboundAdapter.py

@@ -0,0 +1,46 @@
+import intersystems_iris
+from intersystems_iris.pex._Common import _Common
+
+class _OutboundAdapter(_Common):
+    """ Responsible for sending the data to the external system."""
+
+    def __init__(self):
+        """ The BusinessHost variable provides access to the BusinessOperation associated with the OutboundAdapter."""
+        super().__init__()
+        self.BusinessHost = None
+    
+    def OnConnected(self):
+        """ The OnConnected() method is called when the component is connected or reconnected after being disconnected.
+        Use the OnConnected() method to initialize any structures needed by the component."""
+        pass
+
+    def OnInit(self):
+        """ The OnInit() method is called when the component is started.
+        Use the OnInit() method to initialize any structures needed by the component."""
+        pass
+
+    def OnTearDown(self):
+        """ Called before the component is terminated. Use it to freee any structures."""
+        pass
+
+    def _setIrisHandles(self, handleCurrent, handlePartner):
+        """ For internal use only. """
+        self.irisHandle = handleCurrent
+        self.BusinessHost = intersystems_iris.pex.IRISBusinessOperation()
+        self.BusinessHost.irisHandle = handlePartner
+        return
+
+    def _dispatchOnConnected(self, hostObject):
+        """ For internal use only. """
+        self.OnConnected()
+        return
+
+    def _dispatchOnInit(self, hostObject):
+        """ For internal use only. """
+        self.OnInit()
+        return
+
+    def _dispatchOnTearDown(self, hostObject):
+        """ For internal use only. """
+        self.OnTearDown()
+        return

intersystems_iris/pex/__init__.py

@@ -0,0 +1,25 @@
+from intersystems_iris.pex._Common import _Common
+from intersystems_iris.pex._BusinessHost import _BusinessHost
+from intersystems_iris.pex._BusinessService import _BusinessService
+from intersystems_iris.pex._BusinessProcess import _BusinessProcess
+from intersystems_iris.pex._BusinessOperation import _BusinessOperation
+from intersystems_iris.pex._InboundAdapter import _InboundAdapter
+from intersystems_iris.pex._OutboundAdapter import _OutboundAdapter
+from intersystems_iris.pex._IRISBusinessService import _IRISBusinessService
+from intersystems_iris.pex._IRISBusinessOperation import _IRISBusinessOperation
+from intersystems_iris.pex._IRISInboundAdapter import _IRISInboundAdapter
+from intersystems_iris.pex._IRISOutboundAdapter import _IRISOutboundAdapter
+from intersystems_iris.pex._Message import _Message
+from intersystems_iris.pex._Director import _Director
+
+class InboundAdapter(_InboundAdapter): pass
+class OutboundAdapter(_OutboundAdapter): pass
+class BusinessService(_BusinessService): pass
+class BusinessOperation(_BusinessOperation): pass
+class BusinessProcess(_BusinessProcess): pass
+class Message(_Message): pass
+class IRISInboundAdapter(_IRISInboundAdapter): pass
+class IRISOutboundAdapter(_IRISOutboundAdapter): pass
+class IRISBusinessService(_IRISBusinessService): pass
+class IRISBusinessOperation(_IRISBusinessOperation): pass
+class Director(_Director): pass

iris/__init__.py

@@ -0,0 +1,25 @@
+from sys import path as __syspath
+import os
+
+# check for install dir in environment
+# environment to check is IRISINSTALLDIR
+# if not found, raise exception and exit
+installdir = os.environ.get('IRISINSTALLDIR')
+if installdir is None:
+        raise Exception("""Cannot find InterSystems IRIS installation directory
+    Please set IRISINSTALLDIR environment variable to the InterSystems IRIS installation directory""")
+
+# join the install dir with the bin directory
+__syspath.append(os.path.join(installdir, 'bin'))
+# also append lib/python
+__syspath.append(os.path.join(installdir, 'lib', 'python'))
+
+from pythonint import *
+
+# TODO: Figure out how to hide __syspath and __ospath from anyone that
+#       imports iris.  Tried __all__ but that only applies to this:
+#           from iris import *
+
+#
+# End-of-file
+#

iris/iris_site.py

@@ -0,0 +1,13 @@
+import sys
+from os import sep as __os_sep
+from site import getsitepackages as __sitegetsitepackages
+
+#ubuntu needs dist-packages for pandas to be able to be imported
+#ubu 18 doesnt have os.sep in sys.executable
+def set_site_path(platform_name):
+   if "ubuntu" in platform_name:
+      if __os_sep in sys.executable:
+         __siteprefixes = [__os_sep + sys.executable.split(__os_sep)[1]]
+      else:
+         __siteprefixes = ['/usr']
+      sys.path = sys.path + __sitegetsitepackages(__siteprefixes)