iris-pex-embedded-python 2.3.16__py3-none-any.whl → 2.3.18__py3-none-any.whl

grongier/pex/data/PEX/Utils.cls

@@ -0,0 +1,413 @@
+/* Copyright (c) 2021 by InterSystems Corporation.
+   Cambridge, Massachusetts, U.S.A.  All rights reserved.
+   Confidential property of InterSystems Corporation. */
+
+Include Ensemble
+
+Class Grongier.PEX.Utils Extends %RegisteredObject
+{
+
+ClassMethod dispatchRegisterComponent(
+	pModule As %String,
+	pRemoteClassname As %String,
+	pCLASSPATHS As %String = "",
+	pOverwrite As %Boolean = 0,
+	pProxyClassname As %String = "") As %Status
+{
+	set tSc = $$$OK
+	$$$ThrowOnError(##class(Grongier.PEX.Utils).RegisterComponent(pModule, pRemoteClassname, pCLASSPATHS, pOverwrite , pProxyClassname))
+	return tSc
+}
+
+/// "bo","Duplex","/irisdev/app/src/python/demo/duplex/",1,"Duplex.Duplex"
+ClassMethod RegisterComponent(
+	pModule As %String,
+	pRemoteClassname As %String,
+	pCLASSPATHS As %String = "",
+	pOverwrite As %Boolean = 0,
+	pProxyClassname As %String = "") As %Status
+{
+	#dim tSC As %Status = $$$OK
+	#dim ex As %Exception.AbstractException
+	#dim tLanguage,tExtraClasspaths,tDelimiter,tOnePath As %String = ""
+	#dim tClassDetails,tRemoteSettings As %String = ""
+	#dim tClasspaths As %ListOfDataTypes
+	
+	Quit:(""=pRemoteClassname) $$$ERROR($$$EnsErrGeneral,"Remote Classname must be specified in order to register a Production EXtensions component")
+	Quit:(""=pModule) $$$ERROR($$$EnsErrGeneral,"Must specify the module of the remote code.")
+		
+	Try {
+
+		$$$ThrowOnError(..GetRemoteClassInfo(pRemoteClassname,pModule,pCLASSPATHS,.tClassDetails,.tRemoteSettings))
+
+		Set tConnectionSettings("Classpaths") = pCLASSPATHS
+		Set tConnectionSettings("Module") = pModule
+		Set tConnectionSettings("Classname") = pRemoteClassname
+		Set:(""=pProxyClassname) pProxyClassname = "User."_pRemoteClassname
+		
+		$$$ThrowOnError(..GenerateProxyClass(pProxyClassname,.tConnectionSettings,tClassDetails,tRemoteSettings,pOverwrite))
+
+	} Catch ex {
+		set msg = $System.Status.GetOneStatusText(ex.AsStatus(),1)
+		set tSC = $$$ERROR($$$EnsErrGeneral,msg)
+	}
+
+	Quit tSC
+}
+
+ClassMethod DeleteComponentProxy(pClassname As %String = "") As %Status
+{
+	#dim tSC As %Status = $$$OK
+	#dim ex As %Exception.AbstractException
+	#dim tIsPEX As %Boolean = 0
+	#dim tClass As %Dictionary.CompiledClass
+	
+	Quit:(""=pClassname) $$$ERROR($$$EnsErrGeneral,"Remote class name must be specified.")
+	
+	Try {
+		
+		If '##class(%Dictionary.ClassDefinition).%ExistsId(pClassname) {
+			Set tSC = $$$ERROR($$$EnsErrGeneral,$$$FormatText("No proxy class defined for remote class '%1'.",pClassname))
+			Quit
+		}
+		If $classmethod(pClassname,"%Extends","Grongier.PEX.Common") {
+			Set tClass = ##class(%Dictionary.CompiledClass).%OpenId(pClassname,,.tSC)
+			Quit:$$$ISERR(tSC)
+			If '$IsObject(tClass) {
+				Set tSC = $$$ERROR($$$EnsErrGeneral,$$$FormatText("Proxy class for remote class '%1' could not be opened.",pClassname))
+				Quit
+			}
+			Set tIsPEX = ("Grongier.PEX.Utils" = tClass.GeneratedBy)
+		}
+		If tIsPEX {
+			Set tSC = ##class(%Dictionary.ClassDefinition).%DeleteId(pClassname)
+			If $$$ISERR(tSC) {
+				Set tSC = $$$ERROR($$$EnsErrGeneral,$$$FormatText("Unable to delete proxy class for remote class '%1' : '%2'.",pClassname,$System.Status.GetErrorText(tSC)))
+				Quit
+			}
+		} Else {
+			Set tSC = $$$ERROR($$$EnsErrGeneral,$$$FormatText("Cannot delete class '%1' because it is not a PEX proxy class.",pClassname))
+			Quit
+		}
+		
+	} Catch ex {
+		Set tSC = ex.AsStatus()
+	}
+	
+	Quit tSC
+}
+
+// ..GetRemoteClassInfo(pRemoteClassname,pModule,pCLASSPATHS,.tClassDetails,.tRemoteSettings)
+
+ClassMethod GetRemoteClassInfo(
+	pRemoteClassname As %String,
+	pModule As %String,
+	pClasspaths As %String,
+	ByRef pClassDetails,
+	ByRef pRemoteSettings) As %Status [ Internal, Private ]
+{
+	#dim tSC As %Status = $$$OK
+	#dim ex As %Exception.AbstractException
+	#dim tGateway As %External.Gateway
+	#dim tGatewayProxy As %Net.Remote.Object
+	
+	Try {
+		if pClasspaths '="" {
+			set sys = ##class(%SYS.Python).Import("sys")
+			set delimiter = $s($system.Version.GetOS()="Windows":";",1:":")
+			set extraClasspaths = $tr(pClasspaths,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)
+			}
+		}
+		;
+
+		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, pRemoteClassname)
+		set tClass = class."__new__"(class)
+
+
+		If $IsObject(tClass) {
+			#; List of information about the class as a whole - $lb(SuperClass, Description, InfoURL, IconURL, Adapter)
+			Set pClassDetails = tClass."_get_info"()
+			#; List of information about the various properties of the class
+			#; List of lists of form $lb(propName,dataType,defaultVal,required,category,description)
+			Set pRemoteSettings = tClass."_get_properties"()
+		} Else {
+			Set tSC = $$$ERROR($$$EnsErrGeneral,$$$FormatText("Error opening gateway proxy for class '%1'"),pRemoteClassname)
+		}
+	} Catch ex {
+		set msg = $System.Status.GetOneStatusText(ex.AsStatus(),1)
+		set tSC = $$$ERROR($$$EnsErrGeneral,msg)
+	}
+	
+	Quit tSC
+}
+
+/// Set tConnectionSettings("Classpaths") = pCLASSPATHS
+/// Set tConnectionSettings("Module") = pModule
+/// Set tConnectionSettings("Classname") = pRemoteClassname
+/// Set:(""=pProxyClassname) pProxyClassname = pRemoteClassname
+/// 
+/// Set tSC = ..GenerateProxyClass(pProxyClassname,.tConnectionSettings,tClassDetails,tRemoteSettings,pOverwrite)
+/// "bo","Duplex","/irisdev/app/src/python/demo/duplex/",1,"Duplex.Duplex"
+ClassMethod GenerateProxyClass(
+	pClassname As %String,
+	ByRef pConnectionSettings,
+	pClassDetails As %String = "",
+	pRemoteSettings As %String = "",
+	pOverwrite As %Boolean = 0) As %Status [ Internal, Private ]
+{
+	#dim tSC As %Status = $$$OK
+	#dim ex As %Exception.AbstractException
+	
+	Quit:(""=pClassname) $$$ERROR($$$EnsErrGeneral,"Class name must be specified in order to generate a proxy class for this Production EXtensions component")
+	
+	Try {
+
+		If ##class(%Dictionary.ClassDefinition).%ExistsId(pClassname) {
+			If 'pOverwrite {
+				Set tSC = $$$ERROR($$$EnsErrGeneral,$$$FormatText("Proxy class '%1' already exists.",pClassname))
+				Quit
+			} Else {
+				#dim tIsPEX As %Boolean = 0
+				If $classmethod(pClassname,"%Extends","Grongier.PEX.Common") {
+					#dim tClass As %Dictionary.CompiledClass = ##class(%Dictionary.CompiledClass).%OpenId(pClassname)
+					If '$IsObject(tClass) {
+						Set tSC = $$$ERROR($$$EnsErrGeneral,"Class not found")
+						Quit
+					}
+					Set tIsPEX = ("Grongier.PEX.Utils" = tClass.GeneratedBy)
+				}
+				If tIsPEX {
+					Set tSC = ##class(%Dictionary.ClassDefinition).%DeleteId(pClassname)
+					If $$$ISERR(tSC) {
+						Set tSC = $$$ERROR($$$EnsErrGeneral,$$$FormatText("Unable to delete existing proxy class '%1' : '%2'.",pClassname,$System.Status.GetErrorText(tSC)))
+						Quit
+					}
+				} Else {
+					Set tSC = $$$ERROR($$$EnsErrGeneral,$$$FormatText("Cannot overwrite class '%1' because it is not a PEX proxy class.",pClassname))
+					Quit
+				}
+			}
+		}
+		
+		#; create subclass of the ObjectScript Business Host
+		#dim tCOSClass As %Dictionary.ClassDefinition
+		Set tCOSClass = ##class(%Dictionary.ClassDefinition).%New()
+		Set tCOSClass.Name = pClassname
+
+		#dim tSuperClass As %String = pClassDetails."__getitem__"(0)
+		If (""=tSuperClass) {
+			Set tSC = $$$ERROR($$$EnsErrGeneral,"No PEX superclass found.")
+			Quit
+		}
+		If '$Case($P(tSuperClass,".",*),"DuplexProcess":1,"DuplexService":1,"DuplexOperation":1,"InboundAdapter":1,"OutboundAdapter":1,"BusinessService":1,"BusinessProcess":1,"BusinessOperation":1,:0) {
+			Set tSC = $$$ERROR($$$EnsErrGeneral,"Invalid superclass")
+			Quit
+		}
+		Set tSuperClass = "Grongier.PEX."_$P(tSuperClass,".",*)
+		
+		Set tCOSClass.Super = tSuperClass
+		Set tCOSClass.GeneratedBy = $CLASSNAME()
+		Set tCOSClass.ClassVersion = $$$CLASSDEFINITIONVERSION
+		#dim tDescription As %String = pClassDetails."__getitem__"(1)
+		If (""'=tDescription) {
+			Set tCOSClass.Description = $Replace(tDescription,$C(10),$C(13,10))
+		}
+		
+		#; Do not display any of the connection settings
+		#dim tSETTINGSParamValue As %String = "%classname:Python $type,%module:Python $type,%settings:Python $type,%classpaths:Python $type"
+		
+		#; Create the %classname property
+		#dim tPropClassname As %Dictionary.PropertyDefinition = ##class(%Dictionary.PropertyDefinition).%New()
+		Set tPropClassname.Name = "%classname"
+		Set tPropClassname.Type = "%String"
+		Set tPropClassname.InitialExpression = $$$quote(pConnectionSettings("Classname"))
+		Set tPropClassname.Internal = 1
+		Set tSC = tCOSClass.Properties.Insert(tPropClassname)
+		Quit:$$$ISERR(tSC)
+		
+		#; Create the %classpaths property
+		#dim tPropClasspaths As %Dictionary.PropertyDefinition = ##class(%Dictionary.PropertyDefinition).%New()
+		Set tPropClasspaths.Name = "%classpaths"
+		Set tPropClasspaths.Type = "%String"
+		Set tSC = tPropClasspaths.Parameters.SetAt("","MAXLEN")
+		Quit:$$$ISERR(tSC)
+		Set tPropClasspaths.InitialExpression = $$$quote(pConnectionSettings("Classpaths"))
+		Set tPropClasspaths.Description = "One or more Classpaths (separated by '|' character) needed in addition to the ones configured in the Remote Gateway"
+		Set tSC = tCOSClass.Properties.Insert(tPropClasspaths)
+		Quit:$$$ISERR(tSC)
+		
+		#; Create the %module property
+		#dim tPropLanguage As %Dictionary.PropertyDefinition = ##class(%Dictionary.PropertyDefinition).%New()
+		Set tPropLanguage.Name = "%module"
+		Set tPropLanguage.Type = "%String"
+		Set tPropLanguage.Internal = 1
+		Set tPropLanguage.InitialExpression = $$$quote(pConnectionSettings("Module"))
+		Set tSC = tCOSClass.Properties.Insert(tPropLanguage)
+		Quit:$$$ISERR(tSC)
+
+		#; Create other properties
+		#dim tMethod As %Dictionary.MethodDefinition = ##class(%Dictionary.MethodDefinition).%New()
+		Set tMethod.Name = "SetPropertyValues"
+		
+		#dim tCustomProp As %Dictionary.PropertyDefinition
+		#dim tPropInfo,tPropName,tDataType,tDefault,tDesc,tPropCat,tContext As %String
+		#; each remote setting is of form $lb(propName,dataType,defaultVal,required,category,description,editorContext)
+		For i=1:1:$ll(pRemoteSettings) {
+			Set tPropInfo = $lg(pRemoteSettings,i)
+			Continue:""=tPropInfo ; this shouldn't happen, but just in case
+			Set tPropName = $lg(tPropInfo,1)
+			Set tDataType = $lg(tPropInfo,2)
+			If (""=tPropName) || (""=tDataType) {
+				Set tSC = $$$ERROR($$$EnsErrGeneral,"All properties must have a name and datatype defined")
+				Quit
+			}
+			Set tCustomProp = ##class(%Dictionary.PropertyDefinition).%New()
+			Set tCustomProp.Name = tPropName
+			If $Case(tDataType,"String":1,"Integer":1,"Boolean":1,"Numeric":1,:0) {
+				Set tDataType = "%"_tDataType
+			} ElseIf '##class(%Dictionary.ClassDefinition).%ExistsId(tDataType) {
+				Set tDataType = "%String"
+			}
+			Set tCustomProp.Type = tDataType
+			Set tDefault = $lg(tPropInfo,3)
+			If ""'=tDefault {
+				Set tCustomProp.InitialExpression = $$$quote(tDefault)
+			}
+			Set tCustomProp.Required = $lg(tPropInfo,4,0)
+			Set tDesc = $lg(tPropInfo,6)
+			If ""'=tDesc {
+				Set tDesc = $zstrip($Replace(tDesc,$C(10),$C(13,10)),"<>W")
+				Set:$E(tDesc,*-1,*)=$C(13,10) tDesc = $E(tDesc,1,*-2)
+				Set tCustomProp.Description = tDesc
+			}
+			
+			Set tSC = tCOSClass.Properties.Insert(tCustomProp)
+			Quit:$$$ISERR(tSC)
+			
+			Set tPropCat = $lg(tPropInfo,5,"Additional")
+			Set tSETTINGSParamValue = tSETTINGSParamValue_","_tPropName_":"_tPropCat
+			
+			Set tSC = tMethod.Implementation.WriteLine($char(9)_"try {")	Quit:$$$ISERR(tSC)
+			Set tSC = tMethod.Implementation.WriteLine($char(9,9)_"set $property(..%gatewayProxy,"_$$$quote(tPropName)_") = .."_tPropName)	Quit:$$$ISERR(tSC)
+			Set tSC = tMethod.Implementation.WriteLine($char(9)_"} catch ex {")	Quit:$$$ISERR(tSC)
+			Set tSC = tMethod.Implementation.WriteLine($char(9,9)_"$$$LOGWARNING(ex.DisplayString())")	Quit:$$$ISERR(tSC)
+			Set tSC = tMethod.Implementation.WriteLine($char(9)_"}")	Quit:$$$ISERR(tSC)
+		}
+		
+		If $Case(tSuperClass,"Grongier.PEX.BusinessService":1,"Grongier.PEX.BusinessOperation":1,"Grongier.PEX.DuplexService":1,"Grongier.PEX.DuplexOperation":1,:0) {
+			set builtins = ##class(%SYS.Python).Import("builtins")
+			If (builtins.len(pClassDetails)>4) { //Adaptor
+
+				#dim tAdapterClass = pClassDetails."__getitem__"(4)
+				#; May want to issue a warning in the UI if the Adapter class does not exist
+				#; but we don't check here because it does compile and may just be that the user is registering the Service/Operation before the Adapter
+				#dim tADAPTERParam As %Dictionary.ParameterDefinition = ##class(%Dictionary.ParameterDefinition).%New()
+				Set tADAPTERParam.Name = "ADAPTER"
+				Set tADAPTERParam.Default = tAdapterClass
+				Set tSC = tCOSClass.Parameters.Insert(tADAPTERParam)
+				Quit:$$$ISERR(tSC)
+			}
+		}
+
+		set type = ""
+		set:($Case(tSuperClass,"Grongier.PEX.InboundAdapter":1,"Grongier.PEX.OutboundAdapter":1,:0)) type = "Adapter"
+		set tSETTINGSParamValue = $REPLACE(tSETTINGSParamValue,"$type",type)
+		
+		#dim tSETTINGSParam As %Dictionary.ParameterDefinition = ##class(%Dictionary.ParameterDefinition).%New()
+		Set tSETTINGSParam.Name = "SETTINGS"
+		Set tSETTINGSParam.Default = tSETTINGSParamValue
+		Set tSC = tCOSClass.Parameters.Insert(tSETTINGSParam)
+		Quit:$$$ISERR(tSC)
+		
+		Set tSC = tCOSClass.%Save()
+		Quit:$$$ISERR(tSC)
+		
+		Set tSC = $System.OBJ.Compile(pClassname,"-d")
+		
+	} Catch ex {
+		Set tSC = ex.AsStatus()
+	}
+	
+	Quit tSC
+}
+
+ClassMethod CreateProduction(
+	package As %String = "test",
+	name As %String = "AutoCreatedProduction",
+	xdata As %CharacterStream) As %Status
+{
+  #Dim produtionClassName As %String = package _ "." _ name
+  If ('$ZName(produtionClassName, 4))
+  {
+  Return $System.Status.Error(5001, "Invalid Production package or name.")
+  }
+  #Dim productionDefinition As %Dictionary.ClassDefinition
+  // Check if the production already exists
+  If (##class(%Dictionary.ClassDefinition).%ExistsId(produtionClassName))
+  {
+	// Open the production
+	set productionDefinition = ##class(%Dictionary.ClassDefinition).%OpenId(produtionClassName)
+  }
+  Else
+  {
+	// Create the production definition
+    set productionDefinition = ##Class(%Dictionary.ClassDefinition).%New()
+  }
+  //
+  Set productionDefinition.Name         = produtionClassName
+  Set productionDefinition.Super        = "Ens.Production"
+  Set productionDefinition.ClassVersion = 25
+  //
+  // Check if the XData Definition already exists
+  If (##Class(%Dictionary.XDataDefinition).%ExistsId(produtionClassName_"||ProductionDefinition"))
+  {
+	// delete the XData Definition
+	$$$ThrowOnError(##Class(%Dictionary.XDataDefinition).%DeleteId(produtionClassName_"||ProductionDefinition"))
+  }
+  #Dim xdataDefinition As %Dictionary.XDataDefinition = ##Class(%Dictionary.XDataDefinition).%New()
+  //
+  Set xdataDefinition.Name = "ProductionDefinition"
+  //
+  Do xdataDefinition.Data.CopyFrom(xdata)
+  //
+  // Insert XData Definition into Production Definition
+  Do productionDefinition.XDatas.Insert(xdataDefinition)
+  //
+  #Dim statusCode As %Status = productionDefinition.%Save()
+  //
+  If ($System.Status.IsError(statusCode))
+  {
+  Return statusCode
+  }
+  // Compile the production class
+  return $System.OBJ.Compile(produtionClassName,"k-d")
+}
+
+/// Export a production to an XML string
+ClassMethod ExportProduction(pProductionName As %String) As %String
+{
+	Set sc = $$$OK
+	set xdata = ""
+	// Check if the XData Definition exists
+	If (##Class(%Dictionary.XDataDefinition).%ExistsId(pProductionName_"||ProductionDefinition"))
+	{
+		// Open the XData Definition
+		Set xdataDefinition = ##Class(%Dictionary.XDataDefinition).%OpenId(pProductionName_"||ProductionDefinition")
+		Set xdata = xdataDefinition.Data
+	}
+	Else
+	{
+		$$$ThrowOnError($System.Status.Error(5001, "Production does not exist."))
+	}
+	Return xdata
+}
+
+}

intersystems_iris/_BufferReader.py

@@ -0,0 +1,10 @@
+import intersystems_iris._ListReader
+
+class _BufferReader(intersystems_iris._ListReader._ListReader):
+    
+    def __init__(self, header, buffer, locale):
+        self.header = header
+        super().__init__(buffer, locale)
+
+    def _get_header_count(self):
+        return self.header._get_count()

intersystems_iris/_BufferWriter.py

@@ -0,0 +1,32 @@
+import intersystems_iris._ListWriter
+import intersystems_iris._MessageHeader
+
+class _BufferWriter(intersystems_iris._ListWriter._ListWriter):
+
+    def __init__(self, locale, is_unicode, compact_double):
+        super().__init__(locale, is_unicode, compact_double)
+        self.offset = intersystems_iris._MessageHeader._MessageHeader.HEADER_SIZE
+
+    def _write_header(self, function_code):
+        self.buffer[12] = function_code[0]
+        self.buffer[13] = function_code[1]
+        self.offset = intersystems_iris._MessageHeader._MessageHeader.HEADER_SIZE
+
+    def _write_header_sysio(self, sysio_code):
+        code_int = sysio_code + 49728
+        code_bytes = code_int.to_bytes(2, 'little')
+        self.buffer[12] = code_bytes[0]
+        self.buffer[13] = code_bytes[1]
+        self.offset = intersystems_iris._MessageHeader._MessageHeader.HEADER_SIZE
+
+    def _set_connection_info(self, connection_info):
+        self._locale = connection_info._locale
+        self._is_unicode = connection_info._is_unicode
+        self._compact_double = connection_info._compact_double
+
+    def _get_header_buffer(self):
+        return self.buffer[0:intersystems_iris._MessageHeader._MessageHeader.HEADER_SIZE]
+
+    def _get_data_buffer(self):
+        return self.buffer[intersystems_iris._MessageHeader._MessageHeader.HEADER_SIZE:self.offset]
+

intersystems_iris/_ConnectionInformation.py

@@ -0,0 +1,54 @@
+import intersystems_iris._Constant
+
+class _ConnectionInformation(object):
+
+    def __init__(self):
+        self.protocol_version = intersystems_iris._Constant._Constant.PROTOCOL_VERSION
+        self._is_unicode = True
+        self._compact_double = False
+        self._locale = "latin-1"
+        self._delimited_ids = 0
+        self._server_version = ""
+        self._server_version_major = 0
+        self._server_version_minor = 0
+        self._iris_install_dir = ""
+        self._server_job_number = -1
+
+    def _set_server_locale(self, locale):
+        self._locale = self._map_server_locale(locale)
+
+    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 self._server_version.find("Version") > 0:
+            version = server_version[server_version.find("Version")+8:]
+            self._server_version_major = version.split(".")[0]
+            self._server_version_minor = version.split(".")[1]
+        return
+
+    @staticmethod
+    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", 
+            "UNICODE": "utf-8",
+        }
+        return _locales[locale.upper()] if locale.upper() in _locales else locale
+
+

intersystems_iris/_ConnectionParameters.py

@@ -0,0 +1,18 @@
+class _ConnectionParameters(object):
+    """_ConnectionParameters represents the properties that are implicit to a URL."""
+    def __init__(self):
+        self.hostname = None
+        self.port = None
+        self.namespace = None
+        self.timeout = None
+        self.sharedmemory = False
+        self.logfile = None
+        self.sslcontext = None
+        self.isolationLevel = None
+        self.featureOptions = None
+
+    def _set_sharedmemory(self, sharedmemory):
+        self.sharedmemory = sharedmemory
+
+    def _get_sharedmemory(self):
+        return self.sharedmemory

intersystems_iris/_Constant.py

@@ -0,0 +1,38 @@
+class _Constant():
+
+    PROTOCOL_VERSION = 65
+
+    # Message function code
+    MESSAGE_CONNECT = b'Y0'
+    MESSAGE_DISCONNECT = b'Y4'
+    MESSAGE_SHUTDOWN = b'Y6'
+    MESSAGE_PING = b'YQ'
+    MESSAGE_BENCHMARK_ECHO = b'YY'
+    MESSAGE_LOAD_MODULES = b'YP'
+    MESSAGE_DYNAMIC_EXECUTE_CONSTRUCTOR = b'YA'
+    MESSAGE_DYNAMIC_EXECUTE_METHOD = b'YU'
+    MESSAGE_DYNAMIC_EXECUTE_GET = b'YV'
+    MESSAGE_DYNAMIC_EXECUTE_SET = b'YB'
+    MESSAGE_CREATE_OBJECT = b'Y9'
+    MESSAGE_EXCEPTION_RAISED = b'Y5'
+    MESSAGE_GET_LIST = b'YG'
+    MESSAGE_GET_STREAM = b'YH'
+
+    @staticmethod
+    def __convert(code):
+        return code[0]*256+code[1]-22832
+
+    ENUM_MESSAGE_PASSPHRASE = -48
+    ENUM_MESSAGE_CONNECT = __convert.__func__(MESSAGE_CONNECT)
+    ENUM_MESSAGE_DISCONNECT = __convert.__func__(MESSAGE_DISCONNECT)
+    ENUM_MESSAGE_SHUTDOWN = __convert.__func__(MESSAGE_SHUTDOWN)
+    ENUM_MESSAGE_PING = __convert.__func__(MESSAGE_PING)
+    ENUM_MESSAGE_BENCHMARK_ECHO = __convert.__func__(MESSAGE_BENCHMARK_ECHO)
+    ENUM_MESSAGE_LOAD_MODULES = __convert.__func__(MESSAGE_LOAD_MODULES)
+    ENUM_MESSAGE_DYNAMIC_EXECUTE_CONSTRUCTOR = __convert.__func__(MESSAGE_DYNAMIC_EXECUTE_CONSTRUCTOR)
+    ENUM_MESSAGE_DYNAMIC_EXECUTE_METHOD = __convert.__func__(MESSAGE_DYNAMIC_EXECUTE_METHOD)
+    ENUM_MESSAGE_DYNAMIC_EXECUTE_GET = __convert.__func__(MESSAGE_DYNAMIC_EXECUTE_GET)
+    ENUM_MESSAGE_DYNAMIC_EXECUTE_SET = __convert.__func__(MESSAGE_DYNAMIC_EXECUTE_SET)
+
+    # IRISNative messages
+