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

intersystems_iris/dbapi/preparser/_TokenList.py

@@ -0,0 +1,251 @@
+import abc
+import intersystems_iris.dbapi.preparser._Token
+
+class ITokenEnumerator(object):
+    __metaclass__ = abc.ABCMeta
+
+    @abc.abstractmethod
+    def Reset(self):
+        pass
+
+    @abc.abstractmethod
+    def Current(self):
+        pass
+
+    @abc.abstractmethod
+    def MoveNext(self):
+        pass
+
+    @abc.abstractmethod
+    def MovePrevious(self):
+        pass
+
+    @abc.abstractmethod
+    def Clone(self):
+        pass
+
+    @abc.abstractmethod
+    def Count(self):
+        pass
+
+class TokenListNode(object):
+    def __init__(self, Value, Owner):
+        if not isinstance(Value, intersystems_iris.dbapi.preparser._Token._Token):
+            raise TypeError("Value must be a _Token")
+        
+        self.m_Previous = None
+        self.m_Next = None
+        self.m_Value = Value
+
+    def GetValue(self):
+        return self.m_Value
+
+    def SetValue(self, value):
+        if not isinstance(value, intersystems_iris.dbapi.preparser._Token._Token):
+            raise TypeError("value must be a _Token")
+
+        self.m_Value = value
+
+    def Previous(self):
+        return self.m_Previous
+
+    def Next(self):
+        return self.m_Next
+
+    def SetPrevious(self, node):
+        if not isinstance(node, TokenListNode):
+            raise TypeError("node must be a TokenListNode")
+
+        self.m_Previous = node
+
+    def SetNext(self, node):
+        if not isinstance(node, TokenListNode):
+            raise TypeError("node must be a TokenListNode")
+
+        self.m_Next = node
+
+
+class _TokenList(object): 
+    def __init__(self):
+        self.m_Count = 0
+        self.m_Head = None
+        self.m_Tail = None
+
+    def Count(self):
+        return self.m_Count
+
+    def GetToken(self, index):
+        try:
+            index = int(index)
+        except (TypeError, ValueError):
+            raise ValueError("index must be an integer")
+
+        if index < 0 or index > (self.Count() - 1):
+            raise IndexError("Index " + index + " is out of range")
+            
+        node = self.First()
+        for i in range(index):
+            node = node.Next()
+        return node.GetValue()
+
+    def SetToken(self, index, value):
+        try:
+            index = int(index)
+        except (TypeError, ValueError):
+            raise ValueError("index must be an integer")
+
+        if index < 0 or index > (self.Count() - 1):
+            raise IndexError("Index " + index + " is out of range")
+
+        node = self.First()
+        i = 0
+        for i in range(index):
+            node = node.Next()
+        node.SetValue(value)
+
+    def GetEnumerator(self):
+        return LinkedListEnumerator(self)
+
+    def __iter__(self):
+        return LinkedListEnumerator(self)
+
+    def Append(self, Value):
+        node = TokenListNode(Value, self)
+        if self.m_Head == None:
+            self.m_Head = node
+        else:
+            self.m_Tail.SetNext(node)
+            node.SetPrevious(self.m_Tail)
+        self.m_Tail = node
+        self.m_Count += 1
+        return node
+
+    def Prepend(self, Value):
+        node = TokenListNode(Value, self)
+        if self.m_Tail == None:
+            self.m_Tail = node
+        else:
+            self.m_Head.SetPrevious(node)
+            node.SetNext(self.m_Head)
+        self.m_Head = node
+        self.m_Count += 1
+        return node
+
+    def InsertBefore(self, Before, Value):
+        if not isinstance(Before, TokenListNode):
+            raise TypeError("Before must be a TokenListNode")
+
+        node = TokenListNode(Value, self)
+        prev = Before.Previous()
+        node.SetNext(Before)
+        node.SetPrevious(prev)
+        Before.SetPrevious(node)
+        if prev != None:
+            prev.SetNext(node)
+        else:
+            self.m_Head = node
+        self.m_Count += 1
+        return node
+
+    def InsertAfter(self, After, Value):
+        if not isinstance(After, TokenListNode):
+            raise TypeError("Before must be a TokenListNode")
+
+        node = TokenListNode(Value, self)
+        next = After.Next()
+        node.SetNext(next)
+        node.SetPrevious(After)
+        After.SetNext(node)
+        if next != None:
+            next.SetPrevious(node)
+        else:
+            self.m_Tail = node
+        self.m_Count += 1
+        return node
+
+    def Remove(self, Node):
+        if not isinstance(Node, TokenListNode):
+            raise TypeError("Node must be a TokenListNode")
+        if self.m_Head == None:
+            raise TypeError("Cannot remove Node from empty list")
+            
+        prev = Node.Previous()
+        next = Node.Next()
+        if Node == self.m_Head and Node == self.m_Tail:
+            self.m_Head = self.m_Tail = None
+        elif Node == self.m_Head:
+            self.m_Head = next
+            self.m_Head.SetPrevious(None)
+        elif Node == self.m_Tail:
+            self.m_Tail = prev
+            self.m_Tail.SetNext(None)
+        else:
+            #  the node is in the middle of the list
+            next.SetPrevious(prev)
+            prev.SetNext(next)
+        self.m_Count -= 1
+
+    def First(self):
+        return self.m_Head
+
+    def Last(self):
+        return self.m_Tail
+
+
+class LinkedListEnumerator(ITokenEnumerator):
+    def Clone(self):
+        return LinkedListEnumerator(self)
+
+    def __init__(self, arg):
+        if isinstance(arg, _TokenList):
+            super(LinkedListEnumerator, self).__init__()
+            self.m_List = arg
+            self.m_Current = None
+            self.m_bEOF = False
+        elif isinstance(arg, LinkedListEnumerator):
+            super(LinkedListEnumerator, self).__init__()
+            self.m_List = arg.m_List
+            self.m_Current = arg.m_Current
+            self.m_bEOF = arg.m_bEOF
+        else:
+            raise TypeError("arg must be a _TokenList or LinkedListEnumerator")
+
+    def Count(self):
+        return self.m_List.Count()
+
+    def Current(self):
+        return self.m_Current.GetValue()
+
+    def MoveNext(self):
+        if self.m_bEOF:
+            return False
+        elif self.m_Current == None:
+            self.m_Current = self.m_List.First()
+        else:
+            self.m_Current = self.m_Current.Next()
+        self.m_bEOF = (self.m_Current == None)
+        return not self.m_bEOF
+
+    def MovePrevious(self):
+        if self.m_bEOF:
+            return False
+        elif self.m_Current == None:
+            self.m_Current = self.m_List.Last()
+        else:
+            self.m_Current = self.m_Current.Previous()
+        self.m_bEOF = (self.m_Current == None)
+        return not self.m_bEOF
+
+    def Reset(self):
+        self.m_Current = None
+        self.m_bEOF = False
+
+    def __iter__(self):
+        self.m_Current = None
+        self.m_bEOF = False
+        return self
+
+    def __next__(self):
+        if self.MoveNext():
+            return self.Current()
+        raise StopIteration

intersystems_iris/pex/_BusinessHost.py

@@ -0,0 +1,101 @@
+import json
+import sys
+import intersystems_iris
+from . import _Common
+
+class _BusinessHost(_Common):
+    """ This is a superclass for BusinessService, BusinesProcess, and BusinessOperation that
+    defines common methods. It is a subclass of Common.
+    """
+
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def OnGetConnections():
+        """ The OnGetConnections() method returns all of the targets of any SendRequestSync or SendRequestAsync
+        calls for the class. Implement this method to allow connections between components to show up in 
+        the interoperability UI.
+
+        Returns:
+            An IRISList containing all targets for this class. Default is None.
+        """
+        return None
+        
+    def SendRequestSync(self, target, request, timeout=-1, description=None):
+        """ 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.
+        """
+        if self._is_message_instance(request):
+            serialized = self._serialize(request)
+            returnObject = self.irisHandle.invoke("dispatchSendRequestSync",target,serialized,timeout,description)
+        elif isinstance(request, intersystems_iris.IRISObject):
+            returnObject = self.irisHandle.invoke("dispatchSendRequestSync",target,request,timeout,description)
+        else:
+            raise TypeError
+        if isinstance(returnObject, str):
+            returnObject = self._deserialize(returnObject)
+        return returnObject
+
+    @staticmethod
+    def _serialize(message):
+        """ Converts a message into json format.
+
+        Parameters:
+        message: The message to serialize, an instance of a class that is a subclass of Message.
+
+        Returns:
+        string: The message in json format.
+        """
+        if (message != None):
+            jString = json.dumps(message.__dict__) 
+            module = message.__class__.__module__
+            classname = message.__class__.__name__
+            return  module + "." + classname + ":" + jString
+        else:
+            return None
+
+    @staticmethod
+    def _deserialize(serial):
+        """ Converts a json string into a message of type classname, which is stored in the json string.
+
+        Parameters:
+        serial: The json string to deserialize.
+
+        Returns:
+        Message: The message as an instance of the class specified in the json string, which is a subclass of Message.
+
+        Raises:
+        ImportError: if the classname does not include a module name to import.
+        """
+        if (serial != None):
+            i = serial.find(":")
+            if (i <=0):
+                raise ValueError("JSON message malformed, must include classname: " + serial)
+            classpath = serial[:i]
+            gateway = intersystems_iris.GatewayContext.getConnection()._get_gateway()
+            try:
+                klass = gateway._load_class(classpath)
+                msg = klass()
+            except Exception:
+                raise ImportError("Class not found: " + classpath)
+            jdict = json.loads(serial[i+1:])
+            for k, v in jdict.items():
+                setattr(msg, k, v)
+            return msg
+        else:
+            return None
+                

intersystems_iris/pex/_BusinessOperation.py

@@ -0,0 +1,105 @@
+import intersystems_iris
+from intersystems_iris.pex._BusinessHost import _BusinessHost
+
+class _BusinessOperation(_BusinessHost):
+    """ This class corresponds to the PEX framework EnsLib.PEX.BusinessOperation class.
+    The EnsLib.PEX.BusinessOperation RemoteClassName property identifies the Python class with the business operation implementation.
+    The business operation can optionally use an adapter to handle the outgoing message. Specify the adapter in the OutboundAdapter property.
+    If the business operation has an adapter, it uses the adapter to send the message to the external system.
+    The adapter can either be a PEX adapter or an ObjectScript adapter.
+    """
+
+    def __init__(self):
+        """ The adapter variable provides access to the outbound adapter associated with the business operation."""
+        super().__init__()
+        self.Adapter = 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 OnMessage(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
+
+    @staticmethod
+    def getAdapterType():
+        """ The getAdapterType() method is called when registering the business operation in order to instruct the business operation on what outbout adapter to use.
+        The return value from this method should be the string name of the outbound 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 operations.
+        """
+        return ""
+
+    def _setIrisHandles(self, handleCurrent, handlePartner):
+        """ For internal use only. """
+        self.irisHandle = handleCurrent
+        self.Adapter = intersystems_iris.pex.IRISOutboundAdapter()
+        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.
+        
+        Raises:
+        TypeError: if request is not of type Message or IRISObject.
+        """
+        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
+        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
+
+    def _dispatchOnMessage(self, request):
+        """ For internal use only. """
+        if isinstance(request, str):
+            request = self._deserialize(request)
+        returnObject = self.OnMessage(request)
+        if self._is_message_instance(returnObject):
+            returnObject = self._serialize(returnObject)
+        return returnObject
+    

intersystems_iris/pex/_BusinessProcess.py

@@ -0,0 +1,214 @@
+import intersystems_iris
+from intersystems_iris.pex._BusinessHost import _BusinessHost
+
+class _BusinessProcess(_BusinessHost):
+    """ Typically contains most of the logic in a production.
+    A business process can receive messages from a business service, another business process, or a business operation.
+    It can modify the message, convert it to a different format, or route it based on the message contents.
+    The business process can route a message to a business operation or another business process.
+    """
+
+    PERSISTENT_PROPERTY_LIST=None
+    """ A list of the variable names of persistent properties."""
+
+    def __init__(self):
+        super().__init__()
+    
+    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."""
+        pass
+
+    def OnRequest(self, request):
+        """ Handles requests sent to the business process. A production calls this method whenever an initial request 
+        for a specific business process arrives on the appropriate queue and is assigned a job in which to execute.
+
+        Parameters:
+        request: An instance of IRISObject or subclass of Message that contains the request message sent to the business process.
+        
+        Returns:
+        An instance of IRISObject or subclass of Message that contains the response message that this business process can return
+            to the production component that sent the initial message.
+        """
+        pass
+
+    def OnResponse(self, request, response, callRequest, callResponse, completionKey):
+        """ Handles responses sent to the business process in response to messages that it sent to the target.
+        A production calls this method whenever a response for a specific business process arrives on the appropriate queue and is assigned a job in which to execute.
+        Typically this is a response to an asynchronous request made by the business process where the responseRequired parameter has a true value.
+
+        Parameters:
+        request: An instance of IRISObject or subclass of Message that contains the initial request message sent to the business process.
+        response: An instance of IRISObject or subclass of Message that contains the response message that this business process can return
+            to the production component that sent the initial message.
+        callRequest: An instance of IRISObject or subclass of Message that contains the request that the business process sent to its target.
+        callResponse: An instance of IRISObject or subclass of Message that contains the incoming response.
+        completionKey: A string that contains the completionKey specified in the completionKey parameter of the outgoing SendAsync() method.
+
+        Returns:
+        An instance of IRISObject or subclass of Message that contains the response message that this business process can return
+            to the production component that sent the initial message.
+        """
+        pass
+
+    def OnComplete(self, request, response):
+        """ Called after the business process has received and handled all responses to requests it has sent to targets.
+
+        Parameters: 
+        request: An instance of IRISObject or subclass of Message that contains the initial request message sent to the business process.
+        response: An instance of IRISObject or subclass of Message that contains the response message that this business process can return
+            to the production component that sent the initial message.
+
+        Returns:
+        An instance of IRISObject or subclass of Message that contains the response message that this business process can return
+            to the production component that sent the initial message.
+        """
+        pass
+
+    def _setIrisHandles(self, handleCurrent, handlePartner):
+        """ For internal use only. """
+        self.irisHandle = handleCurrent
+        return
+
+    def SendRequestAsync(self, target, request, responseRequired=True, completionKey=None, 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 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.
+        responseRequired: a boolean value that specifies if the target must send a response message. The default is True.
+        completionKey: A string that will be sent with the response message.
+        description: an optional string parameter that sets a description property in the message header. The default is None.
+        
+        Raises:
+        TypeError: if request is not of type Message or IRISObject.
+        """
+        if self._is_message_instance(request):
+            serialized = self._serialize(request)
+            self.irisHandle.invokeVoid("dispatchSendRequestAsync",target,serialized,responseRequired,completionKey,description)
+        elif isinstance(request, intersystems_iris.IRISObject):
+            self.irisHandle.invokeVoid("dispatchSendRequestAsync",target,request,responseRequired,completionKey,description)
+        else:
+            raise TypeError("Message of type: " + str(request.__class__) + " is invalid. Messages must be subclass of Message or IRISObject.")
+        return
+
+    def _savePersistentProperties(self, hostObject):
+        """ For internal use only. """
+        if self.PERSISTENT_PROPERTY_LIST == None:
+            return
+        for prop in self.PERSISTENT_PROPERTY_LIST:
+            val = getattr(self, prop, None)
+            typ = val.__class__.__name__
+            if (typ in ["str","int","float","bool","bytes"]):
+                try:
+                    hostObject.invoke("setPersistentProperty", prop, val)
+                except:
+                    pass
+        return
+
+    def _restorePersistentProperties(self, hostObject):
+        """ For internal use only. """
+        if self.PERSISTENT_PROPERTY_LIST == None:
+            return
+        for prop in self.PERSISTENT_PROPERTY_LIST:
+            try:
+                val = hostObject.invoke("getPersistentProperty", prop)
+                setattr(self, prop, val)
+            except:
+                pass
+        return
+
+    def _dispatchOnConnected(self, hostObject):
+        """ For internal use only. """
+        self._restorePersistentProperties(hostObject)
+        self.OnConnected()
+        self._savePersistentProperties(hostObject)
+        return
+
+    def _dispatchOnInit(self, hostObject):
+        """ For internal use only. """
+        self._restorePersistentProperties(hostObject)
+        self.OnInit()
+        self._savePersistentProperties(hostObject)
+        return
+
+    def _dispatchOnTearDown(self, hostObject):
+        """ For internal use only. """
+        self._restorePersistentProperties(hostObject)
+        self.OnTearDown()
+        self._savePersistentProperties(hostObject)
+        return
+
+    def _dispatchOnRequest(self, hostObject, request):
+        """ For internal use only. """
+        self._restorePersistentProperties(hostObject)
+        if isinstance(request, str):
+            request = self._deserialize(request)
+        returnObject = self.OnRequest(request)
+        if self._is_message_instance(returnObject):
+            returnObject = self._serialize(returnObject)
+        self._savePersistentProperties(hostObject)
+        return returnObject
+    
+    def _dispatchOnResponse(self, hostObject, request, response, callRequest, callResponse, completionKey):
+        """ For internal use only. """
+        self._restorePersistentProperties(hostObject)
+        if isinstance(request, str):
+            request = self._deserialize(request)
+        if isinstance(response, str):
+            response = self._deserialize(response)
+        if isinstance(callRequest, str):
+            callRequest = self._deserialize(callRequest)
+        if isinstance(callResponse, str):
+            callResponse = self._deserialize(callResponse)
+        returnObject = self.OnResponse(request, response, callRequest, callResponse, completionKey)
+        if self._is_message_instance(returnObject):
+            returnObject = self._serialize(returnObject)
+        self._savePersistentProperties(hostObject)
+        return returnObject
+
+    def _dispatchOnComplete(self, hostObject, request, response):
+        """ For internal use only. """
+        self._restorePersistentProperties(hostObject)
+        if isinstance(request, str):
+            request = self._deserialize(request)
+        if isinstance(response, str):
+            response = self._deserialize(response)
+        returnObject = self.OnComplete(request, response)
+        if self._is_message_instance(returnObject):
+            returnObject = self._serialize(returnObject)
+        self._savePersistentProperties(hostObject)
+        return returnObject
+
+    def Reply(self, response):
+        """ Send the specified response to the production component that sent the initial request to the business process.
+
+        Parameters:
+        response: An instance of IRISObject or subclass of Message that contains the response message.
+        """
+        if self._is_message_instance(response):
+            response = self._serialize(response)
+        self.irisHandle.invokeVoid("dispatchReply", response)
+        return
+
+    def SetTimer(self, timeout, completionKey=None):
+        """ Specifies the maximum time the business process will wait for responses.
+
+        Parameters:
+        timeout: an integer that specifies a number of seconds, or a string that specifies a time period such as"PT15s", 
+            which represents 15 seconds of processor time.
+        completionKey: a string that will be returned with the response if the maximum time is exceeded.
+        """
+        self.irisHandle.invokeVoid("dispatchSetTimer", timeout, completionKey)
+        return