iris-pex-embedded-python 2.3.22b3__py3-none-any.whl → 2.3.23b2__py3-none-any.whl

grongier/cls/Grongier/Service/WSGI.cls

@@ -1,4 +1,4 @@
-Class Grongier.Service.WSGI Extends (%RegisteredObject, %CSP.REST) [ ServerOnly = 1 ]
+Class Grongier.Service.WSGI Extends %CSP.REST [ ServerOnly = 1 ]
 {
 
 Parameter CLASSPATHS;
@@ -7,99 +7,304 @@ Parameter MODULENAME;
 
 Parameter APPNAME;
 
-/// Helper method to write data to the output stream
-ClassMethod write(data)
-{
-    w data
-}
+Parameter DEVMODE = 1;
 
-/// Helper to build the environ
-ClassMethod GetEnviron() As %SYS.Python
+/// This method matches the request and method and calls the dispatcher
+ClassMethod Page(skipheader As %Boolean = 0) As %Status [ ProcedureBlock = 1 ]
 {
-    //set builtins
-    set builtins = ##class(%SYS.Python).Import("builtins")
+    #dim tSC As %Status = $$$OK
+    #dim e As %Exception.AbstractException
+    
+    #dim tAuthorized,tRedirected As %Boolean
+    #dim tRedirectRoutine,tURL As %String = ""
+    #dim %response As %CSP.Response
+        
+    Try {
 
-    //import dict to create environ
-    set dict = builtins.dict()
+        #; Ensure that we honor the requested charset 
+        Set %response.CharSet=..#CHARSET
 
-    #dim %request As %CSP.Request
+        #; Ensure that we honor the requested CONTENTTYPE
+        If ..#CONTENTTYPE'="" Set %response.ContentType=..#CONTENTTYPE 
 
-    //set environ 
-    do dict."__setitem__"("SERVER_NAME", $System.INetInfo.LocalHostName())
-    do dict."__setitem__"("SERVER_PORT", "")
-    do dict."__setitem__"("SERVER_PROTOCOL", "HTTP/1.1")
-    do dict."__setitem__"("SERVER_SOFTWARE", "IRIS")
-    do dict."__setitem__"("SCRIPT_NAME", ..#APPNAME)
-    do dict."__setitem__"("REQUEST_METHOD", %request.Method)
-    do dict."__setitem__"("CONTENT_TYPE", %request.ContentType)
-    do dict."__setitem__"("CHARSET", %request.CharSet)
-    Set app=$$getapp^%SYS.cspServer(%request.URL,.path,.match,.updatedurl)
-    do dict."__setitem__"("PATH_INFO", $extract(updatedurl,$length(path),*))
+        #; Ensure that we honor the requested HTTP_ACCEPT_LANGUAGE 
+        Set %response.Domain = ..#DOMAIN
+        Do %response.MatchLanguage() 
+        
+        #; Record if device re-direction is already active
+        Set tRedirected=##class(%Library.Device).ReDirectIO()
+        
+        #; Record the redirect routine
+        Set tRedirectRoutine=$System.Device.GetMnemonicRoutine()
+        
+        if ..#DEVMODE {
+            #; Not so pretty but help to for reload the WSGI application
+            do outputError^%SYS.cspServer2("","","","")
+        }
+        else {
+            #; Now switch to using THIS routine for device redirection
+            Use $io::("^%SYS.cspServer2")
 
-    // to extract the query string
+            #; Switch device redirection on (may already be on but thats ok)
+            Do ##class(%Library.Device).ReDirectIO(1)
+        }
 
-    return dict
-}
+        #; Ensure that the application is defined (security check)
+        If $$$GetSecurityApplicationsDispatchClass(%request.AppData)="" {
+             
+             #; Report not authorized
+             Set tSC=..Http403()
+             
+             #; Done
+             Quit
+        }
+        
+        #; GgiEnvs are not defined in the CSP shell
+        Set tURL=$Get(%request.CgiEnvs("CSPLIB"))
+        If tURL="" Set tURL=%request.URL
+          
+        #; Do an access check
+        Set tSC=..AccessCheck(.tAuthorized)
+        If $$$ISERR(tSC) Quit
 
-/// Implement a singleton pattern to get the python app
-ClassMethod GetPyhonApp() As %SYS.Python
-{
-    if ..#CLASSPATHS '="" {
-        set sys = ##class(%SYS.Python).Import("sys")
-        set delimiter = $s($system.Version.GetOS()="Windows":";",1:":")
-        set extraClasspaths = $tr(..#CLASSPATHS,delimiter,"|")
-        for i=1:1:$l(extraClasspaths,"|") {
-            set onePath = $p(extraClasspaths,"|",i)
-            set onePath = ##class(%File).NormalizeDirectory(onePath)
-            if onePath?1"$$IRISHOME"1P.E set onePath = $e($system.Util.InstallDirectory(),1,*-1)_$e(onePath,11,*)
-            if onePath'="" do sys.path.append(onePath)
+        If tAuthorized=0 {
+            
+            #; Don't want the session token
+            Set %response.OutputSessionToken=0
+            
+            #; Set the Http Status
+            Set %response.Status=..#HTTP403FORBIDDEN
+            
+            #; Done
+            Quit
         }
+        
+        #; Extract the match url from the application name
+        Set tMatchUrl = "/"_$Extract(tURL,$Length(%request.Application)+1,*)
+
+        #; Dispatch the request
+        Set tSC=..DispatchRequest(tMatchUrl,%request.Method)
+        
+    } Catch (e) {
+        Set tSC=e.AsStatus()
+    }
+    
+    If $$$ISERR(tSC) {
+        
+        #; Don't want the session token
+        Set %response.OutputSessionToken=0
+        
+        Do ..Http500(##class(%Exception.StatusException).CreateFromStatus(tSC))
+    }
+    
+    #; Ensure that at least something is written out as the body
+    #; This will trigger the device redirect capture and force headers to be written
+    #; (if not already done)
+    Write ""
+    
+    #; Reset redirect device if necessary
+    If tRedirected {
+        
+        #; Use the original redirected routine
+        Use $io::("^"_tRedirectRoutine)
+        
+        #; Switch device redirection on
+        Do ##class(%Library.Device).ReDirectIO(1)
     }
+    
+    #; Any errors should have been caught and reported
+    Quit $$$OK
+}
 
-    //import module
-    set module = ##class(%SYS.Python).Import(..#MODULENAME)
+ClassMethod OnPreDispatch(
+	pUrl As %String,
+	pMethod As %String,
+	ByRef pContinue As %Boolean) As %Status
+{
+         Set path = ..#CLASSPATHS
+         Set appName = ..#APPNAME
+         Set module = ..#MODULENAME
+         Set devmode = ..#DEVMODE
+         Set pContinue = 1
+         Do ..DispatchREST(pUrl, path, appName, module, devmode)
+         Quit $$$OK
+}
 
-    //set builtins
-    set builtins = ##class(%SYS.Python).Import("builtins")
+ClassMethod DispatchREST(
+	PathInfo As %String,
+	appPath As %String,
+	appName As %String,
+	module As %String,
+	devmode As %Boolean = 1) As %Status
+{
+           Set builtins = ##CLASS(%SYS.Python).Builtins()
+           Set interface = ##CLASS(%SYS.Python).Import("grongier.pex.wsgi.handlers")
+           Set rawformdata = ""
+           Set environ = builtins.dict()
+           Set key = %request.NextCgiEnv("")
 
-    //set app
-    set application = builtins.getattr(module, ..#APPNAME)
+           // Let's check if the WSGI application has been loaded or not for this session.
+           
+           If (($DATA(%session.Data("application")) && $ISOBJECT(%session.Data("application"))) && 'devmode) {
+            Set application = %session.Data("Application")
+           }
+           Else{
 
-    Return application
-}
+            Set application = ..GetPythonClass(appName, module, appPath)
+            If application = "" {
+                throw ##class(%Exception.General).%New("Error loading WSGI application: "_module_"."_appName_" from "_appPath)
+            }
+            Else {
+               Set %session.Data("Application") = application
+            }
+           }
 
-ClassMethod Page(skipheader As %Boolean = 1) As %Status [ Internal, ServerOnly = 1 ]
-{
-    Try {
-        
-        //set environ
-        set environ = ..GetEnviron()
+           // Editing some CGI variables that may be incorrect in %request
+           // Also filling in environ with as many CGI variables as possible from %request
+           // WSGI states that all CGI variables are valid and should be included if possible
+           While (key'="") {
+              Set value = %request.GetCgiEnv(key)
+              If key = "PATH_INFO" {
+               Set app=$$getapp^%SYS.cspServer(%request.URL,.path,.match,.updatedurl)
+               Set value = $EXTRACT(updatedurl,$LENGTH(path),*)
+              }
+              If key = "SCRIPT_NAME" {
+               //%request will sometimes have Script_name include Path_info
+               Set value = $PIECE(%request.Application, "/",1,*-1)
+              }
+              Do environ."__setitem__"(key,value)
+              Set key = %request.NextCgiEnv(key)
+           }
 
-        //import sys
-        set sys = ##class(%SYS.Python).Import("sys")
+           //Have to set up a correct wsgi.input stream from %request
+           Set stream = %request.Content
+           
+           Set contentType = %request.ContentType
+           Set contentLength = 0
 
-        //set stdin
-        set builtins = ##class(%SYS.Python).Import("builtins")
-        set ba = builtins.bytearray()
-        
-        while %request.Content.AtEnd = 0 {
-            do ba.extend(##class(%SYS.Python).Bytes(%request.Content.Read()))
-        }
-        //set handler
-        set handler = ##class(%SYS.Python).Import("grongier.pex.wsgi.handlers").IrisHandler(ba, sys.stdout, sys.stderr,environ)
+           If contentType = "application/x-www-form-urlencoded" {
+            Set formdict = builtins.dict()
+            Set key = $ORDER(%request.Data(""))
+            While (key'="") {
+               Set value = $GET(%request.Data(key,1))
+               Do formdict."__setitem__"(key,value)
+               Set key = $ORDER(%request.Data(key))
+            }
+            Do environ."__setitem__"("formdata", formdict)
+           }
+           ElseIf contentType = "multipart/form-data" {
+            Set boundary = $PIECE(%request.GetCgiEnv("CONTENT_TYPE"), "=",2)
+            Set stream = ##CLASS(%CSP.BinaryStream).%New()
 
-        // get a singleton app
-        set application = ..GetPyhonApp()
+            Do stream.Write($CHAR(13,10))
 
-        //run app
-        do handler.run(application)
+            //Get the Form Data values
 
-    }
-    Catch ex {
-        return ex.AsStatus()
-    }
+            Set key = $ORDER(%request.Data(""))
+            While (key'="") {
+               Do stream.Write("--")
+               Do stream.Write(boundary)
+               Do stream.Write($CHAR(13,10))
+               Set value = $GET(%request.Data(key,1))
+               Do stream.Write("Content-Disposition: form-data; name=")
+               Do stream.Write(""""_key_"""")
+               Do stream.Write($CHAR(13,10,13,10))
+               Do stream.Write(value)
+               Do stream.Write($CHAR(13,10))
+               Set key = $ORDER(%request.Data(key))
+            }
+
+            //Now get the possible MIME data streams
+            Set key = %request.NextMimeData("")
+            While key'="" {
+               Set numMimeStreams = %request.CountMimeData(key)
+               Set index = %request.NextMimeDataIndex(key, "")
+               Do stream.Write("--")
+               Do stream.Write(boundary)
+               Do stream.Write($CHAR(13,10))
+               If numMimeStreams > 1 {
+                  //I need to create a boundary for a nested multipart content type
+                  Set internalboundary = "--"
+                  For i = 1 : 1 : 7 {
+                     Set internalboundary = internalboundary _ $RANDOM(10)
+                  }
+                  While index '= "" {
+                     Set mimestream = %request.GetMimeData(key, index)
+                     Set headers = mimestream.Headers
+                     Do stream.Write("--")
+                     Do stream.Write(internalboundary)
+                     Do stream.Write($CHAR(13,10))
+                     Do stream.Write(headers)
+                     Do stream.Write($CHAR(13,10,13,10))
+                     Set sc = stream.CopyFrom(mimestream)
+                     //TODO error handling
+                     Do stream.Write($CHAR(13,10))
+                     Set index = %request.NextMimeDataIndex(key, index)
+                  }
+                  Do stream.Write("--")
+                  Do stream.Write(internalboundary)
+                  Do stream.Write("--")
+               }
+               Else {
+                  Set mimestream = %request.GetMimeData(key, index)
+                  Set headers = mimestream.Headers
+                  Do stream.Write(headers)
+                  Do stream.Write($CHAR(13,10,13,10))
+                  Set sc = stream.CopyFrom(mimestream)
+                  //TODO error handling
+                  Do stream.Write($CHAR(13,10))
+               }
+               Set key = %request.NextMimeData(key)
+            }
+            Do stream.Write("--")
+            Do stream.Write(boundary)
+            Do stream.Write("--")
+            Do stream.Rewind()
+           }
+
+
+           Try {
+            Do interface."make_request"(environ, stream, application, appPath)
+           }
+           Catch exception {
+            throw exception
+           }
+           Quit $$$OK
+}
+
+ClassMethod GetPythonClass(
+	pClassname As %String,
+	pModule As %String,
+	pClasspath As %String) As %SYS.Python
+{
+	Try {
+		If pClasspath '="" {
+            set sys = ##class(%SYS.Python).Import("sys")
+
+                for i=0:1:(sys.path."__len__"()-1) {
+                    Try {
+                        if sys.path."__getitem__"(i) = pClasspath {
+                            do sys.path."__delitem__"(i)
+                        }
+                    }
+                    Catch ex {
+                        // do nothing
+                    }
+
+                }
+                do sys.path.insert(0, pClasspath)
+		}
 
-    quit $$$OK
+		Set importlib = ##class(%SYS.Python).Import("importlib")
+		Set builtins = ##class(%SYS.Python).Import("builtins")
+		Set module = importlib."import_module"(pModule)
+		Set class = builtins.getattr(module, pClassname)
+   }
+   Catch ex {
+        throw ##class(%Exception.General).%New("Error loading WSGI application: "_pModule_"."_pClassname_" from "_pClasspath)
+   }
+	
+	Quit class
 }
 
 }

grongier/pex/wsgi/handlers.py

@@ -1,51 +1,104 @@
-from wsgiref.handlers import BaseHandler
-import io
+import os, sys, importlib, urllib.parse
+from io import BytesIO
+
+__ospath = os.getcwd()
+
 import iris
 
-class IrisHandler(BaseHandler):
-    """Handler that's just initialized with streams, environment, etc.
+os.chdir(__ospath)
+
+enc, esc = sys.getfilesystemencoding(), 'surrogateescape'
+
+rest_service = iris.cls('%REST.Impl')
+
+def get_from_module(app_path, app_module, app_name):
+
+    # Add the path to the application
+    if (app_path not in sys.path) :
+        sys.path.append(app_path)
+
+    # retrieve the application
+    return getattr(importlib.import_module(app_module), app_name)
+
+# Changes the current working directory to the manager directory of the instance.
+def goto_manager_dir():
+    iris.system.Process.CurrentDirectory(iris.system.Util.ManagerDirectory())
+
+def unicode_to_wsgi(u):
+    # Convert an environment variable to a WSGI "bytes-as-unicode" string
+    return u.encode(enc, esc).decode('iso-8859-1')
+
+def wsgi_to_bytes(s):
+    return s.encode('iso-8859-1')
+
+def write(chunk):
+    rest_service._WriteResponse(chunk)
+
+def start_response(status, response_headers, exc_info=None):
+    '''WSGI start_response callable'''
+    if exc_info:
+        try:
+            raise exc_info[1].with_traceback(exc_info[2])
+        finally:
+            exc_info = None
 
-    This handler subclass is intended for synchronous HTTP/1.0 origin servers,
-    and handles sending the entire response output, given the correct inputs.
+    rest_service._SetStatusCode(status)
+    for tuple in response_headers:
+        rest_service._SetHeader(tuple[0], tuple[1])
+    return write
 
-    Usage::
 
-        handler = SimpleHandler(
-            inp,out,err,env, multithread=False, multiprocess=True
-        )
-        handler.run(app)"""
+# Make request to application
+def make_request(environ, stream, application, path):
 
-    server_software = "IrisWSGI/0.1"
-    wsgi_file_wrapper = None
+    # Change the working directory for logging purposes
+    goto_manager_dir()
 
-    def __init__(self,stdin,stdout,stderr,environ,
-        multithread=True, multiprocess=False
-    ):
-        self.stdin = stdin
-        self.stdout = stdout
-        self.stderr = stderr
-        self.base_env = environ
-        self.wsgi_multithread = multithread
-        self.wsgi_multiprocess = multiprocess
+    error_log_file = open('WSGI.log', 'a+')
+    
+    # We want the working directory to be the app's directory
+    if (not path.endswith(os.path.sep)):
+        path = path + os.path.sep
 
-    def get_stdin(self):
-        if not self.stdin:
-            return None
-        else:
-            self.environ["wsgi.input"] = io.BytesIO(self.stdin)
-            self.environ["CONTENT_LENGTH"] = str(len(self.stdin))
-            return io.BytesIO(self.stdin)
+    #iris.system.Process.CurrentDirectory(path)
+    
+    # Set up the body of the request
+    if stream != '':
+        bytestream = stream
+    elif (environ['CONTENT_TYPE'] == 'application/x-www-form-urlencoded'):
+        bytestream = BytesIO()
+        part = urllib.parse.urlencode(environ['formdata'])
+        bytestream.write(part.encode('utf-8'))
+        bytestream.seek(0)
+    else:
+        bytestream = BytesIO(b'')
 
+    #for k,v in os.environ.items():
+        #environ[k] = unicode_to_wsgi(v)
+    environ['wsgi.input'] = bytestream   
+    environ['wsgi.errors'] = error_log_file
+    environ['wsgi.version']      = (1, 0)
+    environ['wsgi.multithread']  = False
+    environ['wsgi.multiprocess'] = True
+    environ['wsgi.run_once']     = True
 
-    def get_stderr(self):
-        return self.stderr
 
-    def add_cgi_vars(self):
-        self.environ.update(self.base_env)
+    if environ.get('HTTPS', 'off') in ('on', '1'):
+        environ['wsgi.url_scheme'] = 'https'
+    else:
+        environ['wsgi.url_scheme'] = 'http'
+    
+    # Calling WSGI application
+    response = application(environ, start_response)
 
-    def _write(self,data):
-        iris.cls('Grongier.Service.WSGI').write(data)
+    error_log_file.close()
 
-    def _flush(self):
-        self.stdout.flush()
-        self._flush = self.stdout.flush
+    try:
+        for data in response:
+            if data:
+                # (REST.Impl).Write() needs a utf-8 string
+                write(data.decode('utf-8'))
+            write(b'')
+    finally:
+        if hasattr(response, 'close'):
+            response.close()

intersystems_iris/_DBList.py

@@ -1,6 +1,7 @@
 import struct
 import decimal
 import functools
+import uuid
 import math
 import intersystems_iris._IRISOREF
 import datetime
@@ -326,6 +327,10 @@ class _DBList(object):
                 offset = cls.__stuff_multibyte(buffer, offset, data, is_oref, locale)
         return offset
 
+    @classmethod
+    def _stuff_uuid(cls, buffer, offset, data, locale, is_unicode, *args):
+        return cls._stuff_str(buffer, offset, str(data), locale=locale, is_unicode=is_unicode)
+
     @classmethod
     def _stuff_datetime(cls, buffer, offset, data, locale, is_unicode, *args):
         return cls._stuff_str(buffer, offset, data.strftime('%Y-%m-%d %H:%M:%S.%f'), locale=locale, is_unicode=is_unicode)
@@ -496,5 +501,6 @@ _DBList._set_switcher = {
     float: _DBList._stuff_double,
     decimal.Decimal: _DBList._stuff_decimal,
     str: _DBList._stuff_str,
+    uuid.UUID: _DBList._stuff_uuid,
     intersystems_iris._IRISOREF._IRISOREF: _DBList._stuff_str,
 }

intersystems_iris/_IRISEmbedded.py

@@ -51,7 +51,7 @@ class _IRISEmbedded:
             reset_vars(current_vars)
         self.iris = iris
         self._connection_info._delimited_ids = 1
-        self.restore_autocommit = iris.system.SQL.SetAutoCommit(0 if autoCommit is None else 1 if autoCommit else 2)
+        self.autoCommit = autoCommit
 
     def __enter__(self):
         return self
@@ -60,7 +60,6 @@ class _IRISEmbedded:
         self.close()
 
     def close(self):
-        self.iris.system.SQL.SetAutoCommit(self.restore_autocommit)
         self.iris = None
 
     def isClosed(self):
@@ -76,6 +75,7 @@ class _IRISEmbedded:
                 self._pre_preparse_cache[sql] = CachedSQL(cursor)
     
     def setAutoCommit(self, autoCommit):
+        self.autoCommit = autoCommit
         return self.iris.system.SQL.SetAutoCommit(0 if autoCommit is None else 1 if autoCommit else 2)
 
     def commit(self):

intersystems_iris/_ListWriter.py

@@ -51,6 +51,7 @@ class _ListWriter(object):
         param_switcher = {
             SQLType.LONGVARBINARY: self._set_stream,
             SQLType.LONGVARCHAR: self._set_stream,
+            SQLType.GUID: self._set_uuid,
             SQLType.DATE: None,
             SQLType.TIME: None,
             SQLType.TIMESTAMP: None,
@@ -90,7 +91,10 @@ class _ListWriter(object):
     def _set_stream(self, stream):
         self._set(stream)
         # raise NotImplementedError("Stream functionality not yet available with iris.dbapi")
-    
+
+    def _set_uuid(self, val):
+        self._set(str(val))
+
     def _set_date_h(self, date):
         HOROLOG_ORDINAL = datetime.date(1840, 12, 31).toordinal()
         if isinstance(date, datetime.date):

intersystems_iris/dbapi/_DBAPI.py

@@ -2,6 +2,7 @@ import struct
 import copy
 import enum
 import copy
+import uuid
 import decimal
 import intersystems_iris
 from collections import namedtuple
@@ -337,7 +338,7 @@ class _BaseCursor:
                 raise ValueError("INOUT/OUT parameters not permitted")
 
         self._prepared_update_execute()
-        
+
         return self._rowcount
 
     def _process_sqlcode(self, sqlcode, message=None):
@@ -367,8 +368,9 @@ class _BaseCursor:
                 if not self._is_batch_update:
                     raise TypeError("Unsupported argument type: " + str(type(item)))
                 for ele in item:
-                    if (not intersystems_iris._DBList._DBList._set_switcher.get(type(ele), None) and not issubclass(
-                            type(ele), enum.Enum)):
+                    if not intersystems_iris._DBList._DBList._set_switcher.get(type(ele), None) and not issubclass(
+                        type(ele), enum.Enum
+                    ):
                         raise TypeError("Unsupported argument type: " + str(type(ele)))
             elif intersystems_iris._DBList._DBList._set_switcher.get(type(item), None) is None:
                 item = str(item)
@@ -661,7 +663,7 @@ class _BaseCursor:
     def description(self):
         if self._statementType is StatementType.UPDATE:
             return None
-        
+
         if self._columns is None:
             return None
 
@@ -757,7 +759,7 @@ class Cursor(_BaseCursor):
             return True
         else:
             return False
-        
+
     def _reset_cached_info(self):
         if not self._connection._preparedCache or not hasattr(self._connection._preparedCache, "__iter__"):
             return
@@ -1178,7 +1180,7 @@ 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]
-        
+
         for i in range(sets):
             params = self._params.collect(i)
             for pi, param in enumerate(params):
@@ -1207,14 +1209,18 @@ class Cursor(_BaseCursor):
                 if size == 0:
                     break
                 size = 4096 if size > 4096 else size
-                chunk = value[offset:offset + size]
+                chunk = value[offset : offset + size]
                 if not isinstance(chunk, bytes):
                     chunk = bytes(chunk, "utf-8")
                 offset += size
                 full_size -= size
 
                 # message header
-                code = _Message.STORE_BINARY_STREAM if param_type == SQLType.LONGVARBINARY else _Message.STORE_CHARACTER_STREAM
+                code = (
+                    _Message.STORE_BINARY_STREAM
+                    if param_type == SQLType.LONGVARBINARY
+                    else _Message.STORE_CHARACTER_STREAM
+                )
                 self._out_message.wire._write_header(code)
                 intersystems_iris._MessageHeader._MessageHeader._set_statement_id(
                     self._out_message.wire.buffer, self._statement_id
@@ -2240,10 +2246,23 @@ class EmbdeddedCursor(_BaseCursor):
         self._sql = connection.iris.sql
         self._iris = connection.iris
         self._closed = False
+        self._connection = connection
+        self.restore_selectmode = self._iris.system.SQL.SetSelectMode(1)
+        self.restore_autocommit = self._iris.system.SQL.SetAutoCommit(
+            0 if self._connection.autoCommit is None else 1 if self._connection.autoCommit else 2
+        )
 
-        # $System.SQL.SetSelectMode(1 /* ODBC */)
-        # $System.SQL.Util.SetOption("SelectMode", 1 /* ODBC */)
-        connection.iris.system.SQL.SetSelectMode(1)
+    def close(self):
+        self._iris.system.SQL.SetSelectMode(self.restore_selectmode)
+        self._iris.system.SQL.SetAutoCommit(self.restore_autocommit)
+        super().close()
+
+    def __del__(self):
+        try:
+            self.close()
+        except:
+            pass
+        return
 
     def _get_cached_info(self):
         return False
@@ -2386,14 +2405,18 @@ class EmbdeddedCursor(_BaseCursor):
         sets = self._parameter_sets or 1
         metadata = self._statement.Statement._Metadata.parameters
         param_types = [metadata.GetAt(i + 1).ODBCType for i in range(metadata.Size)]
-        
+
         stream_chunk_size = 32000
 
         for i in range(sets):
             params = self._get_parameters(i)
             for ip, param in enumerate(params):
                 if param_types[ip] in (SQLType.LONGVARBINARY, SQLType.LONGVARCHAR):
-                    stream_class = '%Stream.GlobalBinary' if param_types[ip] == SQLType.LONGVARBINARY else '%Stream.GlobalCharacter'
+                    stream_class = (
+                        "%Stream.GlobalBinary"
+                        if param_types[ip] == SQLType.LONGVARBINARY
+                        else "%Stream.GlobalCharacter"
+                    )
                     stream = self._iris.cls(stream_class)._New()
                     while param:
                         stream.Write(param[:stream_chunk_size])
@@ -2448,6 +2471,7 @@ class EmbdeddedCursor(_BaseCursor):
         row = namedtuple("Row", [col.name for col in self._columns], rename=True)
 
         _types = {
+            SQLType.GUID: uuid.UUID,
             SQLType.BIGINT: int,
             SQLType.BINARY: bytes,
             SQLType.VARBINARY: bytes,

intersystems_iris/dbapi/_ResultSetRow.py

@@ -1,3 +1,4 @@
+import uuid
 from datetime import datetime
 from collections import namedtuple
 from ._SQLType import SQLType
@@ -67,6 +68,7 @@ class _ResultSetRow:
 
     class DataRow:
         _types = {
+            SQLType.GUID: uuid.UUID,
             SQLType.BIGINT: int,
             SQLType.BINARY: bytes,
             SQLType.BIT: None,
@@ -157,6 +159,8 @@ class _ResultSetRow:
                 ctype = _column.type
                 value_type = self._types[ctype] if ctype in self._types else None
                 try:
+                    if ctype == SQLType.GUID:
+                        item = uuid.UUID(item)
                     if ctype == SQLType.TIMESTAMP_POSIX:
                         item = from_timestamp_posix(item)
 

iris/__init__.pyi

@@ -0,0 +1,187 @@
+from __future__ import annotations
+from typing import Any
+from iris.iris_ipm import ipm
+from . import iris_ipm
+__all__ = [ 'check_status', 'cls', 'execute', 'gref', 'ipm', 'iris_ipm', 'lock', 'os', 'ref', 'routine', 'sql', 'system', 'tcommit', 'tlevel', 'trollback', 'trollbackone', 'tstart', 'unlock', 'utils']
+def check_status(self, status):
+    """
+    Raises an exception on an error status, or returns None if no error condition occurs.
+    Example: iris.check_status(st) checks the status code st to see if it contains an error.
+    """
+def cls(self, class_name):
+    """
+    Returns a reference to an InterSystems IRIS class.
+    Example: iris.cls("%SYSTEM.INetInfo").LocalHostName() calls a method in the class %SYSTEM.INetInfo.
+    """
+def execute(self, statements):
+    """
+    execute IRIS statements.
+    Example: iris.execute("set x="Hello"\nw x,!\n") returns nothing.
+    """
+def gref(self, global_name):
+    """
+    Returns a reference to an InterSystems IRIS global.
+    Example: g = iris.gref("^foo") sets g to a reference to global ^foo
+    """
+def lock(self, lock_list, timeout_value, locktype):
+    """
+    Sets locks, given a list of lock names, an optional timeout value (in seconds), and an optional locktype.
+    Example: iris.lock(["^foo","^bar"], 30, "S") sets locks "^foo" and "^bar", waiting up to 30 seconds, and using shared locks.
+    """
+def ref(self, value):
+    """
+    Creates an iris.ref object with a specified value.
+    Example: iris.ref("hello") creates an iris.ref object with the value "hello"
+    """
+def routine(self, routine, args):
+    """
+    Invokes an InterSystems IRIS routine, optionally at a given tag.
+    Example: iris.routine("Stop^SystemPerformance", "20211221_160620_test") calls tag Stop in routine ^SystemPerformance.
+    """
+def tcommit(self):
+    """
+    Marks a successful end of an InterSystems IRIS transaction.
+    Example: iris.commit() marks the successful end of a transaction and decrements the nesting level by 1
+    """
+def tlevel(self):
+    """
+    Detects whether a transaction is currently in progress and returns the nesting level. Zero means not in a transaction.
+    Example: iris.tlevel() returns the current transaction nesting level, or zero if not in a transaction
+    """
+def trollback(self):
+    """
+    Terminates the current transaction and restores all journaled database values to their values at the start of the transaction.
+    Example: iris.trollback() rolls back all current transactions in progress and resets the transaction nesting level to 0
+    """
+def trollbackone(self):
+    """
+    Rolls back the current level of nested transactions, that is, the one initiated by the most recent tstart().
+    Example: iris.trollbackone() rolls back the current level of nested transactions and decrements the nesting level by 1
+    """
+def tstart(self):
+    """
+    Starts an InterSystems IRIS transaction.
+    Example: iris.tstart() marks the beginning of a transaction.
+    """
+def unlock(self, lock_list, timout_value, locktype):
+    """
+    Removes locks, given a list of lock names, an optional timeout value (in seconds), and an optional locktype.
+    Example: iris.unlock(["^foo","^bar"], 30, "S") removes locks "^foo" and "^bar", waiting up to 30 seconds, and using shared locks.
+    """
+def utils(self):
+    """
+    Returns a reference to the InterSystems IRIS utilities class.
+    Example: iris.utils().$Job() returns the current job number.
+    """
+# stubs for the sql object
+class sql:
+    """
+    The sql object provides access to the InterSystems IRIS SQL API.
+    """
+    def exec(self, query: str) -> Any:
+        """
+        Execute a query
+        """
+    def prepare(self, query: str) -> PreparedQuery:
+        """
+        Prepare a query
+        """
+    class PreparedQuery:
+        def execute(self, **kwargs) -> Any:
+            """
+            Execute a prepared query, you can pass values
+            """
+# stubs for the system object
+class system:
+    """
+    The system object provides access to the InterSystems IRIS system API.
+    The following classes are available:
+    'DocDB', 'Encryption', 'Error', 'Event', 'Monitor', 'Process', 'Python', 'SQL', 'SYS', 'Security', 'Semaphore', 'Status', 'Util', 'Version'
+    """
+    class DocDB:
+        """
+        The DocDB class provides access to the InterSystems IRIS Document Database API.
+        The following methods are available:
+        'CreateDatabase', 'DropAllDatabases', 'DropDatabase', 'Exists', 'GetAllDatabases', 'GetDatabase', 'Help'
+        """
+        def CreateDatabase(self, name: str, path: str, **kwargs) -> Any:
+            """
+            Create a database
+            """
+        def DropAllDatabases(self) -> Any:
+            """
+            Drop all databases
+            """
+        def DropDatabase(self, name: str) -> Any:
+            """
+            Drop a database
+            """
+        def Exists(self, name: str) -> Any:
+            """
+            Check if a database exists
+            """
+        def GetAllDatabases(self) -> Any:
+            """
+            Get all databases
+            """
+        def GetDatabase(self, name: str) -> Any:
+            """
+            Get a database
+            """
+        def Help(self) -> Any:
+            """
+            Get help
+            """
+    def Encryption(self) -> Any:
+        """
+        The Encryption class provides access to the InterSystems IRIS Encryption API.
+        """
+    def Error(self) -> Any:
+        """
+        The Error class provides access to the InterSystems IRIS Error API.
+        """
+    def Event(self) -> Any:
+        """
+        The Event class provides access to the InterSystems IRIS Event API.
+        """
+    def Monitor(self) -> Any:
+        """
+        The Monitor class provides access to the InterSystems IRIS Monitor API.
+        """
+    def Process(self) -> Any:
+        """
+        The Process class provides access to the InterSystems IRIS Process API.
+        """
+    def Python(self) -> Any:
+        """
+        The Python class provides access to the InterSystems IRIS Python API.
+        """
+    def SQL(self) -> Any:
+        """
+        The SQL class provides access to the InterSystems IRIS SQL API.
+        """
+    def SYS(self) -> Any:
+        """
+        The SYS class provides access to the InterSystems IRIS SYS API.
+        """
+    def Security(self) -> Any:
+        """
+        The Security class provides access to the InterSystems IRIS Security API.
+        """
+    def Semaphore(self) -> Any:
+        """
+        The Semaphore class provides access to the InterSystems IRIS Semaphore API.
+        """
+    def Status(self) -> Any:
+        """
+        The Status class provides access to the InterSystems IRIS Status API.
+        """
+    def Util(self) -> Any:
+        """
+        The Util class provides access to the InterSystems IRIS Util API.
+        """
+    def Version(self) -> Any:
+        """
+        The Version class provides access to the InterSystems IRIS Version API.
+        """
+

iris/iris_ipm.pyi

@@ -0,0 +1,17 @@
+from __future__ import annotations
+__all__ = ['ipm']
+def ipm(cmd, *args):
+    """
+    
+        Executes shell command with IPM:
+        Parameters
+        ----------
+        cmd : str
+            The command to execute
+        Examples
+        --------
+        `ipm('help')`
+        `ipm('load /home/irisowner/dev -v')`
+        `ipm('install webterminal')`
+        
+    """

{iris_pex_embedded_python-2.3.22b3.dist-info → iris_pex_embedded_python-2.3.23b2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
-Name: iris-pex-embedded-python
-Version: 2.3.22b3
+Name: iris_pex_embedded_python
+Version: 2.3.23b2
 Summary: Iris Interoperability based on Embedded Python
 Author-email: grongier <guillaume.rongier@intersystems.com>
 License: MIT License

{iris_pex_embedded_python-2.3.22b3.dist-info → iris_pex_embedded_python-2.3.23b2.dist-info}/RECORD

@@ -18,7 +18,7 @@ grongier/cls/Grongier/PEX/PrivateSession/Message/Ack.cls,sha256=WbBn7pWj5mzruVfL
 grongier/cls/Grongier/PEX/PrivateSession/Message/Poll.cls,sha256=2lj-e20AH7RR8UgGJaldrk-1kd8WjQJNPiH-duds_4A,987
 grongier/cls/Grongier/PEX/PrivateSession/Message/Start.cls,sha256=DAtq4DyRqFq2_4Isa0cZjjwuAzdHjsQu8wMppK4myzs,994
 grongier/cls/Grongier/PEX/PrivateSession/Message/Stop.cls,sha256=ofVKjrN6UPFasalrjPFWYNwlJ5IBlAE62IH8_U07c0g,1435
-grongier/cls/Grongier/Service/WSGI.cls,sha256=X_yM4oxTBOfIOzsCGnvutIuqCAfg7hd6Oqfl-Kq3TjM,2979
+grongier/cls/Grongier/Service/WSGI.cls,sha256=2KrnsATyoarrN6un-2sJwNK-ANw36Waa8GgFx97XQKA,10598
 grongier/pex/__init__.py,sha256=nvcmRCxLy-lpL5GzlCKrmsSK8LF8Q0aKddx6ib8U50E,1166
 grongier/pex/__main__.py,sha256=ebEYPDOBKiXOlmdI4onpQLzfBKU4wyfijYyquA5dWV4,107
 grongier/pex/_business_host.py,sha256=G4-eWlQzWMvjaHauISfSoogPsfQYJavmRi563ak6FS8,20858
@@ -35,20 +35,20 @@ grongier/pex/_pickle_message.py,sha256=noKfc2VkXufV3fqjKvNHN_oANQ1YN9ffCaSV0XSTA
 grongier/pex/_private_session_duplex.py,sha256=Qj_xzwwFnFVwi_Sl7Q7nKk4zmL6UC8iqBAuwnz7mVX8,5033
 grongier/pex/_private_session_process.py,sha256=_2r_csWcVRLmIUt4O0Y1Hg1FcX6A08lt9DvALQhwu8s,1722
 grongier/pex/_utils.py,sha256=GjHT5WolQAoeYkhHP3a0uDBlRzPIkyGG_bi-TwrMdjI,15877
-grongier/pex/wsgi/handlers.py,sha256=t9i3bNld3bewWWOOm5vrDHa1Dcxvp-SB5cHgPUFrggQ,1417
+grongier/pex/wsgi/handlers.py,sha256=NrFLo_YbAh-x_PlWhAiWkQnUUN2Ss9HoEm63dDWCBpQ,2947
 intersystems_iris/_BufferReader.py,sha256=BXjHQs-sclAnvW9mvdlIrtku9m2Jf67Rc5rsZll7a5g,299
 intersystems_iris/_BufferWriter.py,sha256=i2BKM99J8pB5fGn-Gjdo4vcwXPEZQymsLEQd69nJrhs,1337
 intersystems_iris/_ConnectionInformation.py,sha256=Xr6sOPy3uKFyOG05hTmutDHTNjHDhCnCVwH0TTNEwBE,1896
 intersystems_iris/_ConnectionParameters.py,sha256=5-VwMJP_6Ya0lNnMf0UuwJQQfwHcozjknnUekMwCgQ4,578
 intersystems_iris/_Constant.py,sha256=g2NdV669sNH4kUoAjQFNq2xWaEMQiPMoQytNNrrXOnk,1483
-intersystems_iris/_DBList.py,sha256=dXg08f87nWduVaClhFOAw_cc0ue_Q9pbaPkbtPVjSlY,20104
+intersystems_iris/_DBList.py,sha256=D0m_N50ZhpUnGwQiPZ1ZPtNecqROZvSnVbP46RY6juA,20340
 intersystems_iris/_Device.py,sha256=02rNhk32bLrcOdGDOsRHuX79-MLblGvAdBa-XfHtVkw,2311
 intersystems_iris/_GatewayContext.py,sha256=anipv7v5rDS2Ha2MmXTuMtFjo6UNgzUF3SwKQSS-co8,618
 intersystems_iris/_GatewayException.py,sha256=Hs5en7W1mhtt2heuoeyhF5IqFKGqbRD5GWyWZUhwDzs,96
 intersystems_iris/_GatewayUtility.py,sha256=gJTslU_UZBI8bWPTPe6b41DwhaAmlpzUNYT0LkAKXKk,2735
 intersystems_iris/_IRIS.py,sha256=vlxyMtfvyTkHHw5CkfNYqNbR1zUdAknfbLVTGxEOv3E,49548
 intersystems_iris/_IRISConnection.py,sha256=MmPIQJPZ28HoSYafvf4r5cbenzDiHmZhKgZXVfSxnCw,21467
-intersystems_iris/_IRISEmbedded.py,sha256=27oB-o53b1w3gbXNxyT6Z1DGWd9gc4x1h3Nz9luOhN4,2614
+intersystems_iris/_IRISEmbedded.py,sha256=yYL71oLvHjLK_jF8wcyNjXu3ManQ_PpY2wD4GkOfa-E,2503
 intersystems_iris/_IRISGlobalNode.py,sha256=o2MEvyRmNrvLAR0dpeQ76r9b8Yw2sKDaaRLFyGYdcDQ,12049
 intersystems_iris/_IRISGlobalNodeView.py,sha256=0yw9z_mpSLk2m3we5z_vKSjnEdmKfZb11bbASZiiSm8,797
 intersystems_iris/_IRISIterator.py,sha256=m1n_fRdoO8YPfDi7l-JvJTqdJuxq_kxC60aMxkxLJUE,6906
@@ -61,7 +61,7 @@ intersystems_iris/_InStream.py,sha256=6g4HdDoQ0MFub8Yn-Git8DkJNEoyyAtAhrvjkUdDA7
 intersystems_iris/_LegacyIterator.py,sha256=K1CPMBDWBCwKVqIq9hBJ2q_uMiBnht_OdN66g7ZqXfw,4130
 intersystems_iris/_ListItem.py,sha256=k9m0Q0W3e3WuI5cpB1GSZOR9NkkCT87lgvBwYFMzvic,354
 intersystems_iris/_ListReader.py,sha256=wgK0HC56lI1Wdp9Sr3rax6w8NoR5p2YpklswpNIS5X8,2966
-intersystems_iris/_ListWriter.py,sha256=JGmUkzzWUGbwflb9szpRQU305dWqoGkFMvCMwP8uPkE,5515
+intersystems_iris/_ListWriter.py,sha256=zBQd7Mx3ho0jOd_q4RNAhw1ub1kUXVptwRYMN36OQew,5612
 intersystems_iris/_LogFileStream.py,sha256=Dv3S8-zY3b7P4xXx7w0UVGm2vuz7bWTyaOTg6eK0l2s,3797
 intersystems_iris/_MessageHeader.py,sha256=N45Qp25ER7ftGA0BRBxErIpavDF-j4qWv_0kobkAp6U,1662
 intersystems_iris/_OutStream.py,sha256=_I83KPUCv9yBHsaB4QGBeSatypdiMGJxckKdNY1Jzyg,1327
@@ -71,13 +71,13 @@ intersystems_iris/_SharedMemorySocket.py,sha256=2iUaS1FdJNSCUEaE-VT0O_dxF6NRwqZS
 intersystems_iris/__init__.py,sha256=Tk1tD28LwvF6X3yXQsJFLE1Bc-PR3gUJWcX5UnNYOdY,1773
 intersystems_iris/__main__.py,sha256=rCtINTfJcADMAsw1ja-MEO7Q-XekrWthYowzWV8xGIQ,218
 intersystems_iris/dbapi/_Column.py,sha256=VCLHLXs3wuGcUa9w_qy7HBFsuGvhmmI3kGYBagQg59U,2535
-intersystems_iris/dbapi/_DBAPI.py,sha256=eV9PA3T1dlMpKY_H2SAarcbNjOujpprKe99qHqtaUPg,102320
+intersystems_iris/dbapi/_DBAPI.py,sha256=sqkUxjhK683icHlE56ywygV8ODz7yudeIJOQSQTeb78,102938
 intersystems_iris/dbapi/_Descriptor.py,sha256=IjyITxvjygDrhpk-0lGhdqQPh91SG6nTb1vi-AqyJNI,1391
 intersystems_iris/dbapi/_IRISStream.py,sha256=dGJntWo4HXgM1nUHZl2hA4xHkBFEU2xkoEplVDFWhnA,2115
 intersystems_iris/dbapi/_Message.py,sha256=jpLG3HZElqp981iNPFW8UNRO3NbHf6poEv6yywX0Ssw,4076
 intersystems_iris/dbapi/_Parameter.py,sha256=lvPlQkoLlyEjg5J_a9t2I_6vRDkAav6kN1fGyukH4DY,5293
 intersystems_iris/dbapi/_ParameterCollection.py,sha256=kcgNiGv2nH5AwuA6LlPpM4dWqhSqRyD3VtwqHqDGRGU,5541
-intersystems_iris/dbapi/_ResultSetRow.py,sha256=tNKCv5P8XhP9zzdPpBGiXYHLKOScITTBGSqtui1TAM0,12910
+intersystems_iris/dbapi/_ResultSetRow.py,sha256=1V5ixV2VQz0-LDEvVz-khW4e1V6xmlgZ6VyV4PbuQsE,13052
 intersystems_iris/dbapi/_SQLType.py,sha256=IlDacXwQzUMWaJ02Zsu2bUfvUC3-5mBx-m6mE0Yp7ts,557
 intersystems_iris/dbapi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 intersystems_iris/dbapi/preparser/_PreParser.py,sha256=024w-s3n_JNsk_ISC8avJMK3QEZE3hSuD0Nr8arJdZw,78828
@@ -100,12 +100,14 @@ intersystems_iris/pex/_Message.py,sha256=Ugaa_lsEYke__pI5kdC7phAuyPQ7rxXUcROJL4c
 intersystems_iris/pex/_OutboundAdapter.py,sha256=ao2Ubbta2DcrQGdzDUD_j1Zsk8bvUfcZNKTZkzPTNBU,1628
 intersystems_iris/pex/__init__.py,sha256=l_I1dpnluWawbFrGMDC0GLHpuHwjbpd-nho8otFX6TE,1379
 iris/__init__.py,sha256=VyBPMqjkad0JPoza38YZbBeLHM7jZUMS90t8KKEIW94,1045
+iris/__init__.pyi,sha256=BtE0ZohcTo2EYDQhlqqEndMUnIyQIHUte3OIx3S6DKo,6994
 iris/iris_ipm.py,sha256=Q0jcNItjywlqOPZr0hgdTFSeLPNEmB-tcICOI_cXnaY,790
+iris/iris_ipm.pyi,sha256=j7CNUZcjeDu5sgeWUZJO_Qi4vQmHh6aD-jPWv8OdoUs,374
 irisnative/_IRISNative.py,sha256=HQ4nBhc8t8_5OtxdMG-kx1aa-T1znf2I8obZOPLOPzg,665
 irisnative/__init__.py,sha256=6YmvBLQSURsCPKaNg7LK-xpo4ipDjrlhKuwdfdNb3Kg,341
-iris_pex_embedded_python-2.3.22b3.dist-info/LICENSE,sha256=rZSiBFId_sfbJ6RL0GjjPX-InNLkNS9ou7eQsikciI8,1089
-iris_pex_embedded_python-2.3.22b3.dist-info/METADATA,sha256=HRUN4b_9Vhwtb2_bKQ-rGCdF2VzqNAMrnW0NyAjc0-8,49682
-iris_pex_embedded_python-2.3.22b3.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-iris_pex_embedded_python-2.3.22b3.dist-info/entry_points.txt,sha256=atkAtHoIuwXcZ0jl5gwof0l__ru_lt8WhVYk6HxYf70,47
-iris_pex_embedded_python-2.3.22b3.dist-info/top_level.txt,sha256=Tl4ZHgeNefaZW2Oug30vSldhD-tWzixsIfzASBrZ9ps,43
-iris_pex_embedded_python-2.3.22b3.dist-info/RECORD,,
+iris_pex_embedded_python-2.3.23b2.dist-info/LICENSE,sha256=rZSiBFId_sfbJ6RL0GjjPX-InNLkNS9ou7eQsikciI8,1089
+iris_pex_embedded_python-2.3.23b2.dist-info/METADATA,sha256=i4jd-lv7DrBSOBzsc01noZTT-lszckwRwEG4DFy312Y,49682
+iris_pex_embedded_python-2.3.23b2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+iris_pex_embedded_python-2.3.23b2.dist-info/entry_points.txt,sha256=atkAtHoIuwXcZ0jl5gwof0l__ru_lt8WhVYk6HxYf70,47
+iris_pex_embedded_python-2.3.23b2.dist-info/top_level.txt,sha256=Tl4ZHgeNefaZW2Oug30vSldhD-tWzixsIfzASBrZ9ps,43
+iris_pex_embedded_python-2.3.23b2.dist-info/RECORD,,