iris-pex-embedded-python 2.3.22b3__tar.gz → 2.3.23b2__tar.gz

{iris_pex_embedded_python-2.3.22b3 → iris_pex_embedded_python-2.3.23b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iris_pex_embedded_python
-Version: 2.3.22b3
+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 → iris_pex_embedded_python-2.3.23b2}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "iris_pex_embedded_python"
-version = "2.3.22b3"
+version = "2.3.23b2"
 description = "Iris Interoperability based on Embedded Python"
 readme = "README.md"
 authors = [

iris_pex_embedded_python-2.3.23b2/src/grongier/cls/Grongier/Service/WSGI.cls

@@ -0,0 +1,310 @@
+Class Grongier.Service.WSGI Extends %CSP.REST [ ServerOnly = 1 ]
+{
+
+Parameter CLASSPATHS;
+
+Parameter MODULENAME;
+
+Parameter APPNAME;
+
+Parameter DEVMODE = 1;
+
+/// This method matches the request and method and calls the dispatcher
+ClassMethod Page(skipheader As %Boolean = 0) As %Status [ ProcedureBlock = 1 ]
+{
+    #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 {
+
+        #; Ensure that we honor the requested charset 
+        Set %response.CharSet=..#CHARSET
+
+        #; Ensure that we honor the requested CONTENTTYPE
+        If ..#CONTENTTYPE'="" Set %response.ContentType=..#CONTENTTYPE 
+
+        #; 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")
+
+            #; Switch device redirection on (may already be on but thats ok)
+            Do ##class(%Library.Device).ReDirectIO(1)
+        }
+
+        #; 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
+
+        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
+}
+
+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
+}
+
+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("")
+
+           // 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{
+
+            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
+            }
+           }
+
+           // 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)
+           }
+
+           //Have to set up a correct wsgi.input stream from %request
+           Set stream = %request.Content
+           
+           Set contentType = %request.ContentType
+           Set contentLength = 0
+
+           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()
+
+            Do stream.Write($CHAR(13,10))
+
+            //Get the Form Data values
+
+            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)
+		}
+
+		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
+}
+
+}

iris_pex_embedded_python-2.3.23b2/src/grongier/pex/wsgi/handlers.py

@@ -0,0 +1,104 @@
+import os, sys, importlib, urllib.parse
+from io import BytesIO
+
+__ospath = os.getcwd()
+
+import iris
+
+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
+
+    rest_service._SetStatusCode(status)
+    for tuple in response_headers:
+        rest_service._SetHeader(tuple[0], tuple[1])
+    return write
+
+
+# Make request to application
+def make_request(environ, stream, application, path):
+
+    # Change the working directory for logging purposes
+    goto_manager_dir()
+
+    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
+
+    #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
+
+
+    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)
+
+    error_log_file.close()
+
+    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()

{iris_pex_embedded_python-2.3.22b3 → iris_pex_embedded_python-2.3.23b2}/src/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,
 }

{iris_pex_embedded_python-2.3.22b3 → iris_pex_embedded_python-2.3.23b2}/src/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):

{iris_pex_embedded_python-2.3.22b3 → iris_pex_embedded_python-2.3.23b2}/src/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):

{iris_pex_embedded_python-2.3.22b3 → iris_pex_embedded_python-2.3.23b2}/src/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,

{iris_pex_embedded_python-2.3.22b3 → iris_pex_embedded_python-2.3.23b2}/src/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)