Skip to content
Snippets Groups Projects
Commit bc914e73 authored by Aurélien Lamercerie's avatar Aurélien Lamercerie
Browse files

Define semantic net classes

parent 4ed5dff7
No related branches found
No related tags found
No related merge requests found
Showing
with 4223 additions and 2751 deletions
from .semantic_net_rdf_reference import SemanticNetReferenceHandle
from .net import Net
from .class_net import ClassNet
from .atom_class_net import AtomClassNet
from .composite_class_net import CompositeClassNet
from .or_composite_class_net import OrCompositeClassNet
# from .and_composite_class_net import AndCompositeClassNet
from .property_net import PropertyNet
from .atom_property_net import AtomPropertyNet
......@@ -12,4 +12,8 @@ from .composite_property_net import CompositePropertyNet
from .individual_net import IndividualNet
from .value_net import ValueNet
from .phenomena_net import PhenomenaNet
from .restriction_net import RestrictionNet
......@@ -2,16 +2,12 @@
# -*-coding:Utf-8 -*
#==============================================================================
# TENET: Atom Class Net Query Builder
# TENET: Atom Class
#------------------------------------------------------------------------------
# Class to generate SPARQL query parts related to semantic nets
# Class to handle semantic nets
#==============================================================================
#==============================================================================
# Importing required modules
#==============================================================================
from .class_net import ClassNet
from febTransduction.net import ClassNet
#==============================================================================
......@@ -19,20 +15,19 @@ from .class_net import ClassNet
#==============================================================================
class AtomClassNet(ClassNet):
""" Class to generate SPARQL query parts related to semantic nets.
""" Class to handle semantic net.
"""
#--------------------------------------------------------------------------
# Constructor(s)
#--------------------------------------------------------------------------
def __init__(self, num=''):
def __init__(self, support_graph, uri=None):
# -- Net Signature
# -- Parent init
super().__init__(support_graph, uri)
# -- Net Type
self.type_name = 'atomClass'
self.type_id = 'Atom_Class_Net'
self.id = f'?{self.type_name}Net{num}'
self.type_uri = f'net:{self.type_id}'
\ No newline at end of file
# -- Parent init
super().__init__(signature=True)
\ No newline at end of file
......@@ -2,16 +2,12 @@
# -*-coding:Utf-8 -*
#==============================================================================
# TENET: Atom Property Net Query Builder
# TENET: Atom Property
#------------------------------------------------------------------------------
# Class to generate SPARQL query parts related to semantic nets
# Class to handle semantic nets
#==============================================================================
#==============================================================================
# Importing required modules
#==============================================================================
from .property_net import PropertyNet
from febTransduction.net import PropertyNet
#==============================================================================
......@@ -19,39 +15,87 @@ from .property_net import PropertyNet
#==============================================================================
class AtomPropertyNet(PropertyNet):
""" Class to generate SPARQL query parts related to semantic nets.
""" Class to handle semantic net.
"""
#--------------------------------------------------------------------------
# Constructor(s)
#--------------------------------------------------------------------------
def __init__(self, num=''):
def __init__(self, support_graph, uri=None):
# -- Net Signature
# -- Parent init
super().__init__(support_graph, uri)
# -- Net Type
self.type_name = 'atomProperty'
self.type_id = 'Atom_Property_Net'
self.id = f'?{self.type_name}Net{num}'
self.type_uri = f'net:{self.type_id}'
# -- Parent init
super().__init__(signature=True)
# -- Net Attributes
self.core_role = f'{self.id}CoreRole'
self.target_argument_node = f'{self.id}TargetArgumentNode'
self.property_type = f'{self.id}PropertyType'
#self.property_name = f'{self.id}PropertyName'
self.property_name01 = f'{self.id}PropertyName01'
self.property_name10 = f'{self.id}PropertyName10'
self.property_name12 = f'{self.id}PropertyName12'
self.predicate_table.update({
'core_role': 'isCoreRoleLinked',
'target_argument_node': 'targetArgumentNode',
'property_type': 'hasPropertyType',
#'property_name': 'hasPropertyName',
'property_name01': 'hasPropertyName01',
'property_name10': 'hasPropertyName10',
'property_name12': 'hasPropertyName12'
})
\ No newline at end of file
self._core_role = None
self._target_argument_node = []
self._property_type = None
#self._property_name = None
self._property_name01 = None
self._property_name10 = None
self._property_name12 = None
#--------------------------------------------------------------------------
# Accessors for Net Attributes
#--------------------------------------------------------------------------
@property
def core_role(self):
self._core_role = super().get_attribute_value(core_role=self._core_role)
return self._core_role
@core_role.setter
def core_role(self, new_value):
self._core_role = new_value
@property
def target_argument_node(self):
self._target_argument_node = super().get_attribute_value(target_argument_node=self._target_argument_node)
return self._target_argument_node
@target_argument_node.setter
def target_argument_node(self, new_value):
self._target_argument_node = new_value
@property
def property_type(self):
self._property_type = super().get_attribute_value(property_type=self._property_type)
return self._property_type
@property_type.setter
def property_type(self, new_value):
self._property_type = new_value
@property
def property_name01(self):
self._property_name01 = super().get_attribute_value(property_name01=self._property_name01)
return self._property_name01
@property_name01.setter
def property_name01(self, new_value):
self._property_name01 = new_value
@property
def property_name10(self):
self._property_name10 = super().get_attribute_value(property_name10=self._property_name10)
return self._property_name10
@property_name10.setter
def property_name10(self, new_value):
self._property_name10 = new_value
@property
def property_name12(self):
self._property_name12 = super().get_attribute_value(property_name12=self._property_name12)
return self._property_name12
@property_name12.setter
def property_name12(self, new_value):
self._property_name12 = new_value
\ No newline at end of file
......@@ -2,16 +2,12 @@
# -*-coding:Utf-8 -*
#==============================================================================
# TENET: Class Net Query Builder
# TENET: Class Net
#------------------------------------------------------------------------------
# Class to generate SPARQL query parts related to semantic nets
# Class to handle semantic nets
#==============================================================================
#==============================================================================
# Importing required modules
#==============================================================================
from .net import Net
from febTransduction.net import Net
#==============================================================================
......@@ -19,63 +15,36 @@ from .net import Net
#==============================================================================
class ClassNet(Net):
""" Class to generate SPARQL query parts related to semantic nets.
""" Class to handle semantic net.
"""
#--------------------------------------------------------------------------
# Constructor(s)
#--------------------------------------------------------------------------
def __init__(self, num='', signature=False):
def __init__(self, support_graph, uri=None):
# -- Parent init
super().__init__(support_graph, uri)
# -- Net Signature
if not signature:
# -- Net Type
self.type_name = 'class'
self.type_id = 'Class_Net'
self.id = f'?{self.type_name}Net{num}'
self.type_uri = f'net:{self.type_id}'
# -- Parent init
super().__init__(signature=True)
# -- Net Attributes
self.class_name = f'{self.id}ClassName'
self.predicate_table.update({
'class_name': 'hasClassName'
})
self._class_name = None
#==============================================================================
# Development Test
#==============================================================================
if __name__ == '__main__':
print('\n' + ' *** Development Test ***')
print('\n' + ' -- test: Net')
net = AtomClassNet()
print(net)
print('\n' + ' -- test: update a test query')
test_query= f"""[...]
CONSTRUCT {{
{net.construct(base_node='?node1',
class_name='system')}
}}
WHERE {{
clause_1
clause_2
{net.complete_clauses_for_construction('?node1')}
#--------------------------------------------------------------------------
# Accessors for Net Attributes
#--------------------------------------------------------------------------
{net.bind_uri('{{node1.concept_label}}',
'{{node1.variable_label}}')}
}}
"""
print(test_query)
@property
def class_name(self):
self._class_name = super().get_attribute_value(class_name=self._class_name)
return self._class_name
print('\n' + ' *** - ***')
\ No newline at end of file
@class_name.setter
def class_name(self, new_value):
self._class_name = new_value
\ No newline at end of file
......@@ -2,16 +2,12 @@
# -*-coding:Utf-8 -*
#==============================================================================
# TENET: Atom Class Net Query Builder
# TENET: Composite Class Net
#------------------------------------------------------------------------------
# Class to generate SPARQL query parts related to semantic nets
# Class to handle semantic nets
#==============================================================================
#==============================================================================
# Importing required modules
#==============================================================================
from .class_net import ClassNet
from febTransduction.net import ClassNet
#==============================================================================
......@@ -19,33 +15,56 @@ from .class_net import ClassNet
#==============================================================================
class CompositeClassNet(ClassNet):
""" Class to generate SPARQL query parts related to semantic nets.
""" Class to handle semantic net.
"""
#--------------------------------------------------------------------------
# Constructor(s)
#--------------------------------------------------------------------------
def __init__(self, num=''):
def __init__(self, support_graph, uri=None):
# -- Parent init
super().__init__(support_graph, uri)
# -- Net Signature
# -- Net Type
self.type_name = 'compositeClass'
self.type_id = 'Composite_Class_Net'
self.id = f'?{self.type_name}Net{num}'
self.type_uri = f'net:{self.type_id}'
# -- Parent init
super().__init__(signature=True)
# -- Net Attributes
self.node = f'{self.id}Node'
self.mother_class_net = f'{self.id}MotherClassNet'
self.restriction = f'{self.id}Restriction'
self.restriction01 = f'{self.id}Restriction01'
self.predicate_table.update({
'node': 'coverNode',
'mother_class_net': 'hasMotherClassNet',
'restriction': 'hasRestriction',
'restriction01': 'hasRestriction01'
})
\ No newline at end of file
self.mother_class_net = None
self.restriction = []
self.restriction01 = []
#--------------------------------------------------------------------------
# Accessors for Net Attributes
#--------------------------------------------------------------------------
@property
def mother_class_net(self):
self._mother_class_net = super().get_attribute_value(mother_class_net=self._mother_class_net)
return self._mother_class_net
@mother_class_net.setter
def mother_class_net(self, new_value):
self._mother_class_net = new_value
@property
def restriction(self):
self._restriction = super().get_attribute_value(restriction=self._restriction)
return self._restriction
@restriction.setter
def restriction(self, new_value):
self._restriction = new_value
@property
def restriction01(self):
self._restriction01 = super().get_attribute_value(restriction01=self._restriction01)
return self._restriction01
@restriction01.setter
def restriction01(self, new_value):
self._restriction01 = new_value
\ No newline at end of file
......@@ -2,16 +2,12 @@
# -*-coding:Utf-8 -*
#==============================================================================
# TENET: Composite Property Net Query Builder
# TENET: Composite Property Net
#------------------------------------------------------------------------------
# Class to generate SPARQL query parts related to semantic nets
# Class to handle semantic nets
#==============================================================================
#==============================================================================
# Importing required modules
#==============================================================================
from .property_net import PropertyNet
from febTransduction.net import PropertyNet
#==============================================================================
......@@ -19,68 +15,66 @@ from .property_net import PropertyNet
#==============================================================================
class CompositePropertyNet(PropertyNet):
""" Class to generate SPARQL query parts related to semantic nets.
""" Class to handle semantic net.
"""
#--------------------------------------------------------------------------
# Constructor(s)
#--------------------------------------------------------------------------
def __init__(self, num=''):
def __init__(self, support_graph, uri=None):
# -- Net Signature
# -- Parent init
super().__init__(support_graph, uri)
# -- Net Type
self.type_name = 'compositeProperty'
self.type_id = 'Composite_Property_Net'
self.id = f'?{self.type_name}Net{num}'
self.type_uri = f'net:{self.type_id}'
# -- Parent init
super().__init__(signature=True)
# -- Net Attributes
self.core_role = f'{self.id}CoreRole'
self.target_argument_node = f'{self.id}TargetArgumentNode'
self.property_type = f'{self.id}PropertyType'
self.restriction = f'{self.id}Restriction'
self.predicate_table.update({
'core_role': 'isCoreRoleLinked',
'target_argument_node': 'targetArgumentNode',
'property_type': 'hasPropertyType',
'restriction': 'hasRestriction'
})
self._core_role = None
self._target_argument_node = []
self._property_type = None
self._restriction = []
#==============================================================================
# Development Test
#==============================================================================
if __name__ == '__main__':
print('\n' + ' *** Development Test ***')
print('\n' + ' -- test: Net')
net = AtomClassNet()
print(net)
print('\n' + ' -- test: update a test query')
test_query= f"""[...]
CONSTRUCT {{
{net.construct(base_node='?node1',
class_name='system')}
}}
WHERE {{
clause_1
clause_2
{net.complete_clauses_for_construction('?node1')}
{net.bind_uri('{{node1.concept_label}}',
'{{node1.variable_label}}')}
}}
"""
print(test_query)
#--------------------------------------------------------------------------
# Accessors for Net Attributes
#--------------------------------------------------------------------------
print('\n' + ' *** - ***')
\ No newline at end of file
@property
def core_role(self):
self._core_role = super().get_attribute_value(core_role=self._core_role)
return self._core_role
@core_role.setter
def core_role(self, new_value):
self._core_role = new_value
@property
def target_argument_node(self):
self._target_argument_node = super().get_attribute_value(target_argument_node=self._target_argument_node)
return self._target_argument_node
@target_argument_node.setter
def target_argument_node(self, new_value):
self._target_argument_node = new_value
@property
def property_type(self):
self._property_type = super().get_attribute_value(property_type=self._property_type)
return self._property_type
@property_type.setter
def property_type(self, new_value):
self._property_type = new_value
@property
def restriction(self):
self._restriction = super().get_attribute_value(restriction=self._restriction)
return self._restriction
@restriction.setter
def restriction(self, new_value):
self._restriction = new_value
\ No newline at end of file
......@@ -2,16 +2,12 @@
# -*-coding:Utf-8 -*
#==============================================================================
# TENET: Individual Net Query Builder
# TENET: Individual Net
#------------------------------------------------------------------------------
# Class to generate SPARQL query parts related to semantic nets
# Class to handle semantic nets
#==============================================================================
#==============================================================================
# Importing required modules
#==============================================================================
from .net import Net
from febTransduction.net import Net
#==============================================================================
......@@ -19,91 +15,56 @@ from .net import Net
#==============================================================================
class IndividualNet(Net):
""" Class to generate SPARQL query parts related to semantic nets.
""" Class to handle semantic net.
"""
#--------------------------------------------------------------------------
# Constructor(s)
#--------------------------------------------------------------------------
def __init__(self, num=''):
def __init__(self, support_graph, uri=None):
# -- Net Signature
# -- Parent init
super().__init__(support_graph, uri)
# -- Net Type
self.type_name = 'individual'
self.type_id = 'Individual_Net'
self.id = f'?{self.type_name}Net{num}'
self.type_uri = f'net:{self.type_id}'
# -- Parent init
super().__init__(signature=True)
# -- Net Attributes
self.base_class_name = f'{self.id}MotherClassNet'
self.mother_class_net = f'{self.id}MotherClassNet'
self.individual_label = f'{self.id}IndividualLabel'
self.predicate_table.update({
'base_class_name': 'hasBaseClassName',
'mother_class_net': 'hasMotherClassName',
'individual_label': 'hasIndividualLabel'
})
self.base_class_name = None
self.mother_class_net = []
self.individual_label = None
#--------------------------------------------------------------------------
# Method(s) to build 'Construct' parts
# Accessors for Net Attributes
#--------------------------------------------------------------------------
def construct(self, **net_attribute):
query_code = super().construct(**net_attribute)
return query_code
@property
def base_class_name(self):
self._base_class_name = super().get_attribute_value(base_class_name=self._base_class_name)
return self._base_class_name
#--------------------------------------------------------------------------
# Method(s) to build 'Clause' parts
#--------------------------------------------------------------------------
@base_class_name.setter
def base_class_name(self, new_value):
self._base_class_name = new_value
# --
@property
def mother_class_net(self):
self._mother_class_net = super().get_attribute_value(mother_class_net=self._mother_class_net)
return self._mother_class_net
@mother_class_net.setter
def mother_class_net(self, new_value):
self._mother_class_net = new_value
#--------------------------------------------------------------------------
# Method(s) to build 'Binding' parts
#--------------------------------------------------------------------------
def bind_uri(self, net_name='nameless', node_reference='00'):
return super().bind_uri(net_name, node_reference)
#==============================================================================
# Development Test
#==============================================================================
if __name__ == '__main__':
print('\n' + ' *** Development Test ***')
print('\n' + ' -- test: Atom Class Net')
net = IndividualNet()
print(net)
print('\n' + ' -- test: update a test query')
test_query= f"""[...]
CONSTRUCT {{
{net.construct(base_node='?node1',
mother_class_net='?classNet',
individual_label='?valueLabel')}
}}
WHERE {{
clause_1
clause_2
{net.complete_clauses_for_construction('?node1')}
{net.bind_uri('{{node1.concept_label}}',
'{{node1.variable_label}}')}
}}
"""
print(test_query)
@property
def individual_label(self):
self._individual_label = super().get_attribute_value(individual_label=self._individual_label)
return self._individual_label
print('\n' + ' *** - ***')
\ No newline at end of file
@individual_label.setter
def individual_label(self, new_value):
self._individual_label = new_value
\ No newline at end of file
#!/usr/bin/python3.10
# -*-coding:Utf-8 -*
#==============================================================================
# TENET: Logical Set Net Query Builder
#------------------------------------------------------------------------------
# Class to generate SPARQL query parts related to semantic nets
#==============================================================================
#==============================================================================
# Importing required modules
#==============================================================================
from .net import Net
#==============================================================================
# Net Class
#==============================================================================
class LogicalSetNet(Net):
""" Class to generate SPARQL query parts related to semantic nets.
"""
#--------------------------------------------------------------------------
# Constructor(s)
#--------------------------------------------------------------------------
def __init__(self, num=''):
# -- Net Signature
self.type_name = 'logicalSet'
self.type_id = 'Logical_Set_Net'
self.id = f'?{self.type_name}Net{num}'
self.type_uri = f'net:{self.type_id}'
# -- Parent init
super().__init__(signature=True)
# -- Net Attributes
self.logical_constraint = f'{self.id}Restriction'
self.property_net = f'{self.id}PropertyNet'
self.content_net_1 = f'{self.id}ContentNet1'
self.content_net_2 = f'{self.id}ContentNet2'
self.content_net = f'{self.id}ContentNet'
self.naming = f'{self.id}Naming'
self.restriction = f'{self.id}Restriction'
self.predicate_table.update({
'logical_constraint': 'hasLogicalConstraint',
'property_net': 'bindPropertyNet',
'content_net_1': 'containsNet1',
'content_net_2': 'containsNet2',
'content_net': 'containsNet',
'naming': 'hasNaming',
'restriction': 'bindRestriction'
})
#--------------------------------------------------------------------------
# Private data accessor(s)
#--------------------------------------------------------------------------
def __get_predicate(self, attribute_reference):
predicate_reference = self.predicate_table[f'{attribute_reference}']
return f'net:{predicate_reference}'
#--------------------------------------------------------------------------
# Method(s) to build 'Construct' parts
#--------------------------------------------------------------------------
def define_naming(self):
predicate = self.__get_predicate('naming')
return f"""
# -- Naming Definition
{self.id} {predicate} {self.naming}."""
#--------------------------------------------------------------------------
# Method(s) to build 'Clause' parts
#--------------------------------------------------------------------------
def identify_content_net_1(self, target_id):
predicate = self.__get_predicate('content_net_1')
return f"""
# -- Identify content net 1
{self.id} {predicate} {target_id}."""
def identify_content_net_2(self, target_id):
predicate = self.__get_predicate('content_net_2')
return f"""
# -- Identify content net 2
{self.id} {predicate} {target_id}."""
def identify_content_net(self, target_id):
predicate = self.__get_predicate('content_net')
return f"""
# -- Identify content net
{self.id} {predicate} {target_id}."""
def identify_disjoint_content_net(self, target_id_1, target_id_2):
predicate1 = self.__get_predicate('content_net_1')
predicate2 = self.__get_predicate('content_net_2')
return f"""
# -- Identify disjoint content net
{self.id} {predicate} {target_id_1}.
{self.id} {predicate} {target_id_2}.
FILTER ( {target_id_1} != {target_id_2} )."""
def identify_content_net_number(self, number_ref):
predicate = self.__get_predicate('content_net')
return f"""
{{
# -- Identify content net number
SELECT (COUNT(?contentNet) AS {number_ref})
WHERE {{
{self.id} {predicate} ?contentNet.
}}
}}"""
def identify_restriction(self, target_id):
predicate = self.__get_predicate('restriction')
return f"""
# -- Identify restriction
{self.id} {predicate} {target_id}."""
#--------------------------------------------------------------------------
# Method(s) to build 'Binding' parts
#--------------------------------------------------------------------------
def bind_naming(self, property_ref, content_1_ref, content_2_ref):
ref1 = f"{self.id}Ref1"
ref2 = f"{self.id}Ref2"
# -- ref3 = f"{self.id}Ref3"
return f"""
# -- New Naming
{self.identify_content_net_number('?contentNumber')}
BIND (CONCAT({property_ref}, '-', {content_1_ref}) AS {ref1}).
BIND (CONCAT({ref1}, '-and-', {content_2_ref}) AS {ref2}).
BIND (IF (?contentNumber > 2, CONCAT({ref2}, '-etc'), {ref2}) AS {self.naming})."""
\ No newline at end of file
This diff is collapsed.
#!/usr/bin/python3.10
# -*-coding:Utf-8 -*
#==============================================================================
# TENET: Atom Class Net Query Builder
#------------------------------------------------------------------------------
# Class to generate SPARQL query parts related to semantic nets
#==============================================================================
#==============================================================================
# Importing required modules
#==============================================================================
from .class_net import ClassNet
#==============================================================================
# Net Class
#==============================================================================
class OrCompositeClassNet(ClassNet):
""" Class to generate SPARQL query parts related to semantic nets.
"""
#--------------------------------------------------------------------------
# Constructor(s)
#--------------------------------------------------------------------------
def __init__(self, num=''):
# -- Net Signature
self.type_name = 'compositeClass'
self.type_id = 'Composite_Class_Net'
self.id = f'?{self.type_name}Net{num}'
self.type_uri = f'net:{self.type_id}'
# -- Parent init
super().__init__(signature=True)
# -- Net Attributes
self.node = f'{self.id}Node'
self.mother_class_net = f'{self.id}MotherClassNet'
self.restriction = f'{self.id}Restriction'
self.restriction01 = f'{self.id}Restriction01'
self.predicate_table.update({
'node': 'coverNode',
'mother_class_net': 'hasMotherClassNet',
'restriction': 'hasRestriction',
'restriction01': 'hasRestriction01'
})
\ No newline at end of file
......@@ -2,16 +2,12 @@
# -*-coding:Utf-8 -*
#==============================================================================
# TENET: Phenomena Net Query Builder
# TENET: Phenomena Net
#------------------------------------------------------------------------------
# Class to generate SPARQL query parts related to semantic nets
# Class to handle semantic nets
#==============================================================================
#==============================================================================
# Importing required modules
#==============================================================================
from .net import Net
from febTransduction.net import Net
#==============================================================================
......@@ -19,112 +15,46 @@ from .net import Net
#==============================================================================
class PhenomenaNet(Net):
""" Class to generate SPARQL query parts related to semantic nets.
""" Class to handle semantic net.
"""
#--------------------------------------------------------------------------
# Constructor(s)
#--------------------------------------------------------------------------
def __init__(self, num=''):
def __init__(self, support_graph, uri=None):
# -- Parent init
super().__init__(support_graph, uri)
# -- Net Signature
# -- Net Type
self.type_name = 'phenomena'
self.type_id = 'Phenomena_Net'
self.id = f'?{self.type_name}Net{num}'
self.type_uri = f'net:{self.type_id}'
# -- Parent init
super().__init__(signature=True)
# -- Net Attributes
self.phenomena_type = f'{self.id}PhenomenaType'
self.phenomena_ref = f'{self.id}PhenomenaRef'
self.predicate_table.update({
'phenomena_type': 'hasPhenomenaType',
'phenomena_ref': 'hasPhenomenaRef'
})
#--------------------------------------------------------------------------
# Method(s) to build 'Construct' parts
#--------------------------------------------------------------------------
def construct(self, **net_attribute):
query_code = super().construct(**net_attribute)
return query_code
self.phenomena_type = None
self.phenomena_ref = None
#--------------------------------------------------------------------------
# Method(s) to build 'Clause' parts
# Accessors for Net Attributes
#--------------------------------------------------------------------------
def identify_operator(self, num, target_base_id):
relation_role = f'amr:role_op{num}'
target_id = f'{target_base_id}{num}'
return f"""
# -- Identify operator (amr:op)
{self.id} {relation_role} {target_id}."""
@property
def phenomena_type(self):
self._phenomena_type = super().get_attribute_value(phenomena_type=self._phenomena_type)
return self._phenomena_type
def identify_optional_operator(self, num, target_base_id):
relation_role = f'amr:role_op{num}'
target_id = f'{target_base_id}{num}'
return f"""
# -- Identify optional operator (amr:op)
OPTIONAL {{ {self.id} {relation_role} {target_id}. }}"""
@phenomena_type.setter
def phenomena_type(self, new_value):
self._phenomena_type = new_value
@property
def phenomena_ref(self):
self._phenomena_ref = super().get_attribute_value(phenomena_ref=self._phenomena_ref)
return self._phenomena_ref
#--------------------------------------------------------------------------
# Method(s) to build 'Binding' parts
#--------------------------------------------------------------------------
def bind_uri(self, net_name='nameless', node_reference='00'):
return super().bind_uri(net_name, node_reference)
#==============================================================================
# Development Test
#==============================================================================
if __name__ == '__main__':
print('\n' + ' *** Development Test ***')
print('\n' + ' -- test: Atom Class Net')
atom_class_net = AtomClassNet()
print(atom_class_net)
print('\n' + ' -- test: construct')
construct_ctr = atom_class_net.construct(base_node='?node1',
structure='?structureRef',
class_name='?leaf1ConceptLabel')
print(construct_ctr)
print('\n' + ' -- test: update a test query')
test_query= f"""[...]
CONSTRUCT {{
{atom_class_net.construct(base_node='?node1',
structure='?structureRef',
class_name='?leaf1ConceptLabel')}
{atom_class_net.propagate_relations()}
}}
WHERE {{
clause_1
clause_2
{atom_class_net.identify_relations_for_propagation('?node1')}
{atom_class_net.bind_uri('{{node1.concept_label}}',
'{{node1.variable_label}}')}
}}
"""
print(test_query)
print('\n' + ' *** - ***')
\ No newline at end of file
@phenomena_ref.setter
def phenomena_ref(self, new_value):
self._phenomena_ref = new_value
\ No newline at end of file
......@@ -2,16 +2,12 @@
# -*-coding:Utf-8 -*
#==============================================================================
# TENET: Property Net Query Builder
# TENET: Property Net
#------------------------------------------------------------------------------
# Class to generate SPARQL query parts related to semantic nets
# Class to handle semantic nets
#==============================================================================
#==============================================================================
# Importing required modules
#==============================================================================
from .net import Net
from febTransduction.net import Net
#==============================================================================
......@@ -19,28 +15,36 @@ from .net import Net
#==============================================================================
class PropertyNet(Net):
""" Class to generate SPARQL query parts related to semantic nets.
""" Class to handle semantic net.
"""
#--------------------------------------------------------------------------
# Constructor(s)
#--------------------------------------------------------------------------
def __init__(self, num='', signature=False):
def __init__(self, support_graph, uri=None):
# -- Net Signature
if not signature:
# -- Parent init
super().__init__(support_graph, uri)
# -- Net Type
self.type_name = 'property'
self.type_id = 'Property_Net'
self.id = f'?{self.type_name}Net{num}'
self.type_uri = f'net:{self.type_id}'
# -- Parent init
super().__init__(signature=True)
# -- Net Attributes
self.property_name = f'{self.id}PropertyName'
self._property_name = None
#--------------------------------------------------------------------------
# Accessors for Net Attributes
#--------------------------------------------------------------------------
@property
def property_name(self):
self._property_name = super().get_attribute_value(property_name=self._property_name)
return self._property_name
self.predicate_table.update({
'property_name': 'hasPropertyName'
})
\ No newline at end of file
@property_name.setter
def property_name(self, new_value):
self._property_name = new_value
\ No newline at end of file
......@@ -2,16 +2,12 @@
# -*-coding:Utf-8 -*
#==============================================================================
# TENET: Atom Class Net Query Builder
# TENET: Restriction Net
#------------------------------------------------------------------------------
# Class to generate SPARQL query parts related to semantic nets
# Class to handle semantic nets
#==============================================================================
#==============================================================================
# Importing required modules
#==============================================================================
from .net import Net
from febTransduction.net import Net
#==============================================================================
......@@ -19,99 +15,56 @@ from .net import Net
#==============================================================================
class RestrictionNet(Net):
""" Class to generate SPARQL query parts related to semantic nets.
""" Class to handle semantic net.
"""
#--------------------------------------------------------------------------
# Constructor(s)
#--------------------------------------------------------------------------
def __init__(self, num=''):
def __init__(self, support_graph, uri=None):
# -- Net Signature
# -- Parent init
super().__init__(support_graph, uri)
# -- Net Type
self.type_name = 'restriction'
self.type_id = 'Restriction_Net'
self.id = f'?{self.type_name}Net{num}'
self.type_uri = f'net:{self.type_id}'
# -- Parent init
super().__init__(signature=True)
# -- Net Attributes
self.target_node = f'{self.id}TargetNode'
self.restriction_property = f'{self.id}RestrictionOnProperty'
self.restriction_net_value = f'{self.id}RestrictionNetValue'
self.predicate_table.update({
'target_node': 'coverTargetNode',
'restriction_property': 'hasRestrictionOnProperty',
'restriction_net_value': 'hasRestrictionNetValue'
})
#--------------------------------------------------------------------------
# Method(s) to build 'Construct' parts
#--------------------------------------------------------------------------
def construct(self, **net_attribute):
query_code = super().define_new_net(**net_attribute)
return query_code
self.target_node = []
self.restriction_property = None
self.restriction_net_value = None
#--------------------------------------------------------------------------
# Method(s) to build 'Complement Clause' parts
# Accessors for Net Attributes
#--------------------------------------------------------------------------
def complete_clauses_for_construction(self):
query_code = self.identify_structure()
return query_code
@property
def target_node(self):
self._target_node = super().get_attribute_value(target_node=self._target_node)
return self._target_node
@target_node.setter
def target_node(self, new_value):
self._target_node = new_value
#--------------------------------------------------------------------------
# Method(s) to build 'Binding' parts
#--------------------------------------------------------------------------
def bind_uri(self, property_name='nameless', arg_name='nameless'):
ref1 = f"{self.id}Ref1"
ref2 = f"{self.id}Ref2"
ref3 = f"{self.id}Ref3"
return f"""
# -- New Restriction Net
BIND (CONCAT(str(net:), '{self.type_name}') AS {ref1}).
BIND (CONCAT({ref1}, '_', {property_name}) AS {ref2}).
BIND (CONCAT({ref2}, '_', {arg_name}) AS {ref3}).
BIND (uri({ref3}) AS {self.id})."""
#==============================================================================
# Development Test
#==============================================================================
@property
def restriction_property(self):
self._restriction_property = self.get_attribute_value(restriction_property=self._restriction_property)
return self._restriction_property
if __name__ == '__main__':
@restriction_property.setter
def restriction_property(self, new_value):
self._restriction_property = new_value
print('\n' + ' *** Development Test ***')
print('\n' + ' -- test: Net')
net = AtomClassNet()
print(net)
print('\n' + ' -- test: update a test query')
test_query= f"""[...]
CONSTRUCT {{
{net.construct(base_node='?node1',
class_name='system')}
}}
WHERE {{
clause_1
clause_2
{net.complete_clauses_for_construction('?node1')}
{net.bind_uri('{{node1.concept_label}}',
'{{node1.variable_label}}')}
}}
"""
print(test_query)
@property
def restriction_net_value(self):
self._restriction_net_value = super().get_attribute_value(restriction_net_value=self._restriction_net_value)
return self._restriction_net_value
print('\n' + ' *** - ***')
\ No newline at end of file
@restriction_net_value.setter
def restriction_net_value(self, new_value):
self._restriction_net_value = new_value
\ No newline at end of file
#!/usr/bin/python3.10
# -*-coding:Utf-8 -*
#==============================================================================
# TENET: Net Query Builder
#------------------------------------------------------------------------------
# Class to generate SPARQL query parts related to semantic nets
#==============================================================================
# -- Useful Constant(s)
DEFAULT_ATTRIBUTE_VALUE = f'\"NA\"'
INDENT_STR = ' '
SENTENCE_REF = '?sentenceRef'
#==============================================================================
# Net Class
#==============================================================================
class SemanticNetReferenceHandle:
""" Class to handle RDF references (attributes) to semantic nets.
"""
#--------------------------------------------------------------------------
# Constructor
#--------------------------------------------------------------------------
def __init__(self):
self._main_predicate_table = {
# *** [attribute_name: (predicate_ref, variable_ref)] ***
# Net
'node': 'coverNode',
'base_node': 'coverBaseNode',
'structure': 'hasStructure',
'naming': 'hasNaming',
# Class Net
'class_name': 'hasClassName',
'mother_class_net': 'hasMotherClassNet',
# Property Net
'property_name': 'hasPropertyName',
'core_role': 'isCoreRoleLinked',
'target_argument_node': 'targetArgumentNode',
'property_type': 'hasPropertyType',
'property_name01': 'hasPropertyName01',
'property_name10': 'hasPropertyName10',
'property_name12': 'hasPropertyName12',
# Individual Net
'base_class_name': 'hasBaseClassName',
'individual_label': 'hasIndividualLabel',
# Value Net
'value_label': 'hasValueLabel',
# Phenomena Net
'phenomena_type': 'hasPhenomenaType',
'phenomena_ref': 'hasPhenomenaRef',
# Composite Net Restriction
'restriction': 'hasRestriction',
'restriction01': 'hasRestriction01',
# Restriction Net
'target_node': 'coverTargetNode',
'restriction_property': 'hasRestrictionOnProperty',
'restriction_net_value': 'hasRestrictionNetValue'
}
self._track_predicate_table = {
# *** [attribute_name: predicate_ref] ***
'progress_step': 'trackProgress',
'main_net_composante': 'trackMainNetComposante',
'net_composante': 'trackNetComposante'
}
#--------------------------------------------------------------------------
# Accessor(s)
#--------------------------------------------------------------------------
def get_predicate_uri(self, attribute_name):
assert (attribute_name in self._main_predicate_table.keys() or
attribute_name in self._track_predicate_table.keys())
predicate_uri = None
if attribute_name in self._main_predicate_table.keys():
predicate_rdf_reference = self._main_predicate_table[f'{attribute_name}']
predicate_uri = f'net:{predicate_rdf_reference}'
elif attribute_name in self._track_predicate_table.keys():
predicate_rdf_reference = self._track_predicate_table[f'{attribute_name}']
predicate_uri = f'net:{predicate_rdf_reference}'
return predicate_uri
#==============================================================================
# Development Test
#==============================================================================
if __name__ == '__main__':
print('\n' + ' *** Development Test ***')
print('\n -- Semantic Net Reference Table')
net_reference_handle = SemanticNetReferenceHandle()
print('\n -- Some test of getting predicate uri')
def test_getter_1(attr_ref):
attr_predicate = net_reference_handle.get_predicate_uri(attr_ref)
print(f" >>> {attr_ref}: {attr_predicate}")
test_getter_1('base_node')
test_getter_1('progress_step')
test_getter_1('no-name')
test_getter_1('naming')
print('\n' + ' *** - ***')
\ No newline at end of file
This diff is collapsed.
......@@ -2,16 +2,12 @@
# -*-coding:Utf-8 -*
#==============================================================================
# TENET: Value Net Query Builder
# TENET: Value Net
#------------------------------------------------------------------------------
# Class to generate SPARQL query parts related to semantic nets
# Class to handle semantic nets
#==============================================================================
#==============================================================================
# Importing required modules
#==============================================================================
from .net import Net
from febTransduction.net import Net
#==============================================================================
......@@ -19,60 +15,36 @@ from .net import Net
#==============================================================================
class ValueNet(Net):
""" Class to generate SPARQL query parts related to semantic nets.
""" Class to handle semantic net.
"""
#--------------------------------------------------------------------------
# Constructor(s)
#--------------------------------------------------------------------------
def __init__(self, num=''):
def __init__(self, support_graph, uri=None):
# -- Parent init
super().__init__(support_graph, uri)
# -- Net Signature
# -- Net Type
self.type_name = 'value'
self.type_id = 'Value_Net'
self.id = f'?{self.type_name}Net{num}'
self.type_uri = f'net:{self.type_id}'
# -- Parent init
super().__init__(signature=True)
# -- Net Attributes
self.value_label = f'{self.id}ValueLabel'
self.predicate_table.update({
'value_label': 'hasValueLabel'
})
self.value_label = None
#==============================================================================
# Development Test
#==============================================================================
if __name__ == '__main__':
print('\n' + ' *** Development Test ***')
print('\n' + ' -- test: Net')
net = ValueNet()
print(net)
print('\n' + ' -- test: update a test query')
test_query= f"""[...]
CONSTRUCT {{
{net.construct(value_label='a-value')}
}}
WHERE {{
clause_1
clause_2
{net.complete_clauses_for_construction('?node1')}
#--------------------------------------------------------------------------
# Accessors for Net Attributes
#--------------------------------------------------------------------------
{net.bind_uri('{{a_label}}')}
}}
"""
print(test_query)
@property
def value_label(self):
self._value_label = super().get_attribute_value(value_label=self._value_label)
return self._value_label
print('\n' + ' *** - ***')
\ No newline at end of file
@value_label.setter
def value_label(self, new_value):
self._value_label = new_value
\ No newline at end of file
This diff is collapsed.
#!/usr/bin/python3.10
# -*-coding:Utf-8 -*
#==============================================================================
# TENET: Semantic Net Class Test
#------------------------------------------------------------------------------
# Script to test the semantic net classes
#==============================================================================
import subprocess, os
from rdflib import Graph
from rdflib import Namespace
from rdflib.namespace import NamespaceManager
FILE_PATH = f'{os.path.dirname(os.path.abspath(__file__))}'
INPUT_DIR_PATH = f'{FILE_PATH}/input/'
OUTPUT_DIR_PATH = f'{FILE_PATH}/output/'
TEST_GRAPH = f'{INPUT_DIR_PATH}testGraph1.ttl'
from context import tenet
from tenet.febTransduction.net import Net
from tenet.febTransduction.net import ClassNet
from tenet.febTransduction.net import AtomClassNet
from tenet.febTransduction.net import CompositeClassNet
from tenet.febTransduction.net import PropertyNet
from tenet.febTransduction.net import AtomPropertyNet
from tenet.febTransduction.net import CompositePropertyNet
from tenet.febTransduction.net import IndividualNet
from tenet.febTransduction.net import ValueNet
from tenet.febTransduction.net import PhenomenaNet
from tenet.febTransduction.net import RestrictionNet
#==============================================================================
# Test Methods
#==============================================================================
def test_base_attribute_access(net):
print(f'\n *** Base attributes ({net.type_id})) ***')
print(f' ----- uri: {net.uri}')
print(f' ----- node: {net.node}')
print(f' ----- base_node: {net.base_node}')
print(f' ----- structure: {net.structure}')
print(f' ----- naming: {net.naming}')
def test_class_attribute_access(net):
print(f'\n *** Class attributes ({net.type_id})) ***')
print(f' ----- class_name: {net.class_name}')
def test_composite_class_attribute_access(net):
print(f'\n *** Composite Class attributes ({net.type_id})) ***')
print(f' ----- mother_class_net: {net.mother_class_net}')
print(f' ----- restriction: {net.restriction}')
print(f' ----- restriction01: {net.restriction01}')
def test_property_attribute_access(net):
print(f'\n *** Property attributes ({net.type_id})) ***')
print(f' ----- property_name: {net.property_name}')
def test_atom_property_attribute_access(net):
print(f'\n *** Atom Property attributes ({net.type_id})) ***')
print(f' ----- core_role: {net.core_role}')
print(f' ----- target_argument_node: {net.target_argument_node}')
print(f' ----- property_type: {net.property_type}')
print(f' ----- property_name01: {net.property_name01}')
print(f' ----- property_name10: {net.property_name10}')
print(f' ----- property_name12: {net.property_name12}')
def test_composite_property_attribute_access(net):
print(f'\n *** Composite Property attributes ({net.type_id})) ***')
print(f' ----- core_role: {net.core_role}')
print(f' ----- target_argument_node: {net.target_argument_node}')
print(f' ----- property_type: {net.property_type}')
print(f' ----- restriction: {net.restriction}')
def test_restriction_attribute_access(net):
print(f'\n *** Restriction attributes ({net.type_id})) ***')
print(f' ----- target_node: {net.target_node}')
print(f' ----- restriction_property: {net.restriction_property}')
print(f' ----- restriction_net_value: {net.restriction_net_value}')
def test_individual_attribute_access(net):
print(f'\n *** Individual attributes ({net.type_id})) ***')
print(f' ----- base_class_name: {net.base_class_name}')
print(f' ----- mother_class_net: {net.mother_class_net}')
print(f' ----- individual_label: {net.individual_label}')
def test_value_attribute_access(net):
print(f'\n *** Value attributes ({net.type_id})) ***')
print(f' ----- value_label: {net.value_label}')
def test_phenomena_attribute_access(net):
print(f'\n *** Phenomena attributes ({net.type_id})) ***')
print(f' ----- phenomena_type: {net.phenomena_type}')
print(f' ----- phenomena_ref: {net.phenomena_ref}')
#==============================================================================
# Development Test
#==============================================================================
print('\n' + ' *** Development Test ***')
print(f'\n -- Test Graph Loading')
graph = Graph()
graph.bind('net', Namespace('https://tenet.tetras-libre.fr/semantic-net#'))
graph.parse(TEST_GRAPH)
print(f" ----- Graph Loaded ({len(graph)})")
print('\n -- Net')
net = Net(graph, uri='net:atomClass_sun_s2')
test_base_attribute_access(net)
print('\n -- Class Net')
net = ClassNet(graph, uri='net:atomClass_sun_s2')
test_base_attribute_access(net)
test_class_attribute_access(net)
print('\n -- Atom Class Net')
net = AtomClassNet(graph, uri='net:atomClass_sun_s2')
test_base_attribute_access(net)
test_class_attribute_access(net)
print('\n -- Composite Class Net (1)')
net = CompositeClassNet(graph, uri='net:compositeClass_orbit-hasManner-conjunction-OR_o2')
test_base_attribute_access(net)
test_class_attribute_access(net)
test_composite_class_attribute_access(net)
print('\n -- Composite Class Net (2)')
net = CompositeClassNet(graph, uri='net:compositeClass_system-hasPart-sun-and-object_s')
test_base_attribute_access(net)
test_class_attribute_access(net)
test_composite_class_attribute_access(net)
print('\n -- Property Net')
net = AtomPropertyNet(graph, uri='net:atomProperty_orbit_o2')
test_base_attribute_access(net)
test_property_attribute_access(net)
print('\n -- Atom Property Net')
net = AtomPropertyNet(graph, uri='net:atomProperty_orbit_o2')
test_base_attribute_access(net)
test_property_attribute_access(net)
test_atom_property_attribute_access(net)
print('\n -- Composite Property Net')
net = CompositePropertyNet(graph, uri='net:compositeProperty_not-direct_d2')
test_base_attribute_access(net)
test_property_attribute_access(net)
test_composite_property_attribute_access(net)
print('\n -- Individual Net')
net = IndividualNet(graph, uri='net:individual_system_SolarSystem')
test_individual_attribute_access(net)
print('\n -- Value Net')
net = ValueNet(graph, uri='net:value_SolarSystem_blankNode')
test_value_attribute_access(net)
print('\n -- Phenomena Net (1)')
net = PhenomenaNet(graph, uri='net:phenomena_conjunction-AND_a')
test_phenomena_attribute_access(net)
print('\n -- Phenomena Net (1)')
net = PhenomenaNet(graph, uri='net:phenomena_conjunction-OR_o3')
test_phenomena_attribute_access(net)
print('\n -- Restriction Net')
net = RestrictionNet(graph, uri='net:restriction_hasPart_sun')
test_restriction_attribute_access(net)
print('\n' + ' *** - ***')
\ No newline at end of file
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment