updates on schema checks

Author: mandd

src/dackar/knowledge_graph/KGconstruction.py

@@ -28,6 +28,8 @@ def __init__(self, config_file_path, uri, pwd, user):
 
         #self.processedDataFolder = processedDataFolder
 
+        self.datatypes = ['string', 'int', 'float', 'boolean', 'datetime']
+
         # Create python to neo4j driver
         self.py2neo = Py2Neo(uri=uri, user=user, pwd=pwd)
 
@@ -49,13 +51,22 @@ def __init__(self, config_file_path, uri, pwd, user):
                                                                                                       }
                                                                                             }
                                                                         },
-                                                         "required":["node_description"]           
+                                                         "required":["node_description","node_properties"]           
                                                         },
                                             "relation": {"description": "Data element encapsulated in the edge",
                                                          "type": "object",
                                                          "properties" : {"relation_description": {"type": "string", "description": "Type of relationship encapsulated in the relation between two nodes"},
                                                                          "from_entity": {"type": "string", "description": "Label of the departure node"},
-                                                                         "to_entity"  : {"type": "string", "description": "Label of the arrival node"}},
+                                                                         "to_entity"  : {"type": "string", "description": "Label of the arrival node"},
+                                                                         "relation_properties": {"type": "array",
+                                                                                                 "description": "Allowed properties associate with the relation",
+                                                                                                 "items": {"type": "object",
+                                                                                                           "properties": {"name"    : {"type": "string",  "description": "Name of the relation property"},
+                                                                                                                          "type"    : {"type": "string",  "description": "Type of the node property"},
+                                                                                                                          "optional": {"type": "boolean", "description": "Specifies if this property is required or not"}},
+                                                                                                                          "required":["name","type","optional"],
+                                                                                                      }
+                                                                                            }},
                                                          "required":["relation_description","from_entity","to_entity"],
                                                         }
                                             },
@@ -70,7 +81,7 @@ def __init__(self, config_file_path, uri, pwd, user):
     def resetGraph(self):
         self.py2neo.reset()
 
-    def checkSchemaStructure(self, importedSchema):
+    def _checkSchemaStructure(self, importedSchema):
         try:
             validate(instance=importedSchema, schema=self.schemaSchema)
             print("TOML content is valid against the schema.")
@@ -86,13 +97,16 @@ def importGraphSchema(self, graphSchemaName, tomlFilename):
 
         with open(config_path, 'rb') as f:
             config_data = tomllib.load(f)
+        
+        # Check structure of imported graphSchema
+        self._checkSchemaStructure(config_data)
 
-        self.checkSchemaStructure(config_data)
+        #TODO: check datatypes against self.datatypes
 
-        # Check structure of imported graphSchema
-        for node in config_data['node'].keys():
-            pass
         # Check imported graphSchema against self.graphSchemas
+        if graphSchemaName in list(self.graphSchemas.keys()):
+            print('Schema ' + str(graphSchemaName) + ' is already defined in the exisiting schemas')
+
         for node in config_data['node'].keys():
             for schema in self.graphSchemas:
                 if node in schema['node'].keys():
@@ -106,11 +120,33 @@ def importGraphSchema(self, graphSchemaName, tomlFilename):
         self.graphSchemas[graphSchemaName] = config_data
         return config_data
 
-    def schemaValidation(self, constructionSchema):
+    def _schemaReturnNodeProperties(self, nodeLabel):
+        for schema in self.graphSchemas:
+            if nodeLabel in schema['node'].keys():
+                node_properties = schema['node'][nodeLabel]['node_properties']
+                df = pd.DataFrame(node_properties)
+                return df
+        print('Node not found')
+        return None
+
+    def _schemaValidation(self, constructionSchema):
+        # For each node check that required properties are listed
         for node in constructionSchema['nodes']:
-            for schema in self.graphSchemas:
-                if node in schema['node'].keys():
-                    pass
+            specified_prop = set(constructionSchema['nodes'][node].keys())
+            
+            prop_df = self._schemaReturnNodeProperties(node)
+            allowed_properties = set(prop_df['name'])
+            
+            selected_prop_df = prop_df[prop_df['optional']==False]
+            req_properties = set(selected_prop_df['name'])
+
+            if not req_properties.issubset(specified_prop):
+                print('Node ' + str(node) + 'requires all these properties: ' + str(req_properties))
+
+            if not specified_prop.issubset(allowed_properties):
+                print('Node ' + str(node) + 'requires these properties: ' + str(allowed_properties))
+        
+        # For each relation check that required properties are listed
 
     def genericWorkflow(self, data, constructionSchema):
         # Check constructionSchema against self.graphSchemas  
@@ -260,7 +296,7 @@ def eventReportWorkflow(self, filename, constructionSchema, pipelines):
 
     def kgConstructionWorkflow(self, dataframe, graphSchema, constructionSchema):
 
-        self.schemaValidation(self, constructionSchema, graphSchema)
+        self._schemaValidation(self, constructionSchema, graphSchema)
 
         for node in constructionSchema['nodes'].keys(): 
             map = {value: key for key, value in constructionSchema['nodes'][node].items()} 

src/dackar/knowledge_graph/schemas/conditionReportSchema.toml

@@ -9,17 +9,13 @@ version = 1.0
 node_description = """Represents a structured report documenting an observed abnormal event or condition within 
                       a plant or operational environment. This entity captures descriptive information provided 
                       by plant staff, including the nature, context, and potential implications of the anomaly."""
-node_properties = [
-    {name = "date", type = "string", optional = false},
-    {name = "ID",   type = "string", optional = false},
-]
+node_properties = [{name = "date", type = "string", optional = false},
+                   {name = "ID",   type = "string", optional = false}]
 
 [node.work_order]
 description = """[]"""
-edge_properties = [
-    {name = "date", type = "string", optional = false},
-    {name = "ID",   type = "string", optional = false},
-]
+node_properties = [{name = "date", type = "string", optional = false},
+                   {name = "ID",   type = "string", optional = false}]
 
 # ====================
 # Relations
@@ -32,6 +28,7 @@ relation_description = """Indicates that a generalized nuclear-relevant entity s
                           a condition report"""
 from_entity = "condition_report"
 to_entity = "nuclear_entity"
+relation_properties = [{name = "date", type = "string", optional = false}]
 
 
 [relation.mentions]