iris-pex-embedded-python 3.1.6b2__py3-none-any.whl → 3.2.0__py3-none-any.whl

iop/_utils.py

@@ -6,6 +6,8 @@ import inspect
 import xmltodict
 import pkg_resources
 import importlib
+import json
+from dc_schema import get_schema
 
 class _Utils():
     @staticmethod
@@ -33,6 +35,33 @@ class _Utils():
         if path:
             _Utils.raise_on_error(iris.cls('%SYSTEM.OBJ').LoadDir(path,'cubk',"*.cls",1))
 
+    @staticmethod
+    def register_message_schema(cls):
+        """
+        It takes a class and registers the schema
+        
+        :param cls: The class to register
+        """
+        schema = get_schema(cls)
+        schema_name = cls.__module__ + '.' + cls.__name__
+        schema_str = json.dumps(schema)
+        categories = schema_name
+        _Utils.register_schema(schema_name,schema_str,categories)
+
+    @staticmethod
+    def register_schema(schema_name:str, schema_str:str,categories:str):
+        """
+        It takes a schema name, a schema string, and a category string, and registers the schema
+        
+        :param schema_name: The name of the schema
+        :type schema_name: str
+        :param schema_str: The schema as a string
+        :type schema_str: str
+        :param categories: The categories of the schema
+        :type categories: str
+        """
+        _Utils.raise_on_error(iris.cls('IOP.Message.JSONSchema').Import(schema_str,categories,schema_name))
+
     @staticmethod
     def register_component(module:str,classname:str,path:str,overwrite:int=1,iris_classname:str='Python'):
         """
@@ -128,7 +157,7 @@ class _Utils():
                         extend = klass.bases[0].id
                     else:
                         extend = klass.bases[0].attr
-                if  extend in ('BusinessOperation','BusinessProcess','BusinessService','DuplexService','DuplexProcess','DuplexOperation','InboundAdapter','OutboundAdapter'):
+                if extend in ('BusinessOperation','BusinessProcess','BusinessService','DuplexService','DuplexProcess','DuplexOperation','InboundAdapter','OutboundAdapter'):
                     module = _Utils.filename_to_module(filename)
                     iris_class_name = f"{iris_package_name}.{module}.{klass.name}"
                     # strip "_" for iris class name
@@ -188,6 +217,8 @@ class _Utils():
                 list of dictionaries:
                 * key: the name of the production
                 * value: a dictionary containing the settings for the production
+            * SCHEMAS
+                List of classes
         """
         path = None
         # try to load the settings file
@@ -216,6 +247,12 @@ class _Utils():
             _Utils.set_productions_settings(settings.PRODUCTIONS,path)
         except AttributeError:
             print("No productions to register")
+        try:
+            # set the schemas
+            for cls in settings.SCHEMAS:
+                _Utils.register_message_schema(cls)
+        except AttributeError:
+            print("No schemas to register")
         try:
             sys.path.remove(path)
         except ValueError:

iop/cls/IOP/Message/JSONSchema.cls

@@ -0,0 +1,125 @@
+Class IOP.Message.JSONSchema Extends %Persistent
+{
+
+Property Name As %String;
+
+Property Category As %String;
+
+Property JSONSchema As %String(MAXLEN = "");
+
+Index NameIndex On Name [ IdKey, Unique ];
+
+/// Import a JSON Schema from file
+ClassMethod ImportFromFile(
+	pFileName As %String,
+	pCategory As %String = "",
+	pName As %String) As %Status
+{
+    Set pStatus = $$$OK
+    Try {
+        If '##class(%File).Exists(pFileName) {
+            Set pStatus = $$$ERROR($$$GeneralError, "File not found")
+            Return pStatus
+        }
+        Set tFile = ##class(%File).%New(pFileName)
+        $$$ThrowOnError(tFile.Open("R"))
+        Set tSchema = ""
+        While 'tFile.AtEnd {
+            Set tSchema = tSchema _ tFile.ReadLine()
+        }
+        Set pStatus = ..Import(tSchema, pCategory, pName)
+    } Catch ex {
+        Set pStatus = ex.AsStatus()
+    }
+    Return pStatus
+}
+
+/// Store the JSON Schema in this object
+ClassMethod Import(
+	pSchema As %String,
+	pCategory As %String = "",
+	pName As %String) As %Status
+{
+    Set pStatus = $$$OK
+    Try {
+        if ##class(IOP.Message.JSONSchema).%ExistsId(pName) {
+            Set tThis = ##class(IOP.Message.JSONSchema).%OpenId(pName)
+            Set tThis.Category = pCategory
+            Set tThis.JSONSchema = pSchema
+            $$$ThrowOnError(tThis.%Save())
+        } Else {
+            Set tThis = ##class(IOP.Message.JSONSchema).%New()
+            Set tThis.Name = pName
+            Set tThis.Category = pCategory
+            Set tThis.JSONSchema = pSchema
+            $$$ThrowOnError(tThis.%Save())
+        }
+    } Catch ex {
+        Set pStatus = ex.AsStatus()
+    }
+    Quit pStatus
+}
+
+/// Get a stored schema by category and name
+ClassMethod GetSchema(
+	pName As %String = "",
+	Output pSchema As %String) As %Status
+{
+    Set pStatus = $$$OK
+    Try {
+        Set tSql = "SELECT JSONSchema FROM IOP_Message.JSONSchema WHERE Name = ?"
+        Set tStatement = ##class(%SQL.Statement).%New()
+        Do tStatement.%Prepare(tSql)
+        set rs = tStatement.%Execute(pName)
+        If rs.%Next() {
+            Set pSchema = rs.%Get("JSONSchema")
+        } Else {
+            Set pStatus = $$$ERROR($$$GeneralError, "Schema not found")
+        }
+    } Catch ex {
+        Set pStatus = ex.AsStatus()
+    }
+    Return pStatus
+}
+
+/// Validate JSON data against a stored schema
+ClassMethod ValidateJSONSchema(
+	pJSON As %String,
+	pName As %String) As %Status
+{
+    Set tSC = $$$OK
+    Try {
+        Set tSchema = ""
+        Set tSC = ..GetSchema(pName, .tSchema)
+        If $$$ISERR(tSC) Return tSC
+        // Validate JSON data against schema
+        // To be implemented
+        Set tSC = $$$OK
+    } Catch ex {
+        Set tSC = ex.AsStatus()
+    }
+    Return tSC
+}
+
+Storage Default
+{
+<Data name="JSONSchemaDefaultData">
+<Value name="1">
+<Value>%%CLASSNAME</Value>
+</Value>
+<Value name="2">
+<Value>JSONSchema</Value>
+</Value>
+<Value name="3">
+<Value>Category</Value>
+</Value>
+</Data>
+<DataLocation>^IOP.Message.JSONSchemaD</DataLocation>
+<DefaultData>JSONSchemaDefaultData</DefaultData>
+<IdLocation>^IOP.Message.JSONSchemaD</IdLocation>
+<IndexLocation>^IOP.Message.JSONSchemaI</IndexLocation>
+<StreamLocation>^IOP.Message.JSONSchemaS</StreamLocation>
+<Type>%Storage.Persistent</Type>
+}
+
+}

iop/cls/IOP/Message.cls

@@ -1,6 +1,12 @@
-Class IOP.Message Extends (Ens.MessageBody, %CSP.Page, %XML.Adaptor)
+Class IOP.Message Extends (Ens.MessageBody, %CSP.Page, Ens.VDoc.Interface)
 {
 
+Parameter DOCCLASSNAME = "JSON Document";
+
+Parameter DOCCLASSFULLNAME = "JSON Virtual Document";
+
+Parameter DOCSHORTNAME = "JSON";
+
 Parameter BUFFER = 1000000;
 
 Property buffer As %String(MAXLEN = "") [ Calculated, Transient ];
@@ -21,6 +27,511 @@ Property jstr As %Stream.GlobalCharacter [ Internal, Private ];
 
 Property type As %String(MAXLEN = 6) [ ReadOnly ];
 
+/// Gets the next index in an array
+Method GetNextIndex(
+	pPath As %String,
+	pIndex As %String,
+	ByRef pStatus As %Status = {$$$OK}) As %String
+{
+    Set f=$F(pPath,"()")  If 'f Set pStatus=$$$ERROR($$$EnsErrGeneral,"Can't iterate on no-array type '"_pPath_"'") Quit ""
+    if pIndex="" Set pIndex=0
+    Set tValue = ..GetValueAt($EXTRACT(pPath, 1, $LENGTH(pPath)-2))
+    Set builtins = ##class(%SYS.Python).Builtins()
+    if pIndex>=builtins.len(tValue) Quit ""
+    Quit pIndex+1
+}
+
+Method GetValueAt(
+	pPropertyPath As %String = "",
+	pFormat As %String,
+	Output pStatus As %Status,
+	pDummy As %Boolean) As %String
+{
+    Set pStatus = $$$OK
+    Try {
+        // Handle standard path queries
+        If pPropertyPath = "" Return ""
+        
+        // pPropertyPath is formatted as :
+        // 1. "property1.property2.property3" for nested properties
+        // 2. "property1()" for all elements of an array or property1(*)
+        // 3. "property1(index).property2" for nested properties within an array
+        // 4. "property1(index)" for a specific element of an array
+
+        // Convert pPropertyPath to a a jsonpath
+        Set tPath = ..ConvertPath(pPropertyPath)
+
+        Set pyjson = ##class(%SYS.Python).Import("json")
+        Set jp = ##class(%SYS.Python).Import("jsonpath_ng")
+        Set builtins = ##class(%SYS.Python).Builtins()
+
+		Set tJSON = pyjson.loads(..json)
+        Set parser = jp.parse(tPath)
+        Set matches = parser.find(tJSON)
+
+        Set tResult = ""
+        // Return the first match
+        if matches."__len__"() = 1 {
+            Set match = matches."__getitem__"(0)
+            Set tResult = match."value"
+        }
+        ElseIf matches."__len__"() > 1 {
+            Set tResult = builtins.list()
+            For i=0:1:matches."__len__"()-1 {
+                Set match = matches."__getitem__"(i)
+                Do tResult.append(match."value")
+            }
+        }
+
+        Return tResult
+
+    } Catch ex {
+        Set pStatus = ex.AsStatus()
+        Return ""
+    }
+}
+
+ClassMethod ConvertPath(pPropertyPath As %String) As %String
+{
+    // Convert pPropertyPath to a jsonpath just by replacing 
+    // - '()' with '[*]'
+    // - '(index)' with '[index]'
+    // - '(' with '[' and ')' with ']'
+    // - if index is an integer, replace it with [index-1]
+    Set tPath = pPropertyPath
+    Set tPath = $Replace(tPath, "()", "[*]")
+    Set tPath = $Replace(tPath, "(", "[")
+    Set tPath = $Replace(tPath, ")", "]")
+    // Process each [] occurrence in the path
+    Set tPath = ..ProcessBrackets(tPath)
+
+    Return tPath
+}
+
+ClassMethod ProcessBrackets(pPath As %String) As %String
+{
+    Set tPath = pPath
+    Set start = $Find(tPath, "[")
+    While start {
+        Set end = $Find(tPath, "]", start)
+        If 'end Quit  // No matching closing bracket
+        
+        // Extract the index between [ and ]
+        Set tIndex = $Extract(tPath, start, end-2)
+        
+        // If index is numeric, decrease by 1 (0-based indexing)
+        If +tIndex {
+            Set newPath = $Extract(tPath, 1, start-1)
+            Set newPath = newPath _ (tIndex-1)
+            Set newPath = newPath _ $Extract(tPath, end-1, *)
+            Set tPath = newPath
+        }
+        
+        // Move past this [] pair for next iteration
+        Set start = $Find(tPath, "[", end)
+    }
+    Return tPath
+}
+
+Method CopyValues(
+	pSource As Ens.VDoc.Interface,
+	pSourcePath As %String,
+	pTargetPath As %String,
+	pAction As %String,
+	pKey As %String,
+	pEmptyFieldAsNull As %Boolean = 0,
+	pIgnoreMissingSource As %Boolean = 0,
+	pGenerateEmptySegments As %Boolean = 0) As %Status
+{
+    Set tSC = $$$OK
+    Try {
+        // Get source value
+        Set tValue = pSource.GetValueAt(pSourcePath, "String", .tSC, 0)
+        Return:$$$ISERR(tSC) tSC
+
+        // Set target value
+        Set tSC = ..SetValueAt(tValue, pTargetPath, pAction, pKey)
+    } Catch ex {
+        Set tSC = ex.AsStatus()
+    }
+    Return tSC
+}
+
+/// Sets a value at the specified property path in the JSON document
+/// @param pValue Value to set
+/// @param pPropertyPath Path to the property (e.g. "property1.property2" or "array()")
+/// @param pAction Action to perform ("set", "append", "remove", "insert")
+/// @param pKey Optional key for specialized operations, required for insert
+/// @returns %Status
+Method SetValueAt(
+	pValue As %String = "",
+	pPropertyPath As %String = "",
+	pAction As %String = "set",
+	pKey As %String = "") As %Status
+{
+    Set tSC = $$$OK
+    Try {
+        // Validate input parameters
+        If pPropertyPath = "" Return $$$ERROR($$$GeneralError, "Property path cannot be empty")
+        If '$LISTFIND($LISTBUILD("set","append","remove","insert"), pAction) Return $$$ERROR($$$GeneralError, "Invalid action: "_pAction)
+        If (pAction = "insert") && (pKey = "") Return $$$ERROR($$$GeneralError, "Key is required for insert action")
+
+        // Initialize Python objects
+        Set pyjson = ##class(%SYS.Python).Import("json")
+        Set jp = ##class(%SYS.Python).Import("jsonpath_ng")
+        Set builtins = ##class(%SYS.Python).Builtins()
+
+        // Handle append operations
+        Set tAppend = (pAction = "append")
+        If tAppend, $EXTRACT(pPropertyPath, *-1, *) = "()" {
+            Set pPropertyPath = $EXTRACT(pPropertyPath, 1, *-2)
+        }
+
+        // Initialize empty JSON if needed
+        Set:..json="" ..json = "{}"
+        
+        // Parse JSON and prepare path
+        Set tJSON = pyjson.loads(..json)
+        Set tPath = ..ConvertPath(pPropertyPath)
+        Set parser = jp.parse(tPath)
+
+        If pAction = "set" {
+            // Simple set operation
+            Set tJSON = parser."update_or_create"(tJSON, pValue)
+        }
+        ElseIf pAction = "remove" {
+            // Remove operation
+            Set matches = parser.find(tJSON)
+            If matches."__len__"() > 0 {
+                // Not yet implemented
+                Set tSC = $$$ERROR($$$GeneralError, "Remove operation not yet implemented")
+            }
+        }
+        ElseIf pAction = "insert" {
+            // Handle dictionary insert/update
+            Set matches = parser.find(tJSON)
+            If matches."__len__"() = 0 {
+                // Create new dictionary if path doesn't exist
+                Set tDict = builtins.dict()
+                Do tDict."__setitem__"(pKey, pValue)
+                Set tJSON = parser."update_or_create"(tJSON, tDict)
+            }
+            Else {
+                // Update existing dictionary
+                Set tDict = matches."__getitem__"(0)."value"
+                Do tDict."__setitem__"(pKey, pValue)
+                Set tJSON = parser."update"(tJSON, tDict)
+            }
+        }
+        ElseIf tAppend {
+            // Handle append operation
+            Set tFindValue = parser."find"(tJSON)
+            If tFindValue."__len__"() = 0 {
+                // Create new array if path doesn't exist
+                Set:(tAppend) tValue = builtins.list()
+                Do:tAppend tValue.append(pValue)
+                Set tJSON = parser."update_or_create"(tJSON, $Select(tAppend: tValue, 1: pValue))
+            }
+            Else {
+                // Append to existing array
+                Do tFindValue."__getitem__"(0)."value".append(pValue)
+                Set tJSON = parser."update"(tJSON, tFindValue."__getitem__"(0)."value")
+            }
+        }
+
+        // Update JSON storage
+        Set ..json = pyjson.dumps(tJSON)
+        Set ..classname = ..DocType
+
+    }
+    Catch ex {
+        Set tSC = ex.AsStatus()
+        // Log error details
+        $$$LOGWARNING("Error in SetValueAt: "_$System.Status.GetErrorText(tSC))
+    }
+    
+    Return tSC
+}
+
+Method IsValid() As %Status
+{
+    Return $$$OK
+}
+
+Method Validate(pValidationSpec As %String = "") As %Status
+{
+    If ..DocType = "" Return $$$ERROR($$$GeneralError, "No DocType specified")
+    
+    // Validate against stored schema
+    Return ##class(IOP.Message.JSONSchema).ValidateJSON(tJSON, ..DocTypeCategory, ..DocTypeName)
+}
+
+Method ParentMany(Output pParentsList) As %Integer
+{
+    Return 0
+}
+
+/// Returns a list of available DocTypes by querying the JSONSchema storage.
+Query EnumerateDocTypes(
+	Category As %String = "",
+	IncludeBase As %Boolean = 0) As %Query(CONTAINID = 0, ROWSPEC = "Type:%String")
+{
+}
+
+ClassMethod EnumerateDocTypesExecute(
+	ByRef qHandle As %Binary,
+	pName As %String = "",
+	IncludeBase As %Boolean) As %Status
+{
+    Kill qHandle
+    Set qHandle = 0
+    Set sql = "SELECT Name FROM IOP_Message.JSONSchema"
+    If pName '= "" {
+        Set sql = sql _ " WHERE Name = ?"
+    }
+
+    Set stmt = ##class(%SQL.Statement).%New()
+    Set tSC = stmt.%Prepare(sql)
+    Quit:$$$ISERR(tSC) tSC
+
+    If pName '= "" {
+        Set rs = stmt.%Execute(pName)
+    } Else {
+        Set rs = stmt.%Execute()
+    }
+    While rs.%Next() {
+        Set qHandle($I(qHandle)) = rs.%Get("Name")
+    }
+    set qHandle = 0
+    Quit $$$OK
+}
+
+ClassMethod EnumerateDocTypesFetch(
+	ByRef qHandle As %Binary,
+	ByRef qRow As %List,
+	ByRef AtEnd As %Integer = 0) As %Status
+{
+    Set qHandle = $O(qHandle(qHandle))
+    If qHandle = "" {
+        Set qRow = "", AtEnd = 1
+        Quit $$$OK
+    }
+    Set qRow = $LB(qHandle(qHandle))
+    Quit $$$OK
+}
+
+ClassMethod EnumerateDocTypesClose(ByRef qHandle As %Binary) As %Status
+{
+    Kill qHandle
+    Quit $$$OK
+}
+
+/// Returns a list of schema categories from the JSONSchema storage.
+Query EnumerateTypeCategories(Standard As %String = "") As %Query(CONTAINID = 0, ROWSPEC = "Category:%String,Description:%String,IsStandard:%Boolean,Base:%String")
+{
+}
+
+ClassMethod EnumerateTypeCategoriesExecute(
+	ByRef qHandle As %Binary,
+	pStandard As %String = "") As %Status
+{
+    Kill qHandle
+    Set qHandle = 0
+    Set sql = "SELECT Category, Name FROM IOP_Message.JSONSchema"
+
+    Set stmt = ##class(%SQL.Statement).%New()
+    Set tSC = stmt.%Prepare(sql)
+    Quit:$$$ISERR(tSC) tSC
+
+    Set rs = stmt.%Execute()
+
+    While rs.%Next() {
+        Set category = rs.%Get(1)
+        // Format: Category, Description, IsStandard, Base
+        Set qHandle($I(qHandle)) = $LB(category, "JSON Schema category", "IsStandard", "Base")
+    }
+    Set qHandle = 0
+    Quit $$$OK
+}
+
+ClassMethod EnumerateTypeCategoriesFetch(
+	ByRef qHandle As %Binary,
+	ByRef Row As %List,
+	ByRef AtEnd As %Integer = 0) As %Status
+{
+    Set qHandle = $O(qHandle(qHandle))
+    If qHandle = "" {
+        Set Row = "", AtEnd = 1
+        Quit $$$OK
+    }
+    Set Row = qHandle(qHandle)
+    Quit $$$OK
+}
+
+ClassMethod EnumerateTypeCategoriesClose(ByRef qHandle As %Binary) As %Status
+{
+    Kill qHandle
+    Quit $$$OK
+}
+
+/// Returns array of properties that make up the <i>contents</i>
+/// of this object.<br>
+/// This method in implemented within the document class.<br>
+/// The content array is in the form:<br>
+/// 	pContents(n,"type")="%String"<br>
+/// 	pContents(n,"name")="Field"<br>
+/// 	pContents(n,"alias")=alias code<br>
+/// If pContents(n) is non-zero then the property is a composite type with<br>
+/// sub-properties.  The sub-properties are indexed with a similar structure under<br>
+///     pContents(n,m) where m is the index of the subtype property.<br>
+ClassMethod GetContentArray(
+	Output pContents,
+	pMode As %String,
+	pDocType As %String = "MESSAGE",
+	pLevel As %Integer,
+	pIncludeBase As %Boolean = 0) As %Status
+{
+    Set tSC = $$$OK
+    Try {
+        // Get schema structure
+        Set tName = pDocType
+        #; Set tName = $Piece(pDocType, ":", 2)
+
+        Set tSC = ##class(IOP.Message.JSONSchema).GetSchema(tName, .json)
+        If $$$ISERR(tSC) Return tSC
+        set schema = {}.%FromJSON(json)
+
+        $$$ThrowOnError(##class(IOP.Message).SchemaToContents(schema, .tContents))
+
+        Merge @pContents = tContents
+    }
+    Catch ex {
+        Set tSC = ex.AsStatus()
+    }
+    Return $$$OK
+}
+
+/// Convert a JSON schema structure into a contents array format
+/// schema: Dynamic object containing the JSON schema
+/// Output pContents: Array to store the contents structure
+/// Returns: %Status
+ClassMethod SchemaToContents(
+	schema As %DynamicObject,
+	Output pContents) As %Status
+{
+    Set tSC = $$$OK
+    Try {
+        Set idx = 0
+        Do ..ProcessProperties(schema.properties, .idx, .pContents, schema)
+    }
+    Catch ex {
+        Set tSC = ex.AsStatus()
+    }
+    Return tSC
+}
+
+ClassMethod ProcessProperties(
+	properties As %DynamicObject,
+	ByRef idx As %Integer,
+	Output pContents,
+	schema As %DynamicObject) As %Status
+{
+    Set iterator = properties.%GetIterator()
+    While iterator.%GetNext(.key, .value) {
+        Set idx = idx + 1
+        Do ..HandleProperty(value, .key, idx, .pContents, schema)
+    }
+    Return $$$OK
+}
+
+ClassMethod HandleProperty(
+	value As %DynamicObject,
+	ByRef key As %String,
+	idx As %Integer,
+	Output pContents,
+	schema As %DynamicObject)
+{
+    Set type = value.type
+    
+    If type = "string" || type = "number" || type = "boolean" {
+        Do ..HandlePrimitiveType(type, idx, .pContents)
+    }
+    ElseIf type = "array" {
+        Do ..HandleArrayType(value, .key, idx, .pContents, schema)
+    }
+    ElseIf type = "object" {
+        Do ..HandleObjectType(value, idx, .pContents)
+    }
+    ElseIf $IsObject(value.allOf) {
+        Do ..HandleAllOfType(value, key, idx, .pContents, schema)
+    }
+    
+    If type = "array" Set key = key_"()"
+    Set pContents(idx,"name") = key
+    Set pContents(idx,"alias") = key
+}
+
+ClassMethod HandlePrimitiveType(
+	type As %String,
+	idx As %Integer,
+	Output pContents)
+{
+    Set pContents(idx,"type") = $Case(type,
+        "string": "%String",
+        "number": "%Numeric",
+        "boolean": "%Boolean")
+}
+
+ClassMethod HandleArrayType(
+	value As %DynamicObject,
+	ByRef key As %String,
+	idx As %Integer,
+	Output pContents,
+	schema As %DynamicObject)
+{
+    Set pContents(idx,"type") = "()"
+    If $IsObject(value.items) && $IsObject(value.items.allOf) {
+        Do ..HandleAllOfType(value.items, key, idx, .pContents, schema)
+    }
+}
+
+ClassMethod HandleObjectType(
+	value As %DynamicObject,
+	idx As %Integer,
+	Output pContents)
+{
+    Set pContents(idx,"type") = "object"
+    If $IsObject(value.properties) {
+        Do ..SchemaToContents(value, .subContents)
+        Merge @pContents(idx) = subContents
+    }
+}
+
+ClassMethod HandleAllOfType(
+	value As %DynamicObject,
+	key As %String,
+	idx As %Integer,
+	Output pContents,
+	schema As %DynamicObject)
+{
+    Set pContents(idx) = 1 //TODO size of subContents
+    Set pContents(idx,"type") = "object"
+    Set pContents(idx,"name") = key
+    Set pContents(idx,"alias") = key
+    
+    Set allOfIterator = value.allOf.%GetIterator()
+    While allOfIterator.%GetNext(.allOfKey, .allOfValue) {
+        If $IsObject(allOfValue."$ref") {
+            Do ..SchemaToContents(allOfValue."$ref", .subContents)
+        }
+        Else {
+            Set tDef = schema."$defs".%Get($Piece(allOfValue."$ref","/",*))
+            Do ..SchemaToContents(tDef, .subContents)
+        }
+        Merge pContents(idx) = subContents
+    }
+}
+
 Method bufferGet()
 {
 	Quit ..#BUFFER
@@ -185,6 +696,26 @@ Storage Default
 <Value name="6">
 <Value>jsonString</Value>
 </Value>
+<Value name="7">
+<Value>DocType</Value>
+</Value>
+<Value name="8">
+<Value>TimeCreated</Value>
+</Value>
+<Value name="9">
+<Value>Source</Value>
+</Value>
+<Value name="10">
+<Value>IsMutable</Value>
+</Value>
+<Value name="11">
+<Value>OriginalDocId</Value>
+</Value>
+</Data>
+<Data name="UserValues">
+<Attribute>UserValues</Attribute>
+<Structure>subnode</Structure>
+<Subscript>"IOP.Message.UserValues"</Subscript>
 </Data>
 <Data name="jsonObject">
 <Attribute>jsonObject</Attribute>

{iris_pex_embedded_python-3.1.6b2.dist-info → iris_pex_embedded_python-3.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: iris_pex_embedded_python
-Version: 3.1.6b2
+Version: 3.2.0
 Summary: Iris Interoperability based on Embedded Python
 Author-email: grongier <guillaume.rongier@intersystems.com>
 License: MIT License
@@ -48,6 +48,8 @@ Requires-Dist: dacite>=1.6.0
 Requires-Dist: xmltodict>=0.12.0
 Requires-Dist: iris-embedded-python-wrapper>=0.0.6
 Requires-Dist: setuptools>=40.8.0
+Requires-Dist: dc-schema>=0.0.8
+Requires-Dist: jsonpath-ng>=1.7.0
 
 # IoP (Interoperability On Python)
 

{iris_pex_embedded_python-3.1.6b2.dist-info → iris_pex_embedded_python-3.2.0.dist-info}/RECORD

@@ -105,14 +105,14 @@ iop/_outbound_adapter.py,sha256=YTAhLrRf9chEAd53mV6KKbpaHOKNOKJHoGgj5wakRR0,726
 iop/_pickle_message.py,sha256=noKfc2VkXufV3fqjKvNHN_oANQ1YN9ffCaSV0XSTAIE,331
 iop/_private_session_duplex.py,sha256=36OwAGlasbPtfwq2KgMFcr3a33RsNSqohJx243XcDWI,5153
 iop/_private_session_process.py,sha256=pGjWFOQhWpQxUVpTtvNKTPvDxgzjfw0VC4Aqj3KUq8w,1704
-iop/_utils.py,sha256=b1vFnAXbcNV4uN9zojIeSeLgr0CuSt9bBgguZra0ve8,18105
+iop/_utils.py,sha256=c59QrgQgrk528V_n6RInnq_N6RzIGAAEmaTGRwanTSI,19404
 iop/cls/IOP/BusinessOperation.cls,sha256=lrymqZ8wHl5kJjXwdjbQVs5sScV__yIWGh-oGbiB_X0,914
 iop/cls/IOP/BusinessProcess.cls,sha256=s3t38w1ykHqM26ETcbCYLt0ocjZyVVahm-_USZkuJ1E,2855
 iop/cls/IOP/BusinessService.cls,sha256=7ebn32J9PiZXUgXuh5Xxm_7X6zHBiqkJr9c_dWxbPO8,1021
 iop/cls/IOP/Common.cls,sha256=4f4ZpLj8fsj8IKJDNb9pKoCokzo522JHWX0OqpAaC5g,11192
 iop/cls/IOP/Director.cls,sha256=M43LoTb6lwSr0J81RFxi1YLW1mwda09wQ7Xqr3nBtxo,2008
 iop/cls/IOP/InboundAdapter.cls,sha256=GeoCm6q5HcLJ5e4VxgqXiErJXqolBbpKwpunaNzpvjU,610
-iop/cls/IOP/Message.cls,sha256=_-RZ4AxyZ97M8Guvm5eFg_-rH1VbNtnFE3x_G4eMZFg,9719
+iop/cls/IOP/Message.cls,sha256=EJWt0ifN3v-QxFit-xvU4Brodx58_jWeYZDoiyHuHa8,25156
 iop/cls/IOP/OutboundAdapter.cls,sha256=9eOwy5ojwcTzwrHs6LNrFQvUD8aqcoNCZrILN1ycdDM,958
 iop/cls/IOP/PickleMessage.cls,sha256=S3y7AClQ8mAILjxPuHdCjGosBZYzGbUQ5WTv4mYPNMQ,1673
 iop/cls/IOP/Test.cls,sha256=gAC9PEfMZsvAEWIa241-ug2FWAhITbN1SOispZzJPnI,2094
@@ -120,6 +120,7 @@ iop/cls/IOP/Utils.cls,sha256=ZTBr02spm4ppxVBfhnUwb08BmhTjG5-ZbItRshYHs1I,13746
 iop/cls/IOP/Duplex/Operation.cls,sha256=K_fmgeLjPZQbHgNrc0kd6DUQoW0fDn1VHQjJxHo95Zk,525
 iop/cls/IOP/Duplex/Process.cls,sha256=xbefZ4z84a_IUhavWN6P_gZBzqkdJ5XRTXxro6iDvAg,6986
 iop/cls/IOP/Duplex/Service.cls,sha256=sTMOQUCMBgVitmQkM8bbsrmrRtCdj91VlctJ3I7b8WU,161
+iop/cls/IOP/Message/JSONSchema.cls,sha256=SL26n8Z0D81SAGL2NthI10NFdT4Oe1x_GQiaTYPwkoo,3252
 iop/cls/IOP/PrivateSession/Duplex.cls,sha256=8a_dO7E2RTzuxzoufryjlS41l-99NmTtOcmFXOnSwA8,7957
 iop/cls/IOP/PrivateSession/Message/Ack.cls,sha256=y6-5uSVod36bxeQuT2ytPN4TUAfM1mvGGJuTbWbpNv4,941
 iop/cls/IOP/PrivateSession/Message/Poll.cls,sha256=z3ALYmGYQasTcyYNyBeoHzJdNXI4nBO_N8Cqo9l4sQY,942
@@ -129,9 +130,9 @@ iop/cls/IOP/Service/WSGI.cls,sha256=VLNCXEwmHW9dBnE51uGE1nvGX6T4HjhqePT3LVhsjAE,
 iop/wsgi/handlers.py,sha256=NrFLo_YbAh-x_PlWhAiWkQnUUN2Ss9HoEm63dDWCBpQ,2947
 irisnative/_IRISNative.py,sha256=HQ4nBhc8t8_5OtxdMG-kx1aa-T1znf2I8obZOPLOPzg,665
 irisnative/__init__.py,sha256=6YmvBLQSURsCPKaNg7LK-xpo4ipDjrlhKuwdfdNb3Kg,341
-iris_pex_embedded_python-3.1.6b2.dist-info/LICENSE,sha256=rZSiBFId_sfbJ6RL0GjjPX-InNLkNS9ou7eQsikciI8,1089
-iris_pex_embedded_python-3.1.6b2.dist-info/METADATA,sha256=EDJ5HbzThJvVGWatjDaa7blCaD2mI5n6HdclkhGjjbQ,4361
-iris_pex_embedded_python-3.1.6b2.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
-iris_pex_embedded_python-3.1.6b2.dist-info/entry_points.txt,sha256=pj-i4LSDyiSP6xpHlVjMCbg1Pik7dC3_sdGY3Yp9Vhk,38
-iris_pex_embedded_python-3.1.6b2.dist-info/top_level.txt,sha256=VWDlX4YF4qFVRGrG3-Gs0kgREol02i8gIpsHNbhfFPw,42
-iris_pex_embedded_python-3.1.6b2.dist-info/RECORD,,
+iris_pex_embedded_python-3.2.0.dist-info/LICENSE,sha256=rZSiBFId_sfbJ6RL0GjjPX-InNLkNS9ou7eQsikciI8,1089
+iris_pex_embedded_python-3.2.0.dist-info/METADATA,sha256=pccc6u5ZCNCsCR_WmN8skwon3__mAcaeGXxcmW2gDuk,4425
+iris_pex_embedded_python-3.2.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+iris_pex_embedded_python-3.2.0.dist-info/entry_points.txt,sha256=pj-i4LSDyiSP6xpHlVjMCbg1Pik7dC3_sdGY3Yp9Vhk,38
+iris_pex_embedded_python-3.2.0.dist-info/top_level.txt,sha256=VWDlX4YF4qFVRGrG3-Gs0kgREol02i8gIpsHNbhfFPw,42
+iris_pex_embedded_python-3.2.0.dist-info/RECORD,,

{iris_pex_embedded_python-3.1.6b2.dist-info → iris_pex_embedded_python-3.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.7.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any