Renaming both transduction rule variants to novTransduction and janTransduction

tenet/extraction/process.py

@@ -24,8 +24,8 @@ import importlib.util
 import importlib
 
 from utility.timer import timed, timer_return
-from extraction.old_rule import OldRule
-from extraction.old_sequence import OldSequence
+from novTransduction.nov_rule import NovRule
+from novTransduction.nov_sequence import NovSequence
 
 
 #==============================================================================
@@ -62,7 +62,7 @@ def get_new_rule_set(rule_def_set, prefix_list):
         rule_set = {}
         
         for rule_key, rule_def in rule_def_set.items():
-            rule = OldRule()
+            rule = NovRule()
             rule.load_dict(rule_def)
             rule.load_prefix_list(prefix_list)
             rule_set[rule_key] = rule
@@ -135,7 +135,7 @@ def load_rule_set(config, rule_dir, prefix_list):
 #==============================================================================
         
 def _prepare_sequence(sequence_def, rule_set):
-    sequence = OldSequence()
+    sequence = NovSequence()
     sequence.load_sequence_from_dict(sequence_def)
     sequence.load_rule_list(rule_set)
     return sequence
@@ -173,7 +173,7 @@ def _apply_sequence(graph, sequence, refinement_rule_list):
     """ Apply the rules of <sequence> on the working graph <graph> """ 
     
     try:
-        logger.info("--- Sequence: {0}".format(sequence.label))    
+        logger.info("--- *** November Transduction *** Sequence: {0}".format(sequence.label))    
         all_new_triple_set = []
     
         for rule in sequence.rule_list:
@@ -200,7 +200,7 @@ def _apply_sequence(graph, sequence, refinement_rule_list):
     
         return graph, all_new_triple_set
    
-    except:
+    except Exception as e:
         logger.error(" *** Error while processing extraction (_apply_sequence) ***") 
         logger.debug(" ----- len(sequence): {0} ".format(len(sequence))) 
         logger.debug(" ----- last rule: {0} ".format(rule)) 
@@ -222,7 +222,7 @@ def _apply_new_rule_sequence(graph, rule_function):
     
     try:
         rule = rule_function()
-        logger.info(f"--- *** New *** Rule: {rule.label}")    
+        logger.info(f"--- *** January Transduction *** Sequence: {rule.label}")    
         all_new_triple_set = []
     
         for (query_label, sparql_query) in rule.query_list:
@@ -243,22 +243,23 @@ def _apply_new_rule_sequence(graph, rule_function):
             else:
                 logger.debug(str)
                 
-            # -- apply refinement
-            graph, extracted_triple_set = _apply_refinement(graph, refinement_rule_list)
-            all_new_triple_set.extend(extracted_triple_set)
+            # -- apply refinement *** old ***
+            # graph, extracted_triple_set = _apply_refinement(graph, refinement_rule_list)
+            # all_new_triple_set.extend(extracted_triple_set)
     
         return graph, all_new_triple_set
     
-    except AssertionError as e:
-        logger.error(f' *** *** **** Assertion Error *** *** *** \n ')  
+    except AssertionError as ae:
+        logger.error(f' *** *** **** Assertion Error *** *** *** \n {ae}')  
         
     except:
-        logger.error(" *** Error while processing extraction (_apply_new_rule_sequence) ***")
+        logger.error(f" *** Error while processing extraction (_apply_new_rule_sequence) ***")
         logger.debug(f" ----- len(sequence): {len(rule.query_list)} ") 
         logger.debug(f" ----- last rule: {query_label} ") 
         logger.debug(f" ----- last SPARQL query: \n{sparql_query} ") 
         logger.debug(f" ----- len(extracted_triple_set): {len(extracted_triple_set)} ") 
         logger.debug(f" ----- new_triple_count: {new_triple_count} ") 
+        logger.debug(f" ----- exec_time_date: {exec_time_date} ") 
         
     
 def _serialize_graph(config, graph, step_name):
@@ -305,7 +306,6 @@ def apply_step(config, graph, rule_set, step_name, step_sequence_def):
                 graph, triple_list = _apply_sequence(graph, sequence, refinement_rule_list)
                 step_triple_list.extend(triple_list)
             else: # New Rule Application
-                logger.info(f"******* New Rule: {sequence_def} ********")
                 _apply_new_rule_sequence(graph, sequence_def)
                 
          

tenet/transduction/net/net.py → tenet/janTransduction/net/net.py

@@ -38,10 +38,14 @@ class Net:
 
     # -- Operation Reference 
     INITIALIZED = f'net:initialized'
-    RELATION_PROPAGATED = f'net:relation_propagated'
+    DATA_ADDED = f'net:data_added'
     RESTRICTION_ADDED = f'net:restriction_added'
+    RELATION_PROPAGATED = f'net:relation_propagated'
     FINALIZED = f'net:finalized'
     
+    progress_step_list = [INITIALIZED, DATA_ADDED, RESTRICTION_ADDED,
+                               RELATION_PROPAGATED, FINALIZED]
+    
     #--------------------------------------------------------------------------
     # Constructor
     #--------------------------------------------------------------------------
@@ -59,12 +63,14 @@ class Net:
         self.node = f'{self.id}Node'
         self.base_node = f'{self.id}BaseNode'
         self.structure = f'{self.id}Structure'
+        self.naming = f'{self.id}Naming'
              
         self.predicate_table = { 
             # *** [attribute_reference: attribute_predicate] ***
             'node': 'coverNode',
             'base_node': 'coverBaseNode',
-            'structure': 'hasStructure'
+            'structure': 'hasStructure',
+            'naming': 'hasNaming'
             }
         
         
@@ -105,46 +111,147 @@ class Net:
     # Method(s) to track the construction progress
     #--------------------------------------------------------------------------
 
-    def __track_construction_progress(self, progress_step):
+    def track_progression(self, progress_step):
         predicate = self.__get_track_predicate('progress_step')
-        return f"{self.id} {predicate} {progress_step}."
+        return f"{INDENT_STR}{self.id} {predicate} {progress_step}."
     
-    def get_progress_step(self, progress_step_ref):
+    def in_progress_step(self, progress_step):
         predicate = self.__get_track_predicate('progress_step')
-        return f"""
-            {{
-                # -- Progress Step of {self.id}
-                SELECT {self.id} (MAX(?progressStep) AS {progress_step_ref})
-            		WHERE {{
-                        {self.id} {predicate} ?progressStep.
-                }}
-                GROUP BY {self.id}
-            }}""" 
-     
-    def is_progress_step(self, progress_step):
-        query = self.get_progress_step('?currentProgressStep')
-        query += f"""
-            FILTER (?currentProgressStep = {progress_step})."""
-        return query
+        query_code = f'FILTER NOT EXISTS {{ {self.id} {predicate} {progress_step}. }}'
+        return query_code
     
-    def filter_already_processed_net(self, operation_ref):
+    def is_finalized_net(self):
         predicate = self.__get_track_predicate('progress_step')
-        return f"""
-            FILTER NOT EXISTS {{ {self.id} {predicate} {operation_ref}. }}"""
+        progress_step = FINALIZED
+        query_code = f'FILTER NOT EXISTS {{ {self.id} {predicate} {progress_step}. }}'
+        return query_code
         
-    def in_progress(self):
-        query = self.get_progress_step('?currentProgressStep')
-        query += f"""
-            FILTER (?currentProgressStep < {Net.FINALIZED})."""
-        return query
     
-    def identify_main_composante(self, target_id):
-        predicate = self.__get_track_predicate('main_net_composante')
-        return f"\n{INDENT_STR}{self.id} {predicate} {composante}."
+    #--------------------------------------------------------------------------
+    # Method(s) to build 'Construct' parts  (definition)
+    #--------------------------------------------------------------------------
 
-    def identify_composante(self, target_id):
+    def define(self, **net_attribute):
+        net_attribute.update({'structure': '?sentenceRef'})
+        query_code = ''
+        query_code += f'{INDENT_STR}{self.id} a {self.type_uri}.\n' 
+        query_code += self.track_progression(INITIALIZED)
+        #query_code += f'{self.__define_attribute_triples(**net_attribute)}' 
+        return query_code 
+            
+        
+    
+    #--------------------------------------------------------------------------
+    # Method(s) to build 'Construct' parts  (composition tracking)
+    #--------------------------------------------------------------------------
+
+    def track_composante(self, composante, main=False):
+        query_code = ''
         predicate = self.__get_track_predicate('net_composante')
-        return f"\n{INDENT_STR}{self.id} {predicate} {composante}."
+        query_code += f"{self.id} {predicate} {composante.id}."
+        if main:
+            predicate = self.__get_track_predicate('main_net_composante')
+            query_code += f"\n{INDENT_STR}"
+            query_code += f"{self.id} {predicate} {composante.id}."
+        query_code += f"\n{INDENT_STR}"
+        net_node = f'{composante.node}'
+        query_code += self.__define_attribute_triples(node=net_node)
+        return query_code
+    
+    
+    #--------------------------------------------------------------------------
+    # Method(s) to build 'Identification Clause' parts  
+    #--------------------------------------------------------------------------          
+            
+    def identify(self, step_num=-1):
+        query_code = ""
+        query_code += f"{self.id} a [rdfs:subClassOf* {self.type_uri}]." 
+        if step_num > -1 & step_num < len(self._progress_step_list):
+            progress_step = self._progress_step_list[step_num]
+            query_code += self.in_progress_step(progress_step)
+        return query_code     
+    
+    
+    #--------------------------------------------------------------------------
+    # Method(s) to build 'Clause' parts (data selection) 
+    #--------------------------------------------------------------------------
+
+    def select_data(self, *net_attribute):
+        
+        query_code = ""
+        
+        # -- construct triples
+        first = True
+        for attr_ref in net_attribute:
+            if attr_ref in self.predicate_table.keys():
+                predicate = self.__get_predicate(attr_ref)
+                attr_value = getattr(self, attr_ref)     
+                if not first: query_code += f"\n{INDENT_STR}" 
+                query_code += f"{self.id} {predicate} {attr_value}." 
+                first = False
+        
+        return query_code
+    
+    
+    def select_tracking_data(self):
+        return self.select_data('node')
+    
+    
+    
+    #--------------------------------------------------------------------------
+    # Method(s) to build 'Binding' parts  
+    #--------------------------------------------------------------------------
+    
+    def bind_naming(self, *nets):
+        
+        assert len(nets) > 0, 'bind_naming impossible without net'
+        
+        query_code = ''
+        
+        num = 0
+        for net in nets:
+            num += 1
+            if num == 1: # first net
+                current_ref = f"{self.id}NamingRef{num}"
+                query_code += f'{net.select_data("naming")}'
+                query_code += f"\n{INDENT_STR}" 
+                query_code += f'BIND ({net.naming} AS {current_ref}).'       
+            else: # net 2, 3...
+                previous_ref = current_ref
+                current_ref = f"{self.id}NamingRef{num}"
+                query_code += f"\n{INDENT_STR}" 
+                query_code += f'{net.select_data("naming")}'
+                query_code += f"\n{INDENT_STR}" 
+                query_code += f"BIND (CONCAT({previous_ref}, '-', {net.naming}) AS {current_ref})."
+        
+        query_code += f"\n{INDENT_STR}" 
+        query_code += f'BIND (REPLACE({current_ref}, " ", "") AS {self.naming}).'  
+        
+        return query_code
+            
+    
+    def bind_uri(self, net_name, node_reference):
+        
+        ref1 = f"{self.id}UriRef1"
+        ref2 = f"{self.id}UriRef2"
+        ref3 = f"{self.id}UriRef3"
+        
+        query_code = f"""
+            BIND (CONCAT(str(net:), "{self.type_name}") AS {ref1}).
+            BIND (CONCAT({ref1}, "_", {net_name}) AS {ref2}).
+            BIND (CONCAT({ref2}, "_", {node_reference}) AS {ref3}).
+            BIND (uri({ref3}) AS {self.id})."""   
+        
+        return query_code    
+    
+    
+    
+    # *****************************************************************************************
+    #
+    #     OLD  *****     OLD        *******      OLD
+    #
+    # ******************************************************************************************
+        
 
     
     #--------------------------------------------------------------------------
@@ -199,12 +306,6 @@ class Net:
             # -- Additional triple(s) for {self.id}
             {query_code}""" 
         
-        # for attr_ref in self.predicate_table.keys():
-        #     if attr_ref in net_attribute.keys():
-        #         predicate = self.__get_predicate(attr_ref)
-        #         attr_value = net_attribute.get(attr_ref)     
-        #         query_code += f"{self.id} {predicate} {attr_value}." 
-        #         query_code += f"\n{INDENT_STR}"  
      
     
     def define_structure(self):
@@ -218,57 +319,6 @@ class Net:
             
 
     
-    #--------------------------------------------------------------------------
-    # Method(s) to build 'Construct' parts  (composition tracking)
-    #--------------------------------------------------------------------------
-
-    def track_composante(self, composante, main=False):
-        query_code = ''
-        predicate = self.__get_track_predicate('net_composante')
-        query_code += f"{self.id} {predicate} {composante.id}."
-        if main:
-            predicate = self.__get_track_predicate('main_net_composante')
-            query_code += f"\n{INDENT_STR}"
-            query_code += f"{self.id} {predicate} {composante.id}."
-        query_code += f"\n{INDENT_STR}"
-        net_node = f'{composante.node}'
-        query_code += self.__define_attribute_triples(node=net_node)
-        return query_code
-    
-    
-    #--------------------------------------------------------------------------
-    # Method(s) to build 'Clause' parts (data selection) 
-    #--------------------------------------------------------------------------
-
-    def select_data(self, *net_attribute):
-        
-        query_code = ""
-        
-        # -- construct triples
-        first = True
-        for attr_ref in net_attribute:
-            if attr_ref in self.predicate_table.keys():
-                predicate = self.__get_predicate(attr_ref)
-                attr_value = getattr(self, attr_ref)     
-                if not first: query_code += f"\n{INDENT_STR}" 
-                query_code += f"{self.id} {predicate} {attr_value}." 
-                first = False
-        
-        return query_code
-    
-    
-    def select_tracking_data(self):
-        return self.select_data('node')
-    
-    
-    
-    # *******************************************
-    #
-    #     OLD
-    #
-    # **********************************************
-        
-    
     #--------------------------------------------------------------------------
     # Method(s) to build 'Complement Clause' parts  
     #--------------------------------------------------------------------------
@@ -449,28 +499,28 @@ class Net:
     # Method(s) to build 'Binding' parts  
     #--------------------------------------------------------------------------           
     
-    def bind_uri(self, net_name='nameless', node_reference='blank'):
-        
-        ref1 = f"{self.id}Ref1"
-        ref2 = f"{self.id}Ref2"
-        ref3 = f"{self.id}Ref3"
-        
-        if net_name=='nameless':
-            net_name = f"'nameless'"
-            refNet = f"?namelessRefNet"
-        else:
-            refNet = f"{net_name}RefNet"
-            
-        if node_reference=='blank':
-            node_reference = f"'blankNode'"
-            refNode = f"?blankRefNode"
-        else:
-            refNode = f"{node_reference}RefNode"
-            
-        return f"""
-            BIND (REPLACE({net_name}, ' ', "") AS {refNet}).
-            BIND (REPLACE({node_reference}, ' ', "") AS {refNode}).
-            BIND (CONCAT(str(net:), '{self.type_name}') AS {ref1}).
-            BIND (CONCAT({ref1}, '_', {refNet}) AS {ref2}).
-            BIND (CONCAT({ref2}, '_', {refNode}) AS {ref3}).
-            BIND (uri({ref3}) AS {self.id})."""
\ No newline at end of file
+    # def bind_uri(self, net_name='nameless', node_reference='blank'):
+        
+    #     ref1 = f"{self.id}Ref1"
+    #     ref2 = f"{self.id}Ref2"
+    #     ref3 = f"{self.id}Ref3"
+        
+    #     if net_name=='nameless':
+    #         net_name = f"'nameless'"
+    #         refNet = f"?namelessRefNet"
+    #     else:
+    #         refNet = f"{net_name}RefNet"
+            
+    #     if node_reference=='blank':
+    #         node_reference = f"'blankNode'"
+    #         refNode = f"?blankRefNode"
+    #     else:
+    #         refNode = f"{node_reference}RefNode"
+            
+    #     return f"""
+    #         BIND (REPLACE({net_name}, ' ', "") AS {refNet}).
+    #         BIND (REPLACE({node_reference}, ' ', "") AS {refNode}).
+    #         BIND (CONCAT(str(net:), '{self.type_name}') AS {ref1}).
+    #         BIND (CONCAT({ref1}, '_', {refNet}) AS {ref2}).
+    #         BIND (CONCAT({ref2}, '_', {refNode}) AS {ref3}).
+    #         BIND (uri({ref3}) AS {self.id})."""
\ No newline at end of file

tenet/transduction/rule.py → tenet/janTransduction/rule.py

@@ -18,8 +18,8 @@ if __name__ == '__main__':
 
 import logging
 
-import transduction.query_builder as query_builder
-import transduction.net as net
+import janTransduction.query_builder as query_builder
+import janTransduction.net as net
 
 # -- Useful Constant(s)
 DEFAULT_ATTRIBUTE_VALUE = f'\"NA\"'
@@ -162,11 +162,24 @@ class Rule:
     
     
     def __define_new_net_binding_clause(self, *nets):
+        
+        assert len(nets) > 0, '__define_new_net_binding_clause impossible without net'
+        
         clause_part = f"\n{INDENT_STR}"
-        clause_part += f"# -- New Net Binding "
-        # * TODO * for net in nets:
-		# * TODO * clause_part += f'BIND (CONCAT({class_net_0.class_name}, '-', {logical_set_net.naming}) AS ?newClassName).'
-        clause_part += self.new_net.bind_uri('?newNetName', '?newNetMainNode') # -- TODO
+        clause_part += f"""# *** Identify variable label of base leaf ***
+            {nets[0].select_data('base_node')}
+            {nets[0].base_node} a amr:AMR_Leaf ;
+                amr:hasVariable ?variable.
+                ?variable amr:label ?varLabel."""
+                
+        clause_part += f"\n\n{INDENT_STR}"
+        clause_part += f"# -- Naming Binding \n{INDENT_STR}"
+        clause_part += self.new_net.bind_naming(*nets)
+        
+        clause_part += f"\n\n{INDENT_STR}"
+        clause_part += f"# -- URI Binding"
+        clause_part += self.new_net.bind_uri(self.new_net.naming, '?varLabel')
+        
         return clause_part
         
         
@@ -215,11 +228,47 @@ class Rule:
         construct_part += self.__define_composition(*nets)
         construct_part += self.__define_deprecate_net(*nets)
         
+        # -- Query Generation
+        compose_query = query_builder.generate_construct_query(construct_part, clause_part)
+        self.query_list.append((query_label, compose_query))
+        
+    
+    #--------------------------------------------------------------------------
+    # Method(s) to add data in a new semantic net
+    #--------------------------------------------------------------------------
+          
+    def __select_data_value(self, data_value): # TODO
+        clause_part = ''
+        return clause_part
+        
+    def __add_data(self, key, value): # TODO
+        construct_part = ''
+        return construct_part
+    
+    def compute_data(self, **data):
+        
+        query_label = 'net data computing'
+        
+        # -- Clause Part
+        clause_part = ''
+        clause_part += self.new_net.identify(step_num=1)
+        for data_value in data.values():
+            clause_part += __select_data_value(self, data_value)
+        
+        # -- Construct Part
+        construct_part = ''
+        for data_key, data_value in data.items():
+            construct_part += self.__add_data(data_key, data_value)
+        #construct_part += self.new_net.track_progression(step_num=1)
+        
+        # -- Query Generation
         compose_query = query_builder.generate_construct_query(construct_part, clause_part)
         self.query_list.append((query_label, compose_query))
         
     
     
+    
+    
 #==============================================================================
 # Development Test
 #==============================================================================
@@ -229,18 +278,20 @@ if __name__ == '__main__':
     print('\n' + ' *** Development Test ***')  
     
     # print('\n' + ' -- Net Definition')
-    property_net = net.PropertyNet()
-    class_net_0 = net.ClassNet(0)
-    class_net_1 = net.ClassNet(1)
+    property_net_0 = net.PropertyNet(0)
+    property_net_1 = net.PropertyNet(1)
     phenomena_net = net.PhenomenaNet()
     or_composite_class_net = net.OrCompositeClassNet()
     
     # print('\n' + ' -- Test Rule 1')
     rule = Rule('Test Rule', or_composite_class_net)
     rule.add_identification_pattern(phenomena_net, phenomena_type='amr:phenomena_conjunction_or')
-    rule.add_composition_pattern(property_net, 'amr:role_ARG0', class_net_0)
-    rule.add_composition_pattern(property_net, 'amr:role_ARG1', phenomena_net)
-    rule.compose(class_net_0, property_net, class_net_1)
+    rule.add_composition_pattern(property_net_1, 'amr:role_ARG0', property_net_0)
+    rule.add_composition_pattern(property_net_1, 'amr:role_ARG1', phenomena_net)
+    rule.compose(property_net_0, property_net_1, phenomena_net)
+    
+    rule.compute_data()
+    
     num = 0
     for query_label, query in rule.query_list:
         num += 1

tenet/novTransduction/__init__.py

+ 

tenet/extraction/old_rule.py → tenet/novTransduction/nov_rule.py

@@ -44,7 +44,7 @@ RULE_STRING = """ *** Compositional Transduction Rule (CTR) ***
 # Class
 #==============================================================================
 
-class OldRule:
+class NovRule:
     """ Class to define a Compositional Transduction Rule (CTR).
     """