iris-pex-embedded-python 2.3.25b2__py3-none-any.whl → 3.2.1b2__py3-none-any.whl

grongier/pex/_utils.py

@@ -1,369 +1 @@
-import os
-import ast
-import iris
-import inspect
-import xmltodict
-import pkg_resources
-
-class _Utils():
-    @staticmethod
-    def raise_on_error(sc):
-        """
-        If the status code is an error, raise an exception
-        
-        :param sc: The status code returned by the Iris API
-        """
-        if iris.system.Status.IsError(sc):
-            raise RuntimeError(iris.system.Status.GetOneStatusText(sc))
-
-    @staticmethod
-    def setup(path:str = None):
-
-        if path is None:
-            # get the path of the data folder with pkg_resources
-            path = pkg_resources.resource_filename('grongier', 'cls')
-
-        _Utils.raise_on_error(iris.cls('%SYSTEM.OBJ').LoadDir(path,'cubk',"*.cls",1))
-
-    @staticmethod
-    def register_component(module:str,classname:str,path:str,overwrite:int=1,iris_classname:str='Python'):
-        """
-        It registers a component in the Iris database.
-        
-        :param module: The name of the module that contains the class
-        :type module: str
-        :param classname: The name of the class you want to register
-        :type classname: str
-        :param path: The path to the component
-        :type path: str
-        :param overwrite: 0 = no, 1 = yes
-        :type overwrite: int
-        :param iris_classname: The name of the class in the Iris class hierarchy
-        :type iris_classname: str
-        :return: The return value is a string.
-        """
-        path = os.path.normpath(path)
-        # get the absolute path of the folder
-        path = os.path.abspath(path)
-        return iris.cls('Grongier.PEX.Utils').dispatchRegisterComponent(module,classname,path,overwrite,iris_classname)
-
-    @staticmethod
-    def register_folder(path:str,overwrite:int=1,iris_package_name:str='Python'):
-        """
-        > This function takes a path to a folder, and registers all the Python files in that folder as IRIS
-        classes
-        
-        :param path: the path to the folder containing the files you want to register
-        :type path: str
-        :param overwrite: 
-        :type overwrite: int
-        :param iris_package_name: The name of the iris package you want to register the file to
-        :type iris_package_name: str
-        """
-        path = os.path.normpath(path)
-        # get the absolute path of the folder
-        path = os.path.abspath(path)
-        for filename in os.listdir(path):
-            if filename.endswith(".py"): 
-                _Utils._register_file(filename, path, overwrite, iris_package_name)
-            else:
-                continue
-
-    @staticmethod
-    def register_file(file:str,overwrite:int=1,iris_package_name:str='Python'):
-        """
-        It takes a file name, a boolean to overwrite existing components, and the name of the Iris
-        package that the file is in. It then opens the file, parses it, and looks for classes that extend
-        BusinessOperation, BusinessProcess, or BusinessService. If it finds one, it calls register_component
-        with the module name, class name, path, overwrite boolean, and the full Iris package name
-        
-        :param file: the name of the file containing the component
-        :type file: str
-        :param overwrite: if the component already exists, overwrite it
-        :type overwrite: int
-        :param iris_package_name: the name of the iris package that you want to register the components to
-        :type iris_package_name: str
-        """
-        head_tail = os.path.split(file)
-        return _Utils._register_file(head_tail[1],head_tail[0],overwrite,iris_package_name)
-
-    @staticmethod
-    def _register_file(filename:str,path:str,overwrite:int=1,iris_package_name:str='Python'):
-        """
-        It takes a file name, a path, a boolean to overwrite existing components, and the name of the Iris
-        package that the file is in. It then opens the file, parses it, and looks for classes that extend
-        BusinessOperation, BusinessProcess, or BusinessService. If it finds one, it calls register_component
-        with the module name, class name, path, overwrite boolean, and the full Iris package name
-        
-        :param filename: the name of the file containing the component
-        :type filename: str
-        :param path: the path to the directory containing the files to be registered
-        :type path: str
-        :param overwrite: if the component already exists, overwrite it
-        :type overwrite: int
-        :param iris_package_name: the name of the iris package that you want to register the components to
-        :type iris_package_name: str
-        """
-        #pour chaque classe dans le module, appeler register_component
-        f =  os.path.join(path,filename)
-        with open(f) as file:
-            node = ast.parse(file.read())
-            #list of class in the file
-            classes = [n for n in node.body if isinstance(n, ast.ClassDef)]
-            for klass in classes:
-                extend = ''
-                if len(klass.bases) == 1:
-                    if hasattr(klass.bases[0],'id'):
-                        extend = klass.bases[0].id
-                    else:
-                        extend = klass.bases[0].attr
-                if  extend in ('BusinessOperation','BusinessProcess','BusinessService','DuplexService','DuplexProcess','DuplexOperation','InboundAdapter','OutboundAdapter'):
-                    module = _Utils.filename_to_module(filename)
-                    iris_class_name = f"{iris_package_name}.{module}.{klass.name}"
-                    # strip "_" for iris class name
-                    iris_class_name = iris_class_name.replace('_','')
-                    _Utils.register_component(module, klass.name, path, overwrite, iris_class_name)
-    @staticmethod
-    def register_package(package:str,path:str,overwrite:int=1,iris_package_name:str='Python'):
-        """
-        It takes a package name, a path to the package, a flag to overwrite existing files, and the name of
-        the iris package to register the files to. It then loops through all the files in the package and
-        registers them to the iris package
-        
-        :param package: the name of the package you want to register
-        :type package: str
-        :param path: the path to the directory containing the package
-        :type path: str
-        :param overwrite: 0 = don't overwrite, 1 = overwrite
-        :type overwrite: int
-        :param iris_package_name: The name of the package in the Iris package manager
-        :type iris_package_name: str
-        """
-        for filename in os.listdir(os.path.join(path,package)):
-            if filename.endswith(".py"):
-                _Utils._register_file(filename, os.path.join(path,package), overwrite, iris_package_name)
-            else:
-                continue
-
-    @staticmethod
-    def filename_to_module(filename) -> str:
-        """
-        It takes a filename and returns the module name
-        
-        :param filename: The name of the file to be imported
-        :return: The module name
-        """
-        module = ''
-
-        path,file = os.path.split(filename)
-        mod = file.split('.')[0]
-        packages = path.replace(os.sep, ('.'))
-        if len(packages) >1:
-            module = packages+'.'+mod
-        else:
-            module = mod
-
-        return module
-
-    @staticmethod
-    def migrate(filename=None,root_path=None):
-        """ 
-        Read the settings.py file and register all the components
-        settings.py file has two dictionaries:
-            * CLASSES
-                * key: the name of the class
-                * value: an instance of the class
-            * PRODUCTIONS
-                list of dictionaries:
-                * key: the name of the production
-                * value: a dictionary containing the settings for the production
-        """
-        # try to load the settings file
-        if filename:
-            import sys
-            path = None
-            # check if the filename is absolute or relative
-            if os.path.isabs(filename):
-                path = os.path.dirname(filename)
-            else:
-                raise ValueError("The filename must be absolute")
-            # add the path to the system path
-            sys.path.append(path)
-        import settings
-        # get the path of the settings file
-        path = os.path.dirname(inspect.getfile(settings))
-        try:
-            # set the classes settings
-            _Utils.set_classes_settings(settings.CLASSES,path)
-        except AttributeError:
-            print("No classes to register")
-        try:
-            # set the productions settings
-            _Utils.set_productions_settings(settings.PRODUCTIONS,path)
-        except AttributeError:
-            print("No productions to register")
-
-
-
-    @staticmethod
-    def set_classes_settings(class_items,root_path=None):
-        """
-        It takes a dictionary of classes and returns a dictionary of settings for each class
-        
-        :param class_items: a dictionary of classes
-        :return: a dictionary of settings for each class
-        """
-        for key, value in class_items.items():
-            if inspect.isclass(value):
-                path = None
-                if root_path:
-                    path = root_path
-                else:
-                    path = os.path.dirname(inspect.getfile(value))
-                _Utils.register_component(value.__module__,value.__name__,path,1,key)
-            elif inspect.ismodule(value):
-                path = None
-                if root_path:
-                    path = root_path
-                else:
-                    path = os.path.dirname(inspect.getfile(value))
-                _Utils._register_file(value.__name__+'.py',path,1,key)
-            # if the value is a dict
-            elif isinstance(value,dict):
-                # if the dict has a key 'path' and a key 'module' and a key 'class'
-                if 'path' in value and 'module' in value and 'class' in value:
-                    # register the component
-                    _Utils.register_component(value['module'],value['class'],value['path'],1,key)
-                # if the dict has a key 'path' and a key 'package'
-                elif 'path' in value and 'package' in value:
-                    # register the package
-                    _Utils.register_package(value['package'],value['path'],1,key)
-                # if the dict has a key 'path' and a key 'file'
-                elif 'path' in value and 'file' in value:
-                    # register the file
-                    _Utils._register_file(value['file'],value['path'],1,key)
-                # if the dict has a key 'path'
-                elif 'path' in value:
-                    # register folder
-                    _Utils.register_folder(value['path'],1,key)
-                else:
-                    raise ValueError(f"Invalid value for {key}.")
-
-    @staticmethod
-    def set_productions_settings(production_list,root_path=None):
-        """
-        It takes a list of dictionaries and registers the productions
-        """
-        # for each production in the list
-        for production in production_list:
-            # get the production name (first key in the dictionary)
-            production_name = list(production.keys())[0]
-            # set the first key to 'production'
-            production['Production'] = production.pop(production_name)
-            # handle Items
-            production = _Utils.handle_items(production,root_path)
-            # transform the json as an xml
-            xml = _Utils.dict_to_xml(production)
-            # register the production
-            _Utils.register_production(production_name,xml)
-
-    @staticmethod
-    def handle_items(production,root_path=None):
-        # if an item is a class, register it and replace it with the name of the class
-        if 'Item' in production['Production']:
-            # for each item in the list
-            for i,item in enumerate(production['Production']['Item']):
-                # if the attribute "@ClassName" is a class, register it and replace it with the name of the class
-                if '@ClassName' in item:
-                    if inspect.isclass(item['@ClassName']):
-                        path = None
-                        if root_path:
-                            path = root_path
-                        else:
-                            path = os.path.dirname(inspect.getfile(item['@ClassName']))
-                        _Utils.register_component(item['@ClassName'].__module__,item['@ClassName'].__name__,path,1,item['@Name'])
-                        # replace the class with the name of the class
-                        production['Production']['Item'][i]['@ClassName'] = item['@Name']
-                # if the attribute "@ClassName" is a dict
-                elif isinstance(item['@ClassName'],dict):
-                    # create a new dict where the key is the name of the class and the value is the dict
-                    class_dict = {item['@Name']:item['@ClassName']}
-                    # pass the new dict to set_classes_settings
-                    _Utils.set_classes_settings(class_dict)
-                    # replace the class with the name of the class
-                    production['Production']['Item'][i]['@ClassName'] = item['@Name']
-                else:
-                    raise ValueError(f"Invalid value for {item['@Name']}.")
-
-        return production
-
-    @staticmethod
-    def dict_to_xml(json):
-        """
-        It takes a json and returns an xml
-        
-        :param json: a json
-        :return: an xml
-        """
-        xml = xmltodict.unparse(json,pretty=True)
-        # remove the xml version tag
-        xml = xml.replace('<?xml version="1.0" encoding="utf-8"?>','')
-        # remove the new line at the beginning of the xml
-        xml = xml[1:]
-        return xml
-    
-    @staticmethod
-    def register_production(production_name,xml):
-        """
-        It takes a production name and an xml and registers the production
-        
-        :param production_name: the name of the production
-        :type production_name: str
-        :param xml: the xml of the production
-        :type xml: str
-        """
-        # split the production name in the package name and the production name
-        # the production name is the last part of the string
-        package = '.'.join(production_name.split('.')[:-1])
-        production_name = production_name.split('.')[-1]
-        stream = _Utils.string_to_stream(xml)
-        # register the production
-        _Utils.raise_on_error(iris.cls('Grongier.PEX.Utils').CreateProduction(package,production_name,stream))
-
-    @staticmethod
-    def export_production(production_name):
-        """
-        It takes a production name and exports the production
-        
-        :param production_name: the name of the production
-        :type production_name: str
-        """
-        def postprocessor(path, key, value):
-            if value is None:
-                return key, ''
-            return key, value
-        # export the production
-        xdata = iris.cls('Grongier.PEX.Utils').ExportProduction(production_name)
-        # for each chunk of 1024 characters
-        string = _Utils.stream_to_string(xdata)
-        # convert the xml to a dictionary
-        data = xmltodict.parse(string,postprocessor=postprocessor)
-        # return the dictionary
-        return data
-
-    @staticmethod
-    def stream_to_string(stream)-> str:
-        string = ""
-        stream.Rewind()
-        while not stream.AtEnd:
-            string += stream.Read(4092)
-        return string
-    
-    @staticmethod
-    def string_to_stream(string:str):
-        stream = iris.cls('%Stream.GlobalCharacter')._New()
-        n = 4092
-        chunks = [string[i:i+n] for i in range(0, len(string), n)]
-        for chunk in chunks:
-            stream.Write(chunk)
-        return stream
+from iop._utils import _Utils

intersystems_iris/_ConnectionInformation.py

@@ -1,7 +1,7 @@
 import intersystems_iris._Constant
 
-class _ConnectionInformation(object):
 
+class _ConnectionInformation(object):
     def __init__(self):
         self.protocol_version = intersystems_iris._Constant._Constant.PROTOCOL_VERSION
         self._is_unicode = True
@@ -20,9 +20,10 @@ class _ConnectionInformation(object):
     def _parse_server_version(self, server_version):
         split_1 = server_version.split("|")
         self._server_version = split_1[0]
-        if len(split_1)>1: self._iris_install_dir = split_1[1]
+        if len(split_1) > 1:
+            self._iris_install_dir = split_1[1]
         if self._server_version.find("Version") > 0:
-            version = server_version[server_version.find("Version")+8:]
+            version = server_version[server_version.find("Version") + 8 :]
             self._server_version_major = version.split(".")[0]
             self._server_version_minor = version.split(".")[1]
         return
@@ -31,24 +32,25 @@ class _ConnectionInformation(object):
     def _map_server_locale(locale):
         # we need to map IRIS locale literals to Python locale literals
         _locales = {
-            "LATIN1": "latin_1", 
-            "LATIN2": "iso8859_2", 
-            "LATINC": "iso8859_5", 
-            "LATINA": "iso8859_6", 
-            "LATING": "iso8859_7", 
-            "LATINH": "iso8859_8", 
-            "LATINT": "iso8859_11", 
-            "LATIN9": "iso8859_15", 
-            "CP1250": "cp1250", 
-            "CP1251": "cp1251", 
-            "CP1252": "cp1252", 
-            "CP1253": "cp1253", 
-            "CP1255": "cp1255", 
-            "CP1256": "cp1256", 
-            "CP1257": "cp1257", 
-            "CP874": "cp874", 
+            "LATIN1": "latin_1",
+            "LATIN2": "iso8859_2",
+            "LATINC": "iso8859_5",
+            "LATINA": "iso8859_6",
+            "LATING": "iso8859_7",
+            "LATINH": "iso8859_8",
+            "LATINT": "iso8859_11",
+            "LATIN9": "iso8859_15",
+            "CP1250": "cp1250",
+            "CP1251": "cp1251",
+            "CP1252": "cp1252",
+            "CP1253": "cp1253",
+            "CP1255": "cp1255",
+            "CP1256": "cp1256",
+            "CP1257": "cp1257",
+            "CP874": "cp874",
             "UNICODE": "utf-8",
         }
         return _locales[locale.upper()] if locale.upper() in _locales else locale
 
-
+    def __repr__(self) -> str:
+        return f"<{self._server_version}>"

intersystems_iris/dbapi/_DBAPI.py

@@ -1,3 +1,4 @@
+from typing import Union
 import struct
 import copy
 import enum
@@ -25,6 +26,7 @@ from ._SQLType import SQLType
 
 from .._IRISNative import connect as native_connect
 from .._IRISEmbedded import _IRISEmbedded
+from intersystems_iris._IRISConnection import _IRISConnection
 
 
 def NotImplementedErrorDBAPI(msg=None):
@@ -42,7 +44,7 @@ def embedded_connect(*args, hostname=None, port=None, namespace=None, username=N
     return connection
 
 
-def connect(*args, embedded=False, hostname=None, port=None, namespace=None, username=None, password=None, **kw):
+def connect(*args, embedded=False, hostname=None, port=None, namespace=None, username=None, password=None, **kw) -> Union[_IRISConnection, _IRISEmbedded]:
     try:
         if not embedded:
             return native_connect(
@@ -1180,6 +1182,8 @@ class Cursor(_BaseCursor):
         sets = self._parameter_sets or 1
         self.params = list(self.params).copy()
         param_types = [param.type for param in self._params._params_list]
+        if not self.params:
+            return
 
         for i in range(sets):
             params = self._params.collect(i)
@@ -2149,6 +2153,7 @@ class Cursor(_BaseCursor):
 
         if retval is None:
             return retval
+        # print('retval', retval[:])
         return retval.as_tuple()
         # return tuple(retval[:])
 

intersystems_iris/dbapi/_ResultSetRow.py

@@ -1,5 +1,5 @@
 import uuid
-from datetime import datetime, date, time
+from datetime import datetime, date, time, timezone
 from collections import namedtuple
 from ._SQLType import SQLType
 from .._DBList import _DBList
@@ -11,20 +11,26 @@ from ._Column import _Column
 def from_timestamp_posix(posix):
     time = int(posix)
     if time > 0:
-        time ^= 0x1000000000000000 
+        time ^= 0x1000000000000000
     else:
-        time |= 0xF000000000000000 
+        time |= 0xF000000000000000
 
     time /= 1000000
 
-    value = datetime.utcfromtimestamp(time).replace(tzinfo=None)
+    value = datetime.fromtimestamp(time, timezone.utc).replace(tzinfo=None)
     return value
 
+
 class _ResultSetRow:
     _locale = "latin-1"
     _connection = None
 
-    def __init__(self, connection, columns=None, rowcount=0, ):
+    def __init__(
+        self,
+        connection,
+        columns=None,
+        rowcount=0,
+    ):
         self._connection = connection
         # index from user-inputted columns to columns received from server
         self.col_index = []
@@ -55,7 +61,7 @@ class _ResultSetRow:
             self.colCount = len(columns) if columns != None else 0
 
         # number of columns received from server, aka number of items per row
-        #self.colCount = rowcount
+        # self.colCount = rowcount
 
         # list of _ListItems corresponding to the various entries in the row, plus the offset of next row's first _ListItem
         self.rowItems = None
@@ -126,9 +132,9 @@ class _ResultSetRow:
 
         def get(self):
             return self[:]
-        
+
         def as_tuple(self):
-            row = namedtuple('Row', [col.name for col in self._columns], rename=True)
+            row = namedtuple("Row", [col.name for col in self._columns], rename=True)
             values = self[:]
             return row(*values)
 
@@ -164,15 +170,18 @@ class _ResultSetRow:
                         HOROLOG_ORDINAL = date(1840, 12, 31).toordinal()
                         if item:
                             item = date.fromordinal(HOROLOG_ORDINAL + item)
+                    if ctype == SQLType.TIMESTAMP and item:
+                        item = item + '.000' if '.' not in item else item
+                        item = datetime.strptime(item, '%Y-%m-%d %H:%M:%S.%f')
                     if ctype == SQLType.TIME_HOROLOG:
                         if item:
                             item = time(item // 3600, item % 3600 // 60, item % 3600 % 60)
                     if ctype == SQLType.GUID:
                         item = uuid.UUID(item)
-                    if ctype == SQLType.TIMESTAMP_POSIX:
+                    if ctype == SQLType.TIMESTAMP_POSIX and item:
                         item = from_timestamp_posix(item)
 
-                    if _column.tableName == 'None' and _column.schema == 'None':
+                    if _column.tableName == "None" and _column.schema == "None":
                         # Ignore for anonymous tables
                         pass
                     elif item is None:
@@ -285,8 +294,9 @@ class _ResultSetRow:
                 rowItems[i] = curr_offset
                 prev_offset = curr_offset
             except IndexError:
-                raise IndexError("Row incomplete: " + str(self.colCount) +
-                                 " items expected, but " + str(i) + " were found")
+                raise IndexError(
+                    "Row incomplete: " + str(self.colCount) + " items expected, but " + str(i) + " were found"
+                )
         self.update(rowItems)
         return True
 
@@ -319,8 +329,9 @@ class _ResultSetRow:
                 rowItems[i] = curr_offset
                 prev_offset = curr_offset
             except IndexError:
-                raise IndexError("Row incomplete: " + str(self.colCount) +
-                                 " items expected, but " + str(i) + " were found")
+                raise IndexError(
+                    "Row incomplete: " + str(self.colCount) + " items expected, but " + str(i) + " were found"
+                )
         return self.update(rowItems)
 
     def update(self, rowItems):
@@ -330,7 +341,7 @@ class _ResultSetRow:
                 colIndexOffsets[idx] = rowItems[i]
             colIndexOffsets[-1] = self._last_list_item.next_offset
             self.rowItems = colIndexOffsets
-            return self.rowItems[:self.colCount]
+            return self.rowItems[: self.colCount]
         self.rowItems = rowItems
         self._offsets = self.DataRow(self)
         self._new_buffer = False

intersystems_iris/dbapi/preparser/_PreParser.py

@@ -580,7 +580,10 @@ class _PreParser(object):
                     break
                 if token.TokenType is TOKEN.CONSTANT:
                     values += '?'
-                    params += [token.Lexeme] 
+                    param = token.Lexeme
+                    if param.__len__ and param[0] == "'" and param[0] == param[-1]:
+                        param = param[1: -1]
+                    params += [param]
                 else:    
                     values += token.Lexeme
                 values += ' '

iop/__init__.py

@@ -0,0 +1,24 @@
+from iop._business_operation import _BusinessOperation
+from iop._business_process import _BusinessProcess
+from iop._business_service import _BusinessService
+from iop._director import _Director
+from iop._inbound_adapter import _InboundAdapter
+from iop._message import _Message
+from iop._outbound_adapter import _OutboundAdapter
+from iop._pickle_message import _PickleMessage
+from iop._private_session_duplex import _PrivateSessionDuplex
+from iop._private_session_process import _PrivateSessionProcess
+from iop._utils import _Utils
+
+class Utils(_Utils): pass
+class InboundAdapter(_InboundAdapter): pass
+class OutboundAdapter(_OutboundAdapter): pass
+class BusinessService(_BusinessService): pass
+class BusinessOperation(_BusinessOperation): pass
+class BusinessProcess(_BusinessProcess): pass
+class DuplexService(_PrivateSessionDuplex): pass
+class DuplexOperation(_PrivateSessionDuplex): pass
+class DuplexProcess(_PrivateSessionProcess): pass
+class Message(_Message): pass
+class PickleMessage(_PickleMessage): pass
+class Director(_Director): pass

iop/__main__.py

@@ -0,0 +1,4 @@
+# main entry is _cli.main()
+if __name__ == '__main__':
+    import iop._cli as _cli
+    _cli.main()