iris-pex-embedded-python 2.3.23b1__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()

{iris_pex_embedded_python-2.3.23b1.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.23b1
+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.23b1.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,7 +35,7 @@ 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
@@ -105,9 +105,9 @@ 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.23b1.dist-info/LICENSE,sha256=rZSiBFId_sfbJ6RL0GjjPX-InNLkNS9ou7eQsikciI8,1089
-iris_pex_embedded_python-2.3.23b1.dist-info/METADATA,sha256=cxfW_t8_wmtYVXOfaxJjJUuC5eL_EFwhEmji6lP_ySI,49682
-iris_pex_embedded_python-2.3.23b1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-iris_pex_embedded_python-2.3.23b1.dist-info/entry_points.txt,sha256=atkAtHoIuwXcZ0jl5gwof0l__ru_lt8WhVYk6HxYf70,47
-iris_pex_embedded_python-2.3.23b1.dist-info/top_level.txt,sha256=Tl4ZHgeNefaZW2Oug30vSldhD-tWzixsIfzASBrZ9ps,43
-iris_pex_embedded_python-2.3.23b1.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,,