Update AMR Rule: transduction.phenomena_and_analyzer_2

tenet/scheme/amr_clara_rule/transduction/odrl_rule_extractor.py

@@ -51,7 +51,14 @@ def __search_pattern(graph, phenomena_uri):
 # Useful Computation Method(s)
 #============================================================================== 
 
-def __define_naming(rule_relation):
+def __compute_rule_action_net(rule_net, action_net_uri):
+    action_net_list = rule_net.rule_action_net
+    if not isinstance(action_net_list, list): action_net_list = []
+    action_net_list.append(action_net_uri)
+    return action_net_list
+
+
+def __define_naming(rule_relation, action_net):
     return f'{rule_relation}'
     
     
@@ -68,13 +75,13 @@ def __construct_rule_net(graph, rule_relation, phenomena_net, action_net):
     
     # -- Data Computation
     rule_net.rule_relation_name = rule_relation
-    rule_net.rule_action_net = action_net.uri
+    rule_net.rule_action_net = __compute_rule_action_net(rule_net, action_net.uri)
     
     # -- Relation Propagation
     # None
 
     # -- Net Naming
-    rule_net.naming = __define_naming(rule_relation)
+    rule_net.naming = __define_naming(rule_relation, action_net)
     
     # -- Finalization
     rule_net.finalize()

tenet/scheme/amr_clara_rule/transduction/phenomena_and_analyzer_1.py

@@ -17,7 +17,7 @@ from transduction.rdfterm_computer import produce_uriref, produce_literal
 
 
 #==============================================================================
-# Pattern Search: property(class, and_phenomena)
+# Pattern Search: property(_, and_phenomena)
 #==============================================================================
 
 CONJUNCTION_PHENOMENA_URI = 'amr:phenomena_conjunction_and'  

tenet/scheme/amr_clara_rule/transduction/phenomena_and_analyzer_2.py

@@ -5,7 +5,7 @@
 # TENET: Rule to conjunctive phenomena and (rule 2)
 #------------------------------------------------------------------------------
 # Net Expansion AMR rule to analyse conjunctive phenomena (and)
-# Rule: property(property, and_phenomena) => compositeProperty
+# Rule: phenomena(_, and_phenomena) => relation(phenomena, argument)
 #==============================================================================
 
 from rdflib import Graph
@@ -13,23 +13,21 @@ from rdflib import Graph
 import transduction
 from transduction import net
 from transduction.query_builder import generate_select_query
-from transduction.naming_computer import define_composite_naming_1, define_restriction_naming
+from transduction.rdfterm_computer import produce_uriref, produce_literal
 
 
 #==============================================================================
-# Search for patterns: property(property, and_phenomena)
+# Pattern Search: modality(_, and_phenomena)
 #==============================================================================
 
 CONJUNCTION_PHENOMENA_URI = 'amr:phenomena_conjunction_and'  
        
 def __search_pattern(graph):
-    select_data_list = ['?property_net_core', '?property_net_arg0', '?phenomena_net']
-    clause_list = [f'?property_net_core a [rdfs:subClassOf* net:Property_Net].',
-                   f'?property_net_arg0 a [rdfs:subClassOf* net:Property_Net].',
-                   f'?phenomena_net a [rdfs:subClassOf* net:Phenomena_Net].',
-                   f'?phenomena_net net:hasPhenomenaType {CONJUNCTION_PHENOMENA_URI}.',
-                   f'?property_net_core amr:role_ARG0 ?property_net_arg0.',
-                   f'?property_net_core amr:role_ARG1 ?phenomena_net.']
+    select_data_list = ['?left_phenomena_net', '?relation_role', '?right_phenomena_net']
+    clause_list = [f'?left_phenomena_net a [rdfs:subClassOf* net:Phenomena_Net].',
+                   f'?right_phenomena_net a [rdfs:subClassOf* net:Phenomena_Net].',
+                   f'?right_phenomena_net net:hasPhenomenaType {CONJUNCTION_PHENOMENA_URI}.',
+                   f'?left_phenomena_net ?relation_role ?phenomena_net.']
     query_code = generate_select_query(graph, select_data_list, clause_list)
     result_set = graph.query(query_code) 
     return query_code, result_set
@@ -37,131 +35,66 @@ def __search_pattern(graph):
 
 
 #==============================================================================
-# Search for phenomena operators: 
+# Useful Additional Search
 #==============================================================================
 
-def __property_op_pattern_query_code(graph, phenomena_net_uri, num):
+def __search_op_class_pattern(graph, phenomena_net_uri, num):
     assert 1 <= num <= 9, f'invalid number ({num})'
-    select_data_list = ['?property_net']
-    clause_list = [f'?property_net a [rdfs:subClassOf* net:Property_Net].']
-    clause_list.append((phenomena_net_uri, f'amr:role_op{num}', '?property_net'))
+    select_data_list = ['?class_net']
+    clause_list = [f'?class_net a [rdfs:subClassOf* net:Class_Net].',
+                   (phenomena_net_uri, f'amr:role_op{num}', '?class_net')]
     query_code = generate_select_query(graph, select_data_list, clause_list)
-    return query_code
-
+    result_set = graph.query(query_code) 
+    return query_code, result_set
 
-def __search_property_phenomena_operator(graph, phenomena_net_uri):
+def __search_phenomena_operator_class(graph, phenomena_net_uri):
+    query_code = ''
     op_set = []
     for num in range(1, 9+1):
-        query_code = __property_op_pattern_query_code(graph, phenomena_net_uri, num)
-        op_set += graph.query(query_code) 
-    return op_set
-
-
+        query_code, result_set = __search_op_class_pattern(graph, phenomena_net_uri, num)
+        op_set += result_set
+    return query_code, op_set
 
-#==============================================================================
-# Relation Propagation
-#==============================================================================
-
-def __filter_relation(relation_list):
-    result_list = []
-    for relation in relation_list:
-        check = True
-        (s, p, o) = relation
-        if s == o: check = False
-        if check: result_list.append(relation)
-    return result_list
     
+def __search_op_property_pattern(graph, phenomena_net_uri, num):
+    assert 1 <= num <= 9, f'invalid number ({num})'
+    select_data_list = ['?property_net']
+    clause_list = [f'?property_net a [rdfs:subClassOf* net:Property_Net].',
+                   (phenomena_net_uri, f'amr:role_op{num}', '?property_net')]
+    query_code = generate_select_query(graph, select_data_list, clause_list)
+    result_set = graph.query(query_code) 
+    return query_code, result_set
 
-def __propagate_relation(target_net, base_net):
-    # -- target_net.input_relation_list = base_net.input_relation_list
-    out_relation_list = __filter_relation(base_net.output_relation_list)
-    target_net.output_relation_list = out_relation_list
+def __search_phenomena_operator_property(graph, phenomena_net_uri):
+    query_code = ''
+    op_set = []
+    for num in range(1, 9+1):
+        query_code, result_set = __search_op_property_pattern(graph, phenomena_net_uri, num)
+        op_set += result_set
+    return query_code, op_set
 
 
 
 #==============================================================================
-# Construct Methods: construction of composite property net
+# Useful Computation Method(s)
 #==============================================================================  
 
-def __construct_restriction_net(graph, property_net_1, property_net_2):
-    
-    restriction_net = net.RestrictionNet(graph)
-    restriction_net.compose(property_net_1, property_net_2)
-    
-    # -- Data Computation
-    restriction_net.restriction_property = property_net_1.uri
-    restriction_net.restriction_net_value = property_net_2.uri
-
-    # -- Relation Propagation: None
-
-    # -- Net Naming
-    restriction_net.naming = define_restriction_naming(property_net_1, property_net_2)
-    
-    # -- Finalization
-    restriction_net.finalize()
-    triple_list = restriction_net.generate_triple_definition()
-    
-    return restriction_net, triple_list
-    
+def __propagate_relation(left_net, amr_relation_uri, right_net_uri):
+    new_relation = (left_net.uri, amr_relation_uri, right_net_uri)
+    up_relation_list = left_net.output_relation_list + [new_relation]
+    left_net.output_relation_list = up_relation_list
     
     
-def __construct_composite_property_net_from_3_properties(
-        graph, base_property_net, core_property_net, target_property_net):
     
-    # -- Net Composition
-    composite_property_net = net.CompositePropertyNet(graph)
-    composite_property_net.compose(base_property_net, core_property_net, target_property_net)
-    
-    # -- Data Computation
-    composite_property_net.mother_property_net = base_property_net.uri
-    composite_property_net.property_type = 'owl:ObjectProperty'
-
-    # -- Restriction Computation
-    restriction_net, triple_list_1 = __construct_restriction_net(graph, core_property_net, target_property_net)
-    composite_property_net.restriction = restriction_net.uri
-    
-    # -- Relation Propagation
-    __propagate_relation(composite_property_net, base_property_net) 
-
-    # -- Net Naming
-    composite_property_net.naming = define_composite_naming_1(
-        base_property_net, core_property_net, target_property_net)
-    
-    # -- Finalization
-    composite_property_net.finalize()
-    triple_list_2 = composite_property_net.generate_triple_definition()
-    result_triple_list = triple_list_1 + triple_list_2
-    
-    return composite_property_net, result_triple_list
-
-
-
-def __construct_property_union_net(graph, base_property_net, property_net_list):
-
-    # -- Net Composition
-    property_union_net = net.PropertyUnionNet(graph)
-    property_union_net.compose(base_property_net, property_net_list)
-    
-    # -- Data Computation: None
-
-    # -- Restriction Computation: None
-    
-    # -- Relation Propagation
-    __propagate_relation(property_union_net, base_property_net) 
-
-    # -- Net Naming
-    property_union_net.naming = define_union_naming(base_property_net)
-    
-    # -- Finalization
-    property_union_net.finalize()
-    triple_list = property_union_net.generate_triple_definition()
-    
-    return property_union_net, triple_list
+#==============================================================================
+# Construct Method(s)
+#==============================================================================
 
+# None
   
     
 #==============================================================================
-# Main Method: analyze_phenomena_and_2
+# Main Method
 #==============================================================================
 
 def analyze_phenomena_and_2(graph):
@@ -175,36 +108,30 @@ def analyze_phenomena_and_2(graph):
     
     # -- Pattern Analysis
     for pattern in pattern_set:
-        property_net_1 = net.PropertyNet(graph, uri=pattern.property_net_arg0)
-        property_net_2 = net.PropertyNet(graph, uri=pattern.property_net_core)
-        phenomena_net = net.PhenomenaNet(graph, uri=pattern.phenomena_net)
+        property_net = net.PhenomenaNet(graph, uri=pattern.left_phenomena_net)
+        phenomena_net = net.PhenomenaNet(graph, uri=pattern.right_phenomena_net)
         
         # -- Search for phenomena operators
-        property_operator_set = __search_property_phenomena_operator(graph, phenomena_net.uri)
-        
-        # -- Selection Analyzing (2)
-        property_net_list = []
-        for selection_2 in property_operator_set:
-            # print(f' *** DEVTEST *** {selection_2.property_net}')
-            
-            # -- Net Selection
-            property_net_3 = net.PropertyNet(graph, uri=selection_2.property_net)
         
-            # -- New Net Construction (from 3 property nets)
-            new_property, triple_list = __construct_composite_property_net_from_3_properties(
-                graph, property_net_1, property_net_2, property_net_3)
+        # -- Relation Propagation for Operator Class Net
+        _, operator_class_set = __search_phenomena_operator_class(graph, phenomena_net.uri)
+        for operator in operator_class_set:
+            amr_relation_uri = produce_uriref(graph, pattern.relation_role)
+            right_net_uri = produce_uriref(graph, operator.class_net)
+            __propagate_relation(property_net, amr_relation_uri, right_net_uri)
+            rule_triple_list += property_net.generate_net_relation_triples()
             
-            # -- Resulting List Update
-            property_net_list.append(new_property)
-            rule_triple_list += triple_list
+        # -- Relation Propagation for Operator Class Net
+        _, operator_property_set = __search_phenomena_operator_property(graph, phenomena_net.uri)
+        for operator in operator_property_set:
+            amr_relation_uri = produce_uriref(graph, pattern.relation_role)
+            right_net_uri = produce_uriref(graph, operator.property_net)
+            __propagate_relation(property_net, amr_relation_uri, right_net_uri)
+            rule_triple_list += property_net.generate_net_relation_triples()
         
-        # -- Deprecation: Origin Property Net
-        rule_triple_list += property_net_1.deprecate()
         
         # -- New Net Construction (as union of properties)
-        # _, triple_list = __construct_property_union_net(graph, property_net_1, property_net_list)
+        # _, triple_list = __construct_class_union_net(graph, class_net_1, class_net_list)
         # rule_triple_list += triple_list
     
     return rule_label, rule_triple_list
\ No newline at end of file
-
-    
\ No newline at end of file

tenet/scheme/amr_scheme_clara_1.py

@@ -193,7 +193,8 @@ phenomena_analyze_sequence_1 = ['phenomena analyze sequence (1)',
 phenomena_analyze_sequence_2 = ['phenomena analyze sequence (2)',
                                 rule.analyze_phenomena_or_1,
                                 rule.analyze_phenomena_or_2,
-                                rule.analyze_phenomena_and_1]
+                                rule.analyze_phenomena_and_1,
+                                rule.analyze_phenomena_and_2]
 
 composite_class_extraction_sequence = ['composite class extraction sequence',
                                        rule.extract_composite_class_1,