phenomena_application_or.py

#!/usr/bin/python3.10
# -*-coding:Utf-8 -*

#==============================================================================
# TENET: AMR CTR at 'Net Expansion' level for phenomena application (or)
#------------------------------------------------------------------------------
# Module grouping compositional transduction rule_sets (CTR) for the analysis 
# of AMR structures, at 'Net Expansion' level
#==============================================================================

import subprocess, os
from rdflib import Graph
from rdflib import Namespace
from rdflib.namespace import NamespaceManager

if __name__ == '__main__':
    import os, sys
    LIB_PATH = f'{os.path.dirname(os.path.abspath(__file__))}/..'
    sys.path.insert(0, os.path.abspath(LIB_PATH))
    print(sys.path[0])

import febTransduction as transduction
from febTransduction import net
from febTransduction.query_builder import generate_select_query
from febTransduction.naming_computer import define_composite_naming_1


#==============================================================================
# Rule with pattern property(class, or_phenomena)
#==============================================================================

def __select_pattern_1():
    
    # -- Select Data List
    select_data_list = ['?property_net', '?class_net', '?phenomena_net']
    
    # -- Clause List
    clause_list = []
    clause_list.append(f'?property_net a [rdfs:subClassOf* net:Property_Net].')
    clause_list.append(f'?class_net a [rdfs:subClassOf* net:Class_Net].')
    clause_list.append(f'?phenomena_net a [rdfs:subClassOf* net:Phenomena_Net].')
    clause_list.append(f'?phenomena_net net:hasPhenomenaType amr:phenomena_conjunction_or.')
    clause_list.append(f'?property_net amr:role_ARG0 ?class_net.')
    clause_list.append(f'?property_net amr:role_ARG1 ?phenomena_net.')
    
    # -- Query Generation
    query_code = transduction.query_builder.generate_select_query(select_data_list, clause_list)
    
    return query_code

    # pattern = transduction.Pattern('class_net', 'property_net', 'phenomena_net')
    # pattern.add_identification_pattern(phenomena_net, phenomena_type='amr:phenomena_conjunction_or')
    # pattern.add_composition_pattern(property_net, 'amr:role_ARG0', class_net_0)
    # pattern.add_composition_pattern(property_net, 'amr:role_ARG1', phenomena_net)
    # pattern_query = pattern.get_select_query()
    # return pattern_query
    
    
def __op_pattern_1(phenomena_net_uri, num):
    
    assert 1 <= num <= 9 
    
    # -- Select Data List
    select_data_list = ['?class_net']
    
    # -- Clause List
    clause_list = []
    clause_list.append(f'?class_net a [rdfs:subClassOf* net:Class_Net].')
    clause_list.append(f'{phenomena_net_uri} amr:role_op{num} ?class_net.')
    
    # -- Query Generation
    query_code = transduction.query_builder.generate_select_query(select_data_list, clause_list)
    
    return query_code
    

def __define_restriction(net, op_set): # TODO
    pass
    return net
    
    
def analyze_phenomena_or_1(graph):
    
    # -- Rule Initialization 
    rule_label = '"or" phenomena analysis 1 [ property(class, or_phenomena) ]'
    print(f"--- *** February Transduction *** Sequence: {rule_label}")
    #logger.info(f"--- *** February Transduction *** Sequence: {rule_label}")   

    # -- Selection Pattern Application  
    query_code = __select_pattern_1()
    pattern_set = graph.query(query_code) 
    
    # -- New Net Computing
    new_triple_list = []
    for selection in pattern_set:
        
        # -- Net Composition
        class_net = net.ClassNet(graph, selection.class_net)
        property_net = net.PropertyNet(graph, selection.property_net)
        phenomena_net = net.PhenomenaNet(graph, selection.phenomena_net)
        composite_class_net = net.CompositeClassNet(graph)
        composite_class_net.compose(class_net, property_net, phenomena_net)
    
        # -- Data Computation
        composite_class_net.mother_class_net = class_net.uri
        # etc
    
        # -- Restriction Computation
        pass # TODO
        # for num in range(1, 9+1):
        #     query_code = __op_pattern_1(selection.phenomena_net, num)
        #     op_set = graph.query(query_code) 
        #     composite_class_net = __define_restriction(composite_class_net, op_set)
    
        # -- Relation Propagation
        pass # TODO
        # for (n1, rel, _) in class_net.input_relation_list:
        #     composite_class_net.add_input_relation(n1, rel)
            # TODO: à voir si on veut d'autres relations
    
        # -- Net Naming
        composite_class_net.naming = define_composite_naming_1(class_net, property_net, phenomena_net)
        
        # -- Finalization
        composite_class_net.finalize()
        new_triples = composite_class_net.generate_triple_definition()
        new_triple_list.append(new_triples)
    
    return rule_label, new_triple_list


#==============================================================================
# Rule with pattern property(property, or_phenomena)
#==============================================================================

def __select_pattern_2():
    
    # -- Select Data List
    select_data_list = ['?property_net', '?property_net_0', '?phenomena_net']
    
    # -- Clause List
    clause_list = []
    clause_list.append(f'?property_net a [rdfs:subClassOf* net:Property_Net].')
    clause_list.append(f'?property_net_0 a [rdfs:subClassOf* net:Property_Net].')
    clause_list.append(f'?phenomena_net a [rdfs:subClassOf* net:Phenomena_Net].')
    clause_list.append(f'?phenomena_net net:hasPhenomenaType amr:phenomena_conjunction_or.')
    clause_list.append(f'?property_net amr:role_ARG0 ?property_net_0.')
    clause_list.append(f'?property_net amr:role_ARG1 ?phenomena_net.')
    
    # -- Query Generation
    query_code = transduction.query_builder.generate_select_query(select_data_list, clause_list)
    
    return query_code


def analyze_phenomena_or_2(graph):
    
    # -- Rule Initialization 
    rule_label = '"or" phenomena analysis 2 [ property(property, or_phenomena) ]'
    print(f"--- *** February Transduction *** Sequence: {rule_label}")  

    # -- Selection Pattern Application  
    query_code = __select_pattern_2()
    pattern_set = graph.query(query_code) 
    
    # -- New Net Computing
    new_triple_list = []
    for selection in pattern_set:
        
        # -- Net Composition
        property_net_0 = net.PropertyNet(graph, uri=selection.property_net_0) 
        property_net = net.PropertyNet(graph, uri=selection.property_net)
        phenomena_net = net.PhenomenaNet(graph, uri=selection.phenomena_net)
        composite_class_net = net.CompositeClassNet(graph)
        composite_class_net.compose(property_net_0, property_net, phenomena_net)
    
        # -- Data Computation
        composite_class_net.mother_class_net = property_net_0.uri
        # etc
    
        # -- Restriction Computation
        pass # TODO
        # for num in range(1, 9+1):
        #     query_code = __op_pattern_1(selection.phenomena_net, num)
        #     op_set = graph.query(query_code) 
        #     composite_class_net = __define_restriction(composite_class_net, op_set)
    
        # -- Relation Propagation
        pass # TODO
        # for (n1, rel, _) in class_net.input_relation_list:
        #     composite_class_net.add_input_relation(n1, rel)
            # TODO: à voir si on veut d'autres relations
    
        # -- Net Naming
        composite_class_net.naming = define_composite_naming_1(property_net_0, property_net, phenomena_net)
        
        # -- Finalization
        composite_class_net.finalize()
        new_triples = composite_class_net.generate_triple_definition()
        new_triple_list += new_triples
    
    return rule_label, new_triple_list