New Specific Analyzer Rule to analyze link between degree91 and remain (2)

tenet/scheme/amr_master_rule/transduction/phenomena_analyzer/degree_analyzer_1.py

@@ -226,13 +226,16 @@ def __construct_feature_individual_net(graph, feature_class_net, degree_individu
     return individual_net, result_triple_list  
     
 
-
 def __associate_mother_relation_to_refine(graph, left_class_net, right_class_net):
     left_class_net.mother_class_net_to_refine = right_class_net.uri
     result_triple_list = left_class_net.generate_triple_definition()
     return left_class_net, result_triple_list
 
 
+def __add_feature_reference_to_degree_net(graph, degree_net, feature_net):
+    degree_net.feature_net = feature_net.uri
+    return degree_net, degree_net.generate_triple_definition()
+
 
 #==============================================================================
 # Main Method
@@ -266,6 +269,11 @@ def analyze_phenomena_degree91_1(graph):
         
         rule_triple_list += (triple_list_1 + triple_list_2 + triple_list_3)
         
+        # -- Update Degree Phenomena Net by adding feature net reference
+        _, degree_triple_list = __add_feature_reference_to_degree_net(
+            graph, phenomena_net, feature_individual_net)
+        rule_triple_list += degree_triple_list
+        
         # -- Comparison Handle (ARG4)
         _, comparated_class_set = __search_degree_arg4(graph, phenomena_net.uri)
         for row in comparated_class_set:

tenet/scheme/amr_master_rule/transduction/specific_analyzer/specific_analyzer_1_degree_remain.py

@@ -30,8 +30,6 @@ DEGREE_PROPERTY_NET_URI = 'net:predefinedProperty_hasDegree'
 AND_PHENOMENA_URI = 'amr:phenomena_conjunction_and' 
 DEGREE_PHENOMENA_URI = 'amr:phenomena_degree' 
 REMAIN_PROPERTY_NAMING = '"remain"'  
-ARG_RELATION = [None, 'amr:role_ARG1', 'amr:role_ARG2', 'amr:role_ARG3',
-                'amr:role_ARG4', 'amr:role_ARG5', 'amr:role_ARG6'] 
 OP_RELATION = [None, 'amr:role_op1', 'amr:role_op2'] 
              
 def __search_pattern(graph):
@@ -56,31 +54,36 @@ def __search_pattern(graph):
 # Useful Additional Search
 #==============================================================================
 
-def __search_degree_arg4(graph, degree_net_uri):
-    select_data_list = ['?comparated_class_net']
-    clause_list = [(degree_net_uri, ARG_RELATION[4], '?comparated_class_net'),
-                   '?comparated_class_net a [rdfs:subClassOf* net:Class_Net].', 
-                   'FILTER NOT EXISTS {{ ?comparated_class_net a net:Deprecated_Net. }}']
+ARG_RELATION = [None, 'amr:role_ARG1', 'amr:role_ARG2', 'amr:role_ARG3',
+                'amr:role_ARG4', 'amr:role_ARG5', 'amr:role_ARG6'] 
+
+
+def __search_remain_arg1(graph, remain_net_uri):
+    select_data_list = ['?remain_class_net']
+    clause_list = [(remain_net_uri, ARG_RELATION[1], '?remain_class_net'),
+                   '?remain_class_net a [rdfs:subClassOf* net:Class_Net].', 
+                   'FILTER NOT EXISTS {{ ?remain_class_net a net:Deprecated_Net. }}']
     query_code = generate_select_distinct_query(graph, select_data_list, clause_list)
     result_set = graph.query(query_code) 
     return query_code, result_set
 
 
-def __search_degree_arg5(graph, degree_net_uri):
-    select_data_list = ['?superlative_class_net']
-    clause_list = [(degree_net_uri, ARG_RELATION[5], '?superlative_class_net'),
-                   '?superlative_class_net a [rdfs:subClassOf* net:Class_Net].', 
-                   'FILTER NOT EXISTS {{ ?superlative_class_net a net:Deprecated_Net. }}']
+def __search_degree_feature(graph, degree_net_uri):
+    select_data_list = ['?feature_individual_net']
+    clause_list = [(degree_net_uri, 'net:hasFeatureNet', '?feature_individual_net'),
+                   '?feature_individual_net a [rdfs:subClassOf* net:Individual_Net].', 
+                   f'?feature_individual_net net:hasClassType {FEATURE_CLASS_TYPE}.',
+                   'FILTER NOT EXISTS {{ ?feature_individual_net a net:Deprecated_Net. }}']
     query_code = generate_select_distinct_query(graph, select_data_list, clause_list)
     result_set = graph.query(query_code) 
     return query_code, result_set
 
 
-def __search_degree_arg6(graph, degree_net_uri):
-    select_data_list = ['?reference_net']
-    clause_list = [(degree_net_uri, ARG_RELATION[6], '?reference_net'),
-                   '?reference_net a [rdfs:subClassOf* net:Class_Net].',
-                   'FILTER NOT EXISTS {{ ?reference_net a net:Deprecated_Net. }}']
+def __search_degree_arg5(graph, degree_net_uri):
+    select_data_list = ['?superlative_class_net']
+    clause_list = [(degree_net_uri, ARG_RELATION[5], '?superlative_class_net'),
+                   '?superlative_class_net a [rdfs:subClassOf* net:Class_Net].']
+                   # 'FILTER NOT EXISTS {{ ?superlative_class_net a net:Deprecated_Net. }}']
     query_code = generate_select_distinct_query(graph, select_data_list, clause_list)
     result_set = graph.query(query_code) 
     return query_code, result_set
@@ -90,14 +93,38 @@ def __search_degree_arg6(graph, degree_net_uri):
 # Useful Computation Method(s)
 #==============================================================================  
 
+def __filter_mother_class(graph, class_net_uri_set):
+    result_list = []
+    
+    class_net_uri_set_length = len(class_net_uri_set)
+    for row1 in class_net_uri_set:
+        class_net_uri_1 = row1.remain_class_net
+        check = True
+        for row2 in class_net_uri_set:
+            class_net_uri_2 = row2.remain_class_net
+            if class_net_uri_1 != class_net_uri_2:
+                class_net_2 = net.ClassNet(graph, uri=class_net_uri_2)
+                if class_net_uri_1 in class_net_2.mother_class_net:
+                    check = False
+        if check : result_list.append(class_net_uri_1)
+       
+    return result_list
+    
+    
 def __extract_naming(net, default='none'):
     naming = f'{default}'
     naming_list = net.naming
     if len(naming_list) > 0:
-        assert len(naming_list) == 1, f'Houston, we have a problem: too many naming'
+        assert len(naming_list) == 1, 'Houston, we have a problem: too many naming'
         naming = naming_list[0]
     return naming
 
+
+def __define_opposite_feature_naming(class_net):
+    feature_name = __extract_naming(class_net, default='something')
+    return f'not-{feature_name}'
+
+
 def __define_feature_restriction_naming(class_net):
     name = __extract_naming(class_net, default='something')
     return f'{name}-feature'
@@ -129,6 +156,28 @@ def __propagate_relation(target_net, base_net, phenomena_net):
 # Construct Method(s)
 #==============================================================================
 
+def __construct_opposite_feature_individual_net(graph, feature_individual_net):
+
+    # -- Net Composition
+    opposite_individual_net = net.IndividualNet(graph)
+    opposite_individual_net.compose(feature_individual_net)
+    
+    # -- Data Computation
+    opposite_individual_net.class_type = FEATURE_CLASS_TYPE
+    # individual_net.mother_class_net = class_net.uri
+
+    # -- Net Naming
+    opposite_naming = __define_opposite_feature_naming(feature_individual_net)
+    opposite_individual_net.naming = opposite_naming
+    opposite_individual_net.individual_label = opposite_naming
+    
+    # -- Finalization
+    opposite_individual_net.finalize()
+    result_triple_list = opposite_individual_net.generate_triple_definition()
+    
+    return opposite_individual_net, result_triple_list  
+
+
 def __construct_feature_restriction_net(graph, individual_net):
     
     restriction_net = net.RestrictionNet(graph)
@@ -151,78 +200,19 @@ def __construct_feature_restriction_net(graph, individual_net):
     
         
 
-def __construct_composite_class_net(graph, class_net_1, individual_net, phenomena_net):
-
-    # -- Net Composition
-    composite_class_net = net.CompositeClassNet(graph)
-    composite_class_net.compose(class_net_1, individual_net)
-    
-    # -- Data Computation
-    composite_class_net.mother_class_net = class_net_1.uri
-    composite_class_net.root_class_net = class_net_1.root_class_net
+def __add_feature_restriction(graph, target_class_net, feature_individual_net):
 
     # -- Restriction Computation
     triple_list_1 = []
-    restriction_net, triple_list_1 = __construct_feature_restriction_net(graph, individual_net)
-    composite_class_net.restriction = restriction_net.uri 
-
-    # -- Net Naming
-    composite_class_net.naming = __define_composite_naming(class_net_1, individual_net)
-    
-    # -- Relation Propagation
-    __propagate_relation(composite_class_net, class_net_1, phenomena_net)
+    restriction_net, triple_list_1 = __construct_feature_restriction_net(graph, feature_individual_net)
+    target_class_net.restriction = restriction_net.uri 
     
     # -- Finalization
-    composite_class_net.finalize()
-    triple_list_2 = composite_class_net.generate_triple_definition()
+    target_class_net.finalize()
+    triple_list_2 = target_class_net.generate_triple_definition()
     result_triple_list = triple_list_1 + triple_list_2
     
-    return composite_class_net, result_triple_list
-    
-    
-
-def __construct_degree_individual_net(graph, degree_property_net):
-
-    # -- Net Composition
-    individual_net = net.IndividualNet(graph)
-    individual_net.compose(degree_property_net)
-    
-    # -- Data Computation
-    individual_net.class_type = DEGREE_CLASS_TYPE
-    # individual_net.mother_class_net = class_net.uri
-
-    # -- Net Naming
-    individual_net.naming = f'{__extract_naming(degree_property_net, default="something")}'
-    individual_net.individual_label = f'{__extract_naming(degree_property_net, default="something")}'
-    
-    # -- Finalization
-    individual_net.finalize()
-    result_triple_list = individual_net.generate_triple_definition()
-    
-    return individual_net, result_triple_list  
-    
-    
-
-def __construct_feature_individual_net(graph, feature_class_net, degree_individual_net):
-
-    # -- Net Composition
-    individual_net = net.IndividualNet(graph)
-    individual_net.compose(feature_class_net, degree_individual_net)
-    
-    # -- Data Computation
-    individual_net.class_type = FEATURE_CLASS_TYPE
-    # individual_net.mother_class_net = class_net.uri
-
-    # -- Net Naming
-    individual_name = __define_composite_naming(feature_class_net, degree_individual_net)
-    individual_net.naming = individual_name
-    individual_net.individual_label = individual_name
-    
-    # -- Finalization
-    individual_net.finalize()
-    result_triple_list = individual_net.generate_triple_definition()
-    
-    return individual_net, result_triple_list  
+    return target_class_net, result_triple_list  
     
 
 
@@ -251,35 +241,36 @@ def analyze_specific_pattern_1(graph):
         degree_phenomena_net = net.PhenomenaNet(graph, uri=pattern.degree_phenomena_net)
         remain_property_net = net.PropertyNet(graph, uri=pattern.remain_property_net)
                 
-        # -- New Net Construction(s)
-        
-        # degree_individual_net, triple_list_1 = __construct_degree_individual_net(graph, degree_property_net)
-        
-        # feature_individual_net, triple_list_2 = __construct_feature_individual_net(
-        #     graph, attribute_class_net, degree_individual_net)
-        
-        # new_entity_class_net, triple_list_3 = __construct_composite_class_net(
-        #     graph, entity_class_net, feature_individual_net, degree_phenomena_net)  
-        
-        # rule_triple_list += (triple_list_1 + triple_list_2 + triple_list_3)
-        
-        # -- Comparison Handle (ARG4)
-        _, comparated_class_set = __search_degree_arg4(graph, degree_phenomena_net.uri)
-        for row in comparated_class_set:
-            pass #TODO: uri=row.comparated_class_net
+        # -- Degree91 Feature Handle
+        _, feature_individual_set = __search_degree_feature(graph, degree_phenomena_net.uri)
+        feature_individual_net_list = []
+        for row in feature_individual_set:
+            feature_individual_net = net.IndividualNet(graph, uri=row.feature_individual_net)
+            feature_individual_net, new_triples = ( 
+                __construct_opposite_feature_individual_net(graph, feature_individual_net))
+            feature_individual_net_list.append(feature_individual_net)
+            rule_triple_list.extend(new_triples)
+            
+        # -- Search for target class net (remain ARG1)
+        _, arg1_class_set = __search_remain_arg1(graph, remain_property_net.uri)
+        target_class_list = __filter_mother_class(graph, arg1_class_set)
+            
+        # -- Adding Restriction on remain ARG1
+        for feature_individual_net in feature_individual_net_list:
+            for target_class_uri in target_class_list:
+                target_class_net = net.ClassNet(graph, uri=target_class_uri)
+                _, new_triples = __add_feature_restriction(graph, target_class_net, feature_individual_net)
+                rule_triple_list.extend(new_triples)
         
         # -- Superlative Handle (ARG5)
         _, superlative_set = __search_degree_arg5(graph, degree_phenomena_net.uri)
-        # for row in superlative_set:
-        #     superlative_class_net = net.ClassNet(graph, uri=row.superlative_class_net)
-        #     _, triple_list_5 = __associate_mother_relation_to_refine(
-        #         graph, new_entity_class_net, superlative_class_net)
-        #     rule_triple_list += triple_list_5
-        
-        # -- Reference Handle (ARG6)
-        _, reference_set = __search_degree_arg6(graph, degree_phenomena_net.uri)
-        for row in reference_set:
-            pass #TODO: uri=row.reference_net
+        for row in superlative_set:
+            superlative_class_net = net.ClassNet(graph, uri=row.superlative_class_net)
+            for target_class_uri in target_class_list:
+                target_class_net = net.ClassNet(graph, uri=target_class_uri)
+                _, triple_list_5 = __associate_mother_relation_to_refine(
+                    graph, target_class_net, superlative_class_net)
+                rule_triple_list += triple_list_5
         
         # -- Deprecation: Origin Class Nets
         rule_triple_list += degree_phenomena_net.deprecate()

tenet/scheme/owl_amr_scheme_1.py

@@ -119,6 +119,9 @@ classification_sequence_2 = ['classification sequence (2)',
                              rule.propagate_individual_2
                              ]
 
+specif_pattern_analyze_sequence = ['specific pattern analyze sequence',
+                                   rule.analyze_specific_pattern_1]
+
 heuristic_deduction_sequence = ['heuristic deduction sequence',
                                 rule.refine_composite_class,
                                 rule.refine_mother_relation,
@@ -154,6 +157,7 @@ scheme = {
                      phenomena_analyze_sequence_2,
                      composite_class_extraction_sequence,
                      classification_sequence_2,
+                     specif_pattern_analyze_sequence,
                      heuristic_deduction_sequence
                      ],
     

tenet/transduction/net/class_net.py

@@ -34,12 +34,17 @@ class ClassNet(Net):
         self.type_uri = produce_uriref(self.support_graph, f'net:{self.type_id}')
         
         # -- Net Attributes
-        self.attr_list += ['class_name', 'class_uri', 'class_type', 'mother_class_net', 'root_class_net']
+        self.attr_list += ['class_name', 'class_uri', 'class_type', 
+                           'mother_class_net', 'root_class_net',
+                           'mother_class_net_to_refine',
+                           'restriction']
         self._class_name = None
         self._class_uri = None
         self._class_type = None
         self._mother_class_net = None
         self._root_class_net = None
+        self._mother_class_net_to_refine = None
+        self._restriction = []
   
         
     #--------------------------------------------------------------------------
@@ -97,3 +102,24 @@ class ClassNet(Net):
     @root_class_net.setter
     def root_class_net(self, new_value):
         self._root_class_net = self.set_attribute_value_list(new_value, produce_uriref)
+            
+    @property
+    def mother_class_net_to_refine(self):
+        if self._mother_class_net_to_refine is None: 
+            self._mother_class_net_to_refine = self.get_value_list_from_graph('mother_class_net_to_refine')
+        return self._mother_class_net_to_refine
+    
+    @mother_class_net_to_refine.setter
+    def mother_class_net_to_refine(self, new_value):
+        self._mother_class_net_to_refine = self.set_attribute_value_list(new_value, produce_uriref)
+
+        
+    @property
+    def restriction(self):
+        if self._restriction == []: 
+            self._restriction = self.get_value_list_from_graph('restriction')
+        return self._restriction
+    
+    @restriction.setter
+    def restriction(self, new_value):
+        self._restriction = self.set_attribute_value_list(new_value, produce_uriref)
\ No newline at end of file

tenet/transduction/net/phenomena_net.py

@@ -34,9 +34,10 @@ class PhenomenaNet(Net):
         self.type_uri = produce_uriref(self.support_graph, f'net:{self.type_id}')
         
         # -- Net Attributes
-        self.attr_list += ['phenomena_type', 'phenomena_ref']
+        self.attr_list += ['phenomena_type', 'phenomena_ref', 'feature_net']
         self._phenomena_type = None
         self._phenomena_ref = None
+        self._feature_net = None
   
         
     #--------------------------------------------------------------------------
@@ -63,3 +64,13 @@ class PhenomenaNet(Net):
     @phenomena_ref.setter
     def phenomena_ref(self, new_value):
         self._phenomena_ref = self.set_attribute_value_list(new_value, produce_literal)
+
+    @property
+    def feature_net(self):
+        if self._feature_net is None: 
+            self._feature_net = self.get_value_list_from_graph('feature_net')
+        return self._feature_net
+    
+    @feature_net.setter
+    def feature_net(self, new_value):
+        self._feature_net = self.set_attribute_value_list(new_value, produce_uriref)

tenet/transduction/semantic_net_rdf_reference.py

@@ -64,6 +64,7 @@ class SemanticNetReferenceHandle:
             # Phenomena Net
             'phenomena_type':               'hasPhenomenaType',
             'phenomena_ref':                'hasPhenomenaRef',
+            'feature_net':                  'hasFeatureNet',
             
             # Composite Net Restriction
             'restriction':                  'hasRestriction',

tests/dev_owl_rule_tests/test_data/specific-devGraph-1.ttl

@@ -621,6 +621,7 @@ net:phenomena_degree_h2 a net:Phenomena_Net ;
     :role_ARG3 net:atomProperty_more_m2 ;
     net:coverBaseNode :leaf_have-degree-91_h2 ;
     net:coverNode :leaf_have-degree-91_h2 ;
+    net:hasFeatureNet net:individual_more-small_s2 ;
     net:hasNaming "degree" ;
     net:hasPhenomenaRef "have-degree-91" ;
     net:hasPhenomenaType :phenomena_degree ;
@@ -980,6 +981,7 @@ net:phenomena_degree_h a net:Phenomena_Net ;
     :role_ARG5 net:atomClass_object_o ;
     net:coverBaseNode :leaf_have-degree-91_h ;
     net:coverNode :leaf_have-degree-91_h ;
+    net:hasFeatureNet net:individual_most-large_l ;
     net:hasNaming "degree" ;
     net:hasPhenomenaRef "have-degree-91" ;
     net:hasPhenomenaType :phenomena_degree ;
@@ -1435,28 +1437,6 @@ net:individual_dwarf_d2 a net:Individual_Net ;
     net:hasNaming "dwarf" ;
     net:hasStructure "SSC-02-01" .
 
-net:individual_more-small_s2 a net:Individual_Net ;
-    net:composeFrom net:atomClass_small_s2,
-        net:individual_more_m2 ;
-    net:coverBaseNode :leaf_small_s2 ;
-    net:coverNode :leaf_more_m2,
-        :leaf_small_s2 ;
-    net:hasClassType sys:Feature ;
-    net:hasIndividualLabel "more-small" ;
-    net:hasNaming "more-small" ;
-    net:hasStructure "SSC-02-01" .
-
-net:individual_most-large_l a net:Individual_Net ;
-    net:composeFrom net:atomClass_large_l,
-        net:individual_most_m ;
-    net:coverBaseNode :leaf_large_l ;
-    net:coverNode :leaf_large_l,
-        :leaf_most_m ;
-    net:hasClassType sys:Feature ;
-    net:hasIndividualLabel "most-large" ;
-    net:hasNaming "most-large" ;
-    net:hasStructure "SSC-02-01" .
-
 net:value_SolarSystem_blankNode a net:Value_Net ;
     net:coverAmrValue :value_SolarSystem ;
     net:hasNaming "SolarSystem" ;
@@ -1525,6 +1505,28 @@ net:individual_body-SSC-02-01_b a net:Individual_Net ;
     net:hasNaming "body-SSC-02-01" ;
     net:hasStructure "SSC-02-01" .
 
+net:individual_more-small_s2 a net:Individual_Net ;
+    net:composeFrom net:atomClass_small_s2,
+        net:individual_more_m2 ;
+    net:coverBaseNode :leaf_small_s2 ;
+    net:coverNode :leaf_more_m2,
+        :leaf_small_s2 ;
+    net:hasClassType sys:Feature ;
+    net:hasIndividualLabel "more-small" ;
+    net:hasNaming "more-small" ;
+    net:hasStructure "SSC-02-01" .
+
+net:individual_most-large_l a net:Individual_Net ;
+    net:composeFrom net:atomClass_large_l,
+        net:individual_most_m ;
+    net:coverBaseNode :leaf_large_l ;
+    net:coverNode :leaf_large_l,
+        :leaf_most_m ;
+    net:hasClassType sys:Feature ;
+    net:hasIndividualLabel "most-large" ;
+    net:hasNaming "most-large" ;
+    net:hasStructure "SSC-02-01" .
+
 net:typeProperty a owl:AnnotationProperty ;
     rdfs:label "type property" .
 

tests/dev_owl_rule_tests/test_rule_deducer_mother_relation.py

@@ -123,14 +123,14 @@ if __name__ == '__main__':
     graph_1 = load_test_graph(TEST_FILE_NAME_1)
     print('\n \n')
     
-    print('\n ///////////////////// Relation Deduction Rule')
+    print('\n ///////////////////// Deduction Rule')
     
     print('\n *** Step Test ***')
+    
     print('\n -- Step 1: Search Pattern for Deducer')
     pattern_set = test_search_pattern_deducer(graph_1)
     print('\n \n')
         
-    
     print('\n -- Step 2: Search Parent Class Related to Same Node')
     class_net_uri = 'https://tenet.tetras-libre.fr/semantic-net#atomClass_object_o'
     pattern_set = test_search_parent_class_related_to_same_node(graph_1, class_net_uri)

tests/dev_owl_rule_tests/test_rule_specific_analyzer_degree_remain.py

@@ -100,6 +100,39 @@ def test_search_pattern_1(graph):
     return pattern_set
         
 
+def test_search_degree_feature(graph, degree_net_uri):
+    print(f'\n ----- search degree feature for following net: {degree_net_uri}')
+    _, pattern_set = rule_1.__search_degree_feature(graph, degree_net_uri)
+    print(f'\n ----- number of selection found: {len(pattern_set)}')
+    for row in pattern_set: 
+        result_str = f'>>> '
+        result_str += f'{row.feature_individual_net.n3(graph.namespace_manager)}'
+        print(result_str) 
+    return pattern_set
+        
+
+def test_search_remain_arg1(graph, remain_net_uri):
+    print(f'\n ----- search argument 1 from following net: {remain_net_uri}')
+    _, pattern_set = rule_1.__search_remain_arg1(graph, remain_net_uri)
+    print(f'\n ----- number of selection found: {len(pattern_set)}')
+    for row in pattern_set: 
+        result_str = f'>>> '
+        result_str += f'{row.remain_class_net.n3(graph.namespace_manager)}'
+        print(result_str) 
+    return pattern_set
+    
+
+def test_search_degree_arg5(graph, degree_net_uri):
+    print(f'\n ----- search ARG5 for following net: {degree_net_uri}')
+    _, pattern_set = rule_1.__search_degree_arg5(graph, degree_net_uri)
+    print(f'\n ----- number of selection found: {len(pattern_set)}')
+    for row in pattern_set: 
+        result_str = f'>>> '
+        result_str += f'{row.superlative_class_net.n3(graph.namespace_manager)}'
+        print(result_str) 
+    return pattern_set
+
+
 
 #==============================================================================
 # Unit Test
@@ -129,11 +162,29 @@ if __name__ == '__main__':
     print('\n ///////////////////// Extraction Rule 1')
     
     print('\n *** Step Test ***')
+    
+    print('\n -- Step 1: Search Pattern')
     pattern_set = test_search_pattern_1(graph_1)
     print('\n \n')
     
+    print('\n -- Step 2: Degree91 Feature Handle')
+    degree_net_uri = 'https://tenet.tetras-libre.fr/semantic-net#phenomena_degree_h'
+    pattern_set = test_search_degree_feature(graph_1, degree_net_uri)
+    print('\n \n')
+    
+    print('\n -- Step 3: Search for target class net (remain ARG1)')
+    remain_net_uri = 'https://tenet.tetras-libre.fr/semantic-net#atomProperty_remain_r'
+    pattern_set = test_search_remain_arg1(graph_1, remain_net_uri)
+    print('\n \n')
+    
+    print('\n -- Step 4: Superlative Handle (ARG5)')
+    degree_net_uri = 'https://tenet.tetras-libre.fr/semantic-net#phenomena_degree_h'
+    pattern_set = test_search_degree_arg5(graph_1, degree_net_uri)
+    print('\n \n')
+        
+    
     print('\n *** Unit Test ***')
-    # test_rule_application(TEST_FILE_NAME_1, graph_1, rule_1.analyze_phenomena_degree91_1)
+    test_rule_application(TEST_FILE_NAME_1, graph_1, rule_1.analyze_specific_pattern_1)
     print('\n \n')
 
     print('\n *** - ***')
\ No newline at end of file

tests/main_tests/test_main_owl_extraction.py

@@ -56,7 +56,7 @@ test_data_dir = f'{INPUT_DIR_PATH}amrDocuments/'
 # onto_prefix = f'SimpleTest'
 # base_output_name = f'SimpleTest'
 
-uuid_num = '02'
+uuid_num = '01'
 amrld_dir_path = f'{test_data_dir}dev/solar-system-{uuid_num}/'
 amrld_file_path = f'{amrld_dir_path}SSC-{uuid_num}-01.stog.amr.ttl'
 base_output_name = f'SolarSystemDev{uuid_num}'