pymodrev 0.1.0__py3-none-any.whl

pymodrev/__main__.py

@@ -0,0 +1,5 @@
+import sys
+from pymodrev.cli import main
+
+if __name__ == '__main__':
+    main()

pymodrev/asp_rules/async.lp

@@ -0,0 +1,28 @@
+%only one node updates at each time
+1{update(P,T,V):vertex(V)}1 :- exp(P), time(P,T), time(P,T+1).
+
+vlabel(P,T+1,V,1) :- update(P,T,V), 1{noneNegative(P,T,V,Id):functionOr(V,Id)}, vertex(V), exp(P), not r_part(V), not topologicalerror(V), time(P,T+1).
+vlabel(P,T+1,V,0) :- update(P,T,V), {noneNegative(P,T,V,Id):functionOr(V,Id)}0, vertex(V), exp(P), functionOr(V,_), not r_gen(V), not topologicalerror(V), time(P,T+1).
+
+%keep all others
+vlabel(P,T+1,V,S) :- not update(P,T,V), vlabel(P,T,V,S), time(P,T+1).
+
+%prevent updates that do not change the state of the network
+:- update(P,T,V), vlabel(P,T,V,S), vlabel(P,T+1,V,S).
+
+%there cannot exists 2 different times with the same update, which function's inputs are the same and the output is different
+%any function applied in two time points with the same inputs cannot have different outputs
+%ignore this to consider topological repairs
+topologicalerror(V) :- time(P1,T1), time(P2,T2), T1 != T2, time(P1,T1+1), time(P2,T2+1), update(P1, T1, V), update(P2, T2, V), {vlabel(P1,T1,V1,S1) : vlabel(P2,T2,V1,S2), functionAnd(V,Id, V1), S1!=S2}0, vlabel(P1,T1+1,V,S3), vlabel(P2,T2+1,V,S4), S3 != S4, not input(V).
+topologicalerror(V) :- time(P1,T), time(P2,T), time(P1,T+1), time(P2,T+1), update(P1, T, V), update(P2, T, V), P1 != P2, {vlabel(P1,T,V1,S1) : vlabel(P2,T,V1,S2), S1!=S2,  functionAnd(V,Id, V1)}0, vlabel(P1,T+1,V,S3), vlabel(P2,T+1,V,S4), S3 != S4, not input(V).
+
+repair(V) :- topologicalerror(V).
+
+#minimize {1@2,top,V : topologicalerror(V)}.
+
+#show update/3.
+
+% show inconsistent nodes per exeperiment
+inc(P,V) :- vlabel(P,T+1,V,0), 1{noneNegative(P,T,V,Id):functionOr(V,Id)}, vertex(V), exp(P), r_part(V), not topologicalerror(V), time(P,T), time(P,T+1), update(P,T,V).
+inc(P,V) :- vlabel(P,T+1,V,1), {noneNegative (P,T,V,Id):functionOr(V,Id)}0, vertex(V), exp(P), functionOr(V,_), r_gen(V), not topologicalerror(V), time(P,T), time(P,T+1), update(P,T,V).
+#show inc/2.

pymodrev/asp_rules/base.lp

@@ -0,0 +1,17 @@
+sign(0;1).
+complement(T,S) :- sign(S),sign(T),T!=S.
+
+%inferring vertex from edges
+vertex(V) :- edge(V,_,_).
+vertex(V) :- edge(_,V,_).
+
+% each vertex may or may not be in need of repair
+{r_gen(V)} :- vertex(V), not fixed(V).
+{r_part(V)} :- vertex(V), not fixed(V).
+
+repair(V) :- r_gen(V).
+repair(V) :- r_part(V).
+
+#show repair/1.
+#show r_gen/1.
+#show r_part/1.

pymodrev/asp_rules/complete.lp

@@ -0,0 +1,15 @@
+%at least one node updates at each time
+1{update(P,T,V):vertex(V)} :- exp(P), time(P,T), time(P,T+1).
+
+vlabel(P,T+1,V,1) :- update(P,T,V), 1{noneNegative(P,T,V,Id):functionOr(V,Id)}, vertex(V), exp(P), not r_part(V), time(P,T+1).
+vlabel(P,T+1,V,0) :- update(P,T,V), {noneNegative(P,T,V,Id):functionOr(V,Id)}0, vertex(V), exp(P), functionOr(V,_), not r_gen(V), time(P,T+1).
+
+%keep all others
+vlabel(P,T+1,V,S) :- not update(P,T,V), vlabel(P,T,V,S), time(P,T+1).
+
+#show update/3.
+
+% show inconsistent nodes per exeperiment
+inc(P,V) :- vlabel(P,T+1,V,0), 1{noneNegative(P,T,V,Id):functionOr(V,Id)}, vertex(V), exp(P), r_part(V), time(P,T), time(P,T+1), update(P,T,V).
+inc(P,V) :- vlabel(P,T+1,V,1), {noneNegative (P,T,V,Id):functionOr(V,Id)}0, vertex(V), exp(P), functionOr(V,_), r_gen(V), time(P,T), time(P,T+1), update(P,T,V).
+#show inc/2.

pymodrev/asp_rules/steady_state.lp

@@ -0,0 +1,30 @@
+%guarantee of stable state observation
+ss(P) :- exp(P), not time(P,_).
+
+%generate
+1{vlabel(P,V,S):sign(S)}1 :- vertex(V), ss(P).
+
+:-vlabel(P,V,S1), obs_vlabel(P,V,S2),complement(S1,S2).
+
+% functions
+% one positive or negative contribution in a clause
+onePositive(P,V,Id) :- functionAnd(V,Id, V2), edge(V2,V,S), vlabel(P,V2,S), ss(P).
+oneNegative(P,V,Id) :- functionAnd(V,Id, V2), edge(V2,V,S), vlabel(P,V2,T), complement(S,T), ss(P).
+
+% none positive or none negative on a clause
+% nonePositive(V,Id) :- not onePositive(V,Id), oneNegative(V,Id).
+noneNegative(P,V,Id) :- onePositive(P,V,Id), not oneNegative(P,V,Id).
+
+vlabel(P,V,1) :- 1{noneNegative(P,V,Id):functionOr(V,Id)}, vertex(V), ss(P), not r_part(V).
+vlabel(P,V,0) :- {noneNegative(P,V,Id):functionOr(V,Id)}0, vertex(V), ss(P), functionOr(V,_), not r_gen(V).
+
+#minimize {1,V : repair(V)}.
+#minimize {1,g,V : r_gen(V)}.
+#minimize {1,p,V : r_part(V)}.
+
+#show vlabel/3.
+
+% show inconsistent nodes per experiments
+inc(P,V) :- vlabel(P,V,0), 1{noneNegative(P,V,Id):functionOr(V,Id)}, vertex(V), ss(P), r_part(V).
+inc(P,V) :- vlabel(P,V,1), {noneNegative(P,V ,Id):functionOr(V,Id)}0, vertex(V), ss(P), functionOr(V,_), r_gen(V).
+#show inc/2.

pymodrev/asp_rules/sync.lp

@@ -0,0 +1,20 @@
+vlabel(P,T+1,V,1) :- 1{noneNegative(P,T,V,Id):functionOr(V,Id)}, vertex(V), exp(P), not r_part(V), not topologicalerror(V), time(P,T), time(P,T+1).
+vlabel(P,T+1,V,0) :- {noneNegative(P,T,V,Id):functionOr(V,Id)}0, vertex(V), exp(P), functionOr(V,_), not r_gen(V), not topologicalerror(V), time(P,T), time(P,T+1).
+
+%there cannot exists 2 different times with the same update, which function's inputs are the same and the output is different
+%any function applied in two time points with the same inputs cannot have different outputs
+%ignore this to consider topological repairs
+topologicalerror(V) :- time(P1,T1), time(P2,T2), T1 != T2, time(P1,T1+1), time(P2,T2+1), vertex(V), {vlabel(P1,T1,V1,S1): vlabel(P2,T2,V1,S2), S1!=S2, functionAnd(V,Id, V1)}0, vlabel(P1,T1+1,V,S3), vlabel(P2,T2+1,V,S4), S3 != S4, not input(V).
+topologicalerror(V) :- time(P1,T), time(P2,T), time(P1,T+1), time(P2,T+1), exp(P1), exp(P2), P1 != P2, vertex(V), {vlabel(P1,T,V1,S1): vlabel(P2,T,V1,S2), S1!=S2, functionAnd(V,Id, V1)}0, vlabel(P1,T+1,V,S3), vlabel(P2,T+1,V,S4), S3 != S4, not input(V).
+
+repair(V) :- topologicalerror(V).
+
+#minimize {1@2,top,V : topologicalerror(V)}.
+#show topologicalerror/1.
+
+% show inconsistent nodes per exeperiment
+inc(P,V) :- vlabel(P,T+1,V,0), 1{noneNegative(P,T,V,Id):functionOr(V,Id)}, vertex(V), exp(P), r_part(V), not topologicalerror(V), time(P,T), time(P,T+1).
+inc(P,V) :- vlabel(P,T+1,V,1), {noneNegative (P,T,V,Id):functionOr(V,Id)}0, vertex(V), exp(P), functionOr(V,_), r_gen(V), not topologicalerror(V), time(P,T), time(P,T+1).
+incT(P1,P2,V) :- time(P1,T1), time(P2,T2), T1!= T2, time(P1,T1+1), time(P2,T2+1), vertex(V), {vlabel( P1,T1,V1,S1): vlabel(P2,T2,V1,S2), S1!=S2, functionAnd(V, Id, V1)}0, vlabel(P1,T1+1,V,S3), vlabel(P2,T2+1,V,S4), S3 != S4, not input(V), P1 <= P2.
+#show inc/2.
+#show incT/3.

pymodrev/asp_rules/time_series.lp

@@ -0,0 +1,33 @@
+%time control per experiment
+time(P,T) :- exp(P), obs_vlabel(P,T,_,_).
+time(P,T) :- time(P,T+1), T+1 > 0.
+
+%generate
+1{vlabel(P,T,V,S):sign(S)}1:-vertex(V), exp(P), time(P,T).
+
+:-vlabel(P,T,V,S1), obs_vlabel(P,T,V,S2), complement(S1,S2).
+
+% functions
+%one positive or negative contribution in a clause
+onePositive(P,T,V,Id) :- functionAnd(V,Id, V2), edge(V2,V,S), vlabel(P,T,V2,S), exp(P), time(P,T).
+oneNegative(P,T,V,Id) :- functionAnd(V,Id, V2), edge(V2,V,S1), vlabel(P,T,V2,S2), complement(S1,S2), exp(P), time(P,T).
+
+% none negative on a clause
+noneNegative(P,T,V,Id) :- onePositive(P,T,V,Id), not oneNegative(P,T,V,Id).
+
+%input nodes
+input(V) :- not functionOr(V,_), vertex(V).
+
+vlabel(P,T+1,V,0) :- input(V), vlabel(P,T,V,0), exp(P), time(P,T+1), not r_gen(V).
+vlabel(P,T+1,V,1) :- input(V), vlabel(P,T,V,1), exp(P), time(P,T+1), not r_part(V).
+
+
+#minimize {1@1,V : repair(V)}.
+#minimize {1@1,g,V : r_gen(V)}.
+#minimize {1@1,p,V : r_part(V)}.
+#show vlabel/4.
+
+% show inconsistent nodes per exeperiment
+inc(P,V) :- vlabel(P,T+1,V,1), input(V), vlabel(P,T,V,0), exp(P), time(P,T+1), r_gen(V).
+inc(P,V) :- vlabel(P,T+1,V,0), input(V), vlabel(P,T,V,1), exp(P), time(P,T+1), r_part(V).
+#show inc/2.

pymodrev/cli.py

@@ -0,0 +1,171 @@
+"""
+This script analyzes a given network model to determine its consistency.
+If inconsistencies are found, it attempts to compute the minimal set of repair
+operations needed to restore consistency.
+"""
+
+import argparse
+import sys
+import os
+import logging
+
+from importlib import util
+from pymodrev.network.network import Network
+from pymodrev.parsers.parser_factory import get_parser
+from pymodrev.configuration import config
+from pymodrev.repair.engine import model_revision
+from pymodrev.repair.consistency import check_consistency
+from pymodrev.repair.engine import print_consistency
+from pymodrev.repair.repair import apply_repair
+
+# Configure logger
+logger = logging.getLogger(__name__)
+
+
+def process_arguments(network: Network) -> None:
+    """
+    Process command-line arguments and configure network accordingly.
+    """
+    parser = argparse.ArgumentParser(
+        description="Model Revision program. Given a model and a set of observations, it determines if the model is consistent. If not, it computes all the minimum number of repair operations in order to render the model consistent.",
+        formatter_class=argparse.RawTextHelpFormatter,
+        epilog=f"Version: {config.version}"
+    )
+
+    parser.add_argument("-m", "--model",
+                        required=True, help="Input model file.")
+    parser.add_argument("-obs", "--observations", nargs='+',
+                        required=True, metavar=('OBS', 'UPDATER'),
+                        help="""List of observation files and updater pairs.
+Each observation must be followed by its updater type. 
+Example: -obs obs1.lp asyncupdater obs2.lp syncupdater""")
+    parser.add_argument('-t', '--task', choices=['c', 'r', 'm'], required=True,
+                        help="""Specify the task to perform (default=r):
+   c - check for consistency
+   r - get repairs
+   m - get repaired models""")
+    parser.add_argument("--exhaustive-search", action="store_true",
+                        help="Force exhaustive search of function repair operations (default=false).")
+    parser.add_argument("--sub-opt", action="store_true",
+                        help="Show sub-optimal solutions found (default=false).")
+    parser.add_argument("--all-opt", action="store_true",
+                        help="""Computes all optimal solutions (default=true).
+Stops at first optimal solution if false.""")
+    parser.add_argument("-v", "--verbose", type=int, choices=[0, 1, 2], default=2,
+                        help="""Specify output verbose level (default=2):
+    0 - compact format
+    1 - json format
+    2 - human-readable format""")
+    parser.add_argument("-d", "--debug", action="store_true", help="Enable debug mode.")
+
+    args = parser.parse_args()
+
+    # Apply arguments to config and network
+    network.input_file_network = args.model
+    config.task = args.task
+    config.force_optimum = args.exhaustive_search
+    config.show_solution_for_each_inconsistency = args.sub_opt
+    config.verbose = args.verbose
+    config.debug = args.debug
+
+    # Activate debug mode
+    if args.debug:
+        logging.basicConfig(level=logging.DEBUG, format='%(name)s - %(levelname)s: %(message)s')
+    
+    obs_args = args.observations
+    if len(obs_args) % 2 != 0:
+        parser.error("Expected an even number of arguments for -obs (pairs of obs_file and updater_name)")
+
+    # Load updaters dynamically from updaters/ directory
+    updaters = {}
+    updater_dir = os.path.join(os.path.dirname(__file__), "updaters")
+    for filename in os.listdir(updater_dir):
+        if filename.endswith(".py") and filename not in ("__init__.py", "updater.py", "time_series_updater.py"):
+            module_name = os.path.splitext(filename)[0]
+            class_name = "".join(word.capitalize() for word in module_name.split("_"))
+            file_path = os.path.join(updater_dir, filename)
+            # Load module dynamically
+            spec = util.spec_from_file_location(module_name, file_path)
+            module = util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            # Get class from module
+            updater_class = getattr(module, class_name)()
+            # Add class to updaters dictionary
+            updaters[module_name.replace('_','')] = updater_class
+
+    for i in range(0, len(obs_args), 2):
+        obs_path = obs_args[i]
+        updater_name = obs_args[i+1]
+
+        try:
+            network.add_observation_file(obs_path)
+            if updater_name not in updaters:
+                raise Exception(f"Updater '{updater_name}' not found in updaters directory")
+            network.add_updater(updaters[updater_name])
+            if updater_name == 'steadystateupdater':
+                network.has_ss_obs = True
+            else:
+                network.has_ts_obs = True
+        except Exception as e:
+            parser.error(str(e))
+
+def main():
+    network = Network()
+    process_arguments(network)
+    
+    # Delegate parsing to the correct reader based on file extension
+    try:
+        parser = get_parser(network.input_file_network)
+        parse = parser.read(network, network.input_file_network)
+    except ValueError as e:
+        logger.error(str(e))
+        sys.exit(1)
+
+    if parse < 1 and not config.ignore_warnings:
+        logger.error('Model definition with errors. Check documentation for input definition details.')
+        sys.exit(1)
+
+    # Check consistency
+    f_inconsistencies, optimization = check_consistency(network)
+    if config.task == 'c' or optimization == 0:
+        print_consistency(f_inconsistencies, optimization)
+        sys.exit(0)
+
+    # Model revision
+    repairs2apply = model_revision(network, f_inconsistencies, optimization)
+    if config.task == 'm':
+        import copy
+        import itertools
+        
+        # 1. Collect all possible model combinations (Cartesian product of repair sets per solution)
+        all_models_to_save = []
+        for repair_sol in repairs2apply:
+            nodes_with_repairs = []
+            # Sort node IDs for deterministic output order
+            for node_id in sorted(repair_sol.inconsistent_nodes.keys()):
+                i_node = repair_sol.inconsistent_nodes[node_id]
+                if i_node.repair_sets:
+                    node_options = [(node_id, rs) for rs in i_node.repair_sets]
+                    nodes_with_repairs.append(node_options)
+            
+            # Cartesian product of options across all nodes for THIS solution
+            for combination in itertools.product(*nodes_with_repairs):
+                node_repair_map = dict(combination)
+                all_models_to_save.append((repair_sol, node_repair_map))
+
+        # 2. Apply repairs and write files
+        total_models = len(all_models_to_save)
+        if total_models == 0:
+            logger.info("No repaired models to generate.")
+        else:
+            padding = len(str(total_models))
+            prefix, ext = os.path.splitext(network.input_file_network)
+            for i, (repair_sol, node_repair_map) in enumerate(all_models_to_save):
+                newNetwork = copy.deepcopy(network)
+                apply_repair(newNetwork, repair_sol, node_repair_map)
+                filename = f"{prefix}_{str(i+1).zfill(padding)}{ext}"
+                parser.write(newNetwork, filename)
+                print(f"Generated repaired model: {filename}")
+
+if __name__ == '__main__':
+    main()

pymodrev/configuration.py

@@ -0,0 +1,87 @@
+"""
+This module defines enumerations and configuration settings for handling 
+inconsistencies and update types in a network analysis system.
+"""
+
+from enum import Enum
+from dataclasses import dataclass
+
+class Inconsistencies(Enum):
+    """
+    Enumeration representing different levels of inconsistencies in the system.
+
+    Attributes:
+        CONSISTENT (int): No inconsistency detected.
+        SINGLE_INC_GEN (int): A general single inconsistency.
+        SINGLE_INC_PART (int): A partial single inconsistency.
+        DOUBLE_INC (int): A double inconsistency.
+    """
+    CONSISTENT = (0, "No inconsistency detected")
+    SINGLE_INC_GEN = (1, "General single inconsistency")
+    SINGLE_INC_PART = (2, "Partial single inconsistency")
+    DOUBLE_INC = (3, "Double inconsistency")
+
+    def __init__(self, int_val, description):
+        self._value_ = int_val
+        self.description = description
+    def __str__(self):
+        return f"{self.name} ({self.value}): {self.description}"
+
+
+class UpdateType(Enum):
+    """
+    Enumeration representing the types of update strategies that can be used.
+
+    Attributes:
+        ASYNC (int): Asynchronous update strategy.
+        SYNC (int): Synchronous update strategy.
+        MASYNC (int): Mixed asynchronous update strategy.
+    """
+    ASYNC = (0, "Asynchronous update strategy")
+    SYNC = (1, "Synchronous update strategy")
+    MASYNC = (2, "Mixed asynchronous update strategy")
+
+    def __init__(self, int_val, description):
+        self._value_ = int_val
+        self.description = description
+    def __str__(self):
+        return f"{self.name} ({self.value}): {self.description}"
+
+
+import importlib.metadata
+
+try:
+    _package_version = importlib.metadata.version('pymodrev')
+except Exception:
+    _package_version = '1.0.0-dev'
+
+@dataclass
+class Configuration:
+    """Class representing the configuration settings for the system"""
+    name: str = 'pyModRev'
+    version: str = _package_version
+    task: str = 'r' # default is show the repairs
+    verbose: int = 2 # default is human-readable format
+    update: UpdateType = UpdateType.ASYNC  # Setting the update type to ASYNC
+    debug: bool = False
+    check_asp: bool = True  # Use ASP consistency check program
+    function_asp: bool = True  # Use ASP function program
+    all_opt: bool = True  # Show one or more solutions
+    labelling: bool = False
+    multiple_profiles: bool = True
+    compare_level_function: bool = True
+    exact_middle_function_determination: bool = True
+    ignore_warnings: bool = False
+    force_optimum: bool = False
+    show_solution_for_each_inconsistency: bool = False  # Show best solution for each consistency check even if it is not globally optimum
+    show_all_functions: bool = True # Show all function repairs for a given node
+    check_consistency: bool = False  # Just check the consistency of the model and return
+
+    def __getitem__(self, key):
+        return getattr(self, key)
+
+    def __setitem__(self, key, value):
+        setattr(self, key, value)
+
+
+config = Configuration()

pymodrev/network/edge.py

@@ -0,0 +1,70 @@
+"""
+This module defines the Edge class, which represents a connection between two
+nodes in a network.
+The Edge class provides methods to manage and query the properties of the edge,
+such as its start node, end node, sign, and whether it is fixed.
+"""
+
+from pymodrev.network.node import Node
+
+
+class Edge:
+    """
+    Represents an edge in a network, connecting two nodes with a specific sign.
+    Provides methods to manage and query the edge's properties.
+    """
+
+    def __init__(self, start_node: Node, end_node: Node, sign: int) -> None:
+        """
+        Initializes an edge with a start node, end node, and sign.
+        """
+        self._start_node = start_node
+        self._end_node = end_node
+        self._sign = sign
+        self._fixed = False
+
+    @property
+    def start_node(self) -> Node:
+        """Returns the start node of the edge."""
+        return self._start_node
+
+    @property
+    def end_node(self) -> Node:
+        """Returns the end node of the edge."""
+        return self._end_node
+
+    @property
+    def sign(self) -> int:
+        """Returns the sign of the edge."""
+        return self._sign
+
+    @sign.setter
+    def sign(self, value: int):
+        """Sets the sign of the edge."""
+        self._sign = value
+
+    @property
+    def fixed(self) -> bool:
+        """Returns whether the edge is fixed."""
+        return self._fixed
+
+    @fixed.setter
+    def fixed(self, value: bool):
+        """Sets whether the edge is fixed."""
+        self._fixed = value
+
+    def flip_sign(self) -> None:
+        """
+        Flips the sign of the edge (from 0 to 1 or from 1 to 0).
+        """
+        self.sign = 1 if self.sign == 0 else 0
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, Edge):
+            return False
+        return self.start_node == other.start_node and \
+               self.end_node == other.end_node and \
+               self.sign == other.sign
+
+    def __hash__(self) -> int:
+        return hash((self.start_node, self.end_node, self.sign))

pymodrev/network/exceptions.py

@@ -0,0 +1,27 @@
+"""
+This module defines custom exception classes for the pyModRev system.
+"""
+
+class PyModRevError(Exception):
+    """Base class for exceptions in this module."""
+    pass
+
+class NetworkError(PyModRevError):
+    """Exception raised for errors related to network structure."""
+    pass
+
+class EdgeNotFoundError(NetworkError):
+    """Exception raised when an edge is not found in the network."""
+    pass
+
+class ParseError(PyModRevError):
+    """Exception raised for errors during network or observation file parsing."""
+    pass
+
+class SolverError(PyModRevError):
+    """Exception raised when the ASP solver encounters an error or impossibility."""
+    pass
+
+class ConfigurationError(PyModRevError):
+    """Exception raised for invalid configurations or command-line arguments."""
+    pass