`pyirk.ruleengine`

Created: 2022-09-06 19:14:39 author: Carsten Knoll

This module contains code to enable semantic inferences based on special items (e.g. instances of I41__semantic_rule)

Module Contents

Classes

`PremiseType`
`LiteralWrapper`
`RuleApplicator`	Class to handle the application of a single semantic rule. Deploys several RuleApplicatorWorkers (depending on the OR-subscopes)
`RuleApplicatorWorker`	Performs the application of one premise branch of a rule
`ReportingRuleResult`
`ReportingMultiRuleResult`
`AlgorithmicRuleApplicationWorker`	This class executes algorithmic rules.
`HypothesisReasoner`

Functions

`apply_all_semantic_rules`	Extract all semantic rules and apply them.
`apply_semantic_rules`
`apply_semantic_rule`	Create a RuleApplicator instance for the rules, execute its apply-method, return the result (list of new statements)
`get_all_rules`
`filter_relevant_stms`	From a list of Statement instances select only those which are qualifiers and whose subject is an RE with .role == SUBJECT. In other words: omit those instances which are created as dual relation edges
`edge_matcher`	:param e1d: attribute data of edges from “main graph” (see RuleApplicator) :param e2d: attribute data of edges from “prototype graph” (see RuleApplicator)
`crpr`	custom representation function which accepts Entities and literals
`compare_relation_statements`	decide whether a given relation fulfills all given statements
`is_node_for_simple_graph`	exclude nodes which are defined inside certain scopes
`get_simple_properties`

Data

`LITERAL_BASE_URI`
`VERBOSITY`
`wildcard_relation_uri`
`AtlasView`

API

pyirk.ruleengine.LITERAL_BASE_URI: ‘irk:/tmp/literals’

pyirk.ruleengine.VERBOSITY: False

pyirk.ruleengine.apply_all_semantic_rules(mod_context_uri=None) → List[pyirk.core.Statement]

Extract all semantic rules and apply them.

:returns: list of newly created statements

pyirk.ruleengine.apply_semantic_rules(*rules: List, mod_context_uri: str = None) → List[pyirk.core.Statement]

pyirk.ruleengine.apply_semantic_rule(rule: pyirk.core.Item, mod_context_uri: str = None) → List[pyirk.core.Statement]: Create a RuleApplicator instance for the rules, execute its apply-method, return the result (list of new statements)

pyirk.ruleengine.get_all_rules()

pyirk.ruleengine.filter_relevant_stms(re_list: List[pyirk.core.Statement], return_items=True) → List[pyirk.core.Statement]

From a list of Statement instances select only those which are qualifiers and whose subject is an RE with .role == SUBJECT. In other words: omit those instances which are created as dual relation edges

:param re_list: :return:

class pyirk.ruleengine.PremiseType(*args, **kwds)

Bases: enum.Enum

GRAPH: 0

SPARQL: 1

class pyirk.ruleengine.LiteralWrapper(value): Initialization

class pyirk.ruleengine.RuleApplicator(rule: pyirk.core.Entity, mod_context_uri: Optional[str] = None)

Class to handle the application of a single semantic rule. Deploys several RuleApplicatorWorkers (depending on the OR-subscopes)

Initialization

get_premise_type() → pyirk.ruleengine.PremiseType

extract_premise_stm_lists()

apply() → pyirk.core.RuleResult

Application of a semantic rule either in a specified module context or in the currently active module.

(A rule has to be applied in a module context because newly created entities must belong to some module)

_apply() → pyirk.core.RuleResult: Perform the actual application of the rule (either via subgraph monomorphism or via SPARQL query)

create_prototypes_for_variable_literals()

create_prototypes_for_fiat_entities()

create_simple_graph() → networkx.DiGraph

Create graph without regarding qualifiers. Nodes: uris (of items and relations)

:return:

get_all_node_relations() → dict: returns a dict of all graph-relevant relations {(uri1, uri2): [Container(rel_uri=uri3), …], ….}. Keys: 2-tuples of uris. Values: Lists of Containers (due to multi-edges)

_make_literal(value) → str: create (if necessary) and return an uri for an literal value

class pyirk.ruleengine.RuleApplicatorWorker(parent: pyirk.ruleengine.RuleApplicator, premise_stms: List[pyirk.core.Statement], premise_items: List[pyirk.core.Item])

Performs the application of one premise branch of a rule

Initialization

max_subgraph_monomorphisms: 3000

property rule

apply_sparql_premise() → pyirk.core.RuleResult

_resolve_local_node(node=None, uri=None): return item or literal

_get_understandable_local_nodes(): Generate a humand understandable version of self.local_nodes.a It is intendend for debugging only.

_get_understandable_result_maps(result_maps: List[dict]) → List[list]: Generate a human understandable version of the result_map-dicts which are returned by self.match_subgraph_P() It is intendend for debugging only.

apply_graph_premise() → pyirk.core.RuleResult

_process_result_map(result_maps) → pyirk.core.RuleResult

process the found subgraphs with the assertion

get_extended_result_map(result_map: dict) → dict

This function create a dict which contains every entry of result_map + mappings from subjectivized predicates.

:param result_map: mapping from P-node to G-node-item (as returned by self.match_subgraph_P)

_get_all_edge_predicate_relations(uri1, uri2, ensure_length1=False)

get_condition_funcs_and_args()

prepare_consequent_functions(): Creates 3 lists: - a list of the consequent functions (might create a new item, new statement or have other side effects) - a list of argument nodes (which will serve as keys for the actual arguments) - a list of the node names

get_asserted_relation_templates() → List[Tuple[int, pyirk.core.Relation, int]]: Create a list like [(0, R25, 1), …]

_fill_extended_local_nodes(force=False): join local_nodes + asserted_nodes + parent.literal_variable_nodes

match_subgraph_P() → List[dict]

_get_by_uri(uri): return literal or entity based on uri

_node_matcher(n1d: dict, n2d: dict) → bool

:param n1d: attribute data of node from “main graph” e.g. {‘itm’: <Item I22[“mathematical knowledge artifact”]>} :param n2d: attribute data of node from “prototype graph” e.g. { ‘itm’: {‘R3’: None, ‘R4’: <Item I1[“general item”]>}, ‘entity’: <Item Ia8139[“P1”]> }

:return: boolean matching result

a pair of nodes should match if - n2 is an external entity for self and the uris match - n2 is not an external entity (no further restrictions)

pyirk.ruleengine