Apply linter suggestions

Author: IlyaMuravjov

cfpq_algo/all_pairs/all_pairs_cfl_reachability_algo.py

@@ -40,4 +40,3 @@ def _create_instance(
 
         Algo instance encapsulates intermediate solving state between algorithm steps.
         """
-        pass

cfpq_algo/all_pairs/matrix/abstract_all_pairs_cfl_reachability.py

@@ -1,17 +1,17 @@
 from abc import ABC, abstractmethod
 from typing import List
 
+import graphblas
 from graphblas.core.matrix import Matrix
 from graphblas.core.operator import Semiring, Monoid
-from graphblas.semiring import any_pair
 
+from cfpq_algo.all_pairs.all_pairs_cfl_reachability_algo import AllPairsCflReachabilityAlgoInstance
 from cfpq_algo.setting.algo_setting import AlgoSetting
+from cfpq_algo.setting.matrix_optimizer_setting import create_matrix_optimizer
+from cfpq_matrix.matrix_utils import complimentary_mask, identity_matrix
 from cfpq_model.cnf_grammar_template import CnfGrammarTemplate
 from cfpq_model.label_decomposed_graph import OptimizedLabelDecomposedGraph, LabelDecomposedGraph
-from cfpq_algo.setting.matrix_optimizer_setting import get_matrix_optimizer_settings, create_matrix_optimizer
-from cfpq_matrix.utils import complimentary_mask, identity_matrix
-from cfpq_algo.all_pairs.all_pairs_cfl_reachability_algo import AllPairsCflReachabilityAlgoInstance
-from cfpq_model.subtractable_semiring import SubtractableSemiring
+from cfpq_matrix.subtractable_semiring import SubtractableSemiring
 
 
 class AbstractAllPairsCflReachabilityMatrixAlgoInstance(AllPairsCflReachabilityAlgoInstance, ABC):
@@ -22,13 +22,13 @@ def __init__(
         settings: List[AlgoSetting],
         algebraic_structure: SubtractableSemiring = SubtractableSemiring(
             one=True,
-            semiring=any_pair,
-            sub_op=lambda minuend, subtrahend: complimentary_mask(minuend, subtrahend)
+            semiring=graphblas.semiring.any_pair,
+            sub_op=complimentary_mask
         )
     ):
         self.graph = OptimizedLabelDecomposedGraph.from_unoptimized(
             graph,
-            matrix_optimizer = create_matrix_optimizer(settings)
+            matrix_optimizer=create_matrix_optimizer(settings)
         )
         self.grammar = grammar
         self.settings = settings

cfpq_algo/all_pairs/matrix/incremental_all_pairs_cfl_reachability_algo.py

@@ -1,18 +1,19 @@
 from typing import List
 
+from cfpq_algo.all_pairs.all_pairs_cfl_reachability_algo import (
+    AllPairsCflReachabilityAlgoInstance,
+    AllPairsCflReachabilityAlgo
+)
+from cfpq_algo.all_pairs.matrix.abstract_all_pairs_cfl_reachability import \
+    AbstractAllPairsCflReachabilityMatrixAlgoInstance
 from cfpq_algo.setting.algo_setting import AlgoSetting
 from cfpq_model.cnf_grammar_template import CnfGrammarTemplate
 from cfpq_model.label_decomposed_graph import LabelDecomposedGraph
-from cfpq_algo.all_pairs.matrix.abstract_all_pairs_cfl_reachability import \
-    AbstractAllPairsCflReachabilityMatrixAlgoInstance
-from cfpq_algo.all_pairs.all_pairs_cfl_reachability_algo import AllPairsCflReachabilityAlgoInstance, \
-    AllPairsCflReachabilityAlgo
 
 
-class IncrementalAllPairsCFLReachabilityMatrixAlgoInstance(AbstractAllPairsCflReachabilityMatrixAlgoInstance):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
+class IncrementalAllPairsCFLReachabilityMatrixAlgoInstance(
+    AbstractAllPairsCflReachabilityMatrixAlgoInstance
+):
     def compute_transitive_closure(self):
         front = self.graph.to_unoptimized()
         self.graph = self.graph.empty_copy()

cfpq_algo/all_pairs/matrix/non_incremental_all_pairs_cfl_reachability_algo.py

@@ -1,18 +1,19 @@
 from typing import List
 
+from cfpq_algo.all_pairs.all_pairs_cfl_reachability_algo import (
+    AllPairsCflReachabilityAlgoInstance,
+    AllPairsCflReachabilityAlgo
+)
+from cfpq_algo.all_pairs.matrix.abstract_all_pairs_cfl_reachability import \
+    AbstractAllPairsCflReachabilityMatrixAlgoInstance
 from cfpq_algo.setting.algo_setting import AlgoSetting
 from cfpq_model.cnf_grammar_template import CnfGrammarTemplate
 from cfpq_model.label_decomposed_graph import OptimizedLabelDecomposedGraph, LabelDecomposedGraph
-from cfpq_algo.all_pairs.matrix.abstract_all_pairs_cfl_reachability import \
-    AbstractAllPairsCflReachabilityMatrixAlgoInstance
-from cfpq_algo.all_pairs.all_pairs_cfl_reachability_algo import AllPairsCflReachabilityAlgoInstance, \
-    AllPairsCflReachabilityAlgo
 
 
-class NonIncrementalAllPairsCFLReachabilityMatrixAlgoInstance(AbstractAllPairsCflReachabilityMatrixAlgoInstance):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
+class NonIncrementalAllPairsCFLReachabilityMatrixAlgoInstance(
+    AbstractAllPairsCflReachabilityMatrixAlgoInstance
+):
     def compute_transitive_closure(self) -> OptimizedLabelDecomposedGraph:
         old_nvals = self.graph.nvals
         while True:

cfpq_algo/setting/algo_settings_manager.py

@@ -4,8 +4,11 @@
 
 from cfpq_algo.setting.algo_setting import AlgoSetting
 from cfpq_algo.setting.preprocessor_setting import IndexExplodingPreProcessorSetting
-from cfpq_algo.setting.matrix_optimizer_setting import OptimizeEmptyMatrixSetting, LazyAddMatrixSetting, \
+from cfpq_algo.setting.matrix_optimizer_setting import (
+    OptimizeEmptyMatrixSetting,
+    LazyAddMatrixSetting,
     OptimizeFormatMatrixSetting
+)
 
 
 class AlgoSettingsManager:
@@ -34,4 +37,5 @@ def read_args(self, args: Namespace) -> List[AlgoSetting]:
     def report_unused(self):
         for setting in self._settings:
             if setting.was_specified_by_user and not setting.was_used_by_algo:
-                warnings.warn(f"Algo setting '{setting.flag_name}' was specified, but was not used by the algorithm.")
+                warnings.warn(f"Algo setting '{setting.flag_name}' was specified, "
+                              "but was not used by the algorithm.")

cfpq_algo/setting/matrix_optimizer_setting.py

@@ -12,7 +12,9 @@
 from cfpq_matrix.empty_optimized_matrix import EmptyOptimizedMatrix
 
 
-def create_matrix_optimizer(algo_settings: List[AlgoSetting]) -> Callable[[Matrix], OptimizedMatrix]:
+def create_matrix_optimizer(
+        algo_settings: List[AlgoSetting]
+) -> Callable[[Matrix], OptimizedMatrix]:
     optimizer_settings = get_matrix_optimizer_settings(algo_settings)
     return lambda matrix: optimize_matrix(matrix, optimizer_settings)
 
@@ -44,7 +46,7 @@ def add_arg(self, parser: ArgumentParser):
         )
 
     def read_arg(self, args: Namespace):
-        if args.__getattribute__(self.var_name) is True:
+        if getattr(args, self.var_name) is True:
             self.was_specified_by_user = True
             self.is_enabled = False
 

cfpq_algo/setting/preprocessor_setting.py

@@ -5,7 +5,7 @@
 from cfpq_algo.setting.algo_setting import AlgoSetting
 from cfpq_model.cnf_grammar_template import CnfGrammarTemplate
 from cfpq_model.label_decomposed_graph import LabelDecomposedGraph
-from cfpq_model.utils import explode_indices
+from cfpq_model.model_utils import explode_indices
 
 
 class PreProcessorSetting(AlgoSetting, ABC):

cfpq_cli/run_all_pairs_cflr.py

@@ -4,51 +4,52 @@
 from time import time
 from typing import Optional, List
 
+from cfpq_algo.all_pairs.all_cfl_pairs_reachability_impls import \
+    ALL_PAIRS_CFL_REACHABILITY_ALGO_NAMES, \
+    get_all_pairs_cfl_reachability_algo
 from cfpq_algo.setting.algo_setting import AlgoSetting
 from cfpq_algo.setting.algo_settings_manager import AlgoSettingsManager
 from cfpq_algo.setting.preprocessor_setting import preprocess_graph_and_grammar
+from cfpq_cli.time_limit import time_limit, TimeoutException
 from cfpq_model.cnf_grammar_template import CnfGrammarTemplate
 from cfpq_model.label_decomposed_graph import LabelDecomposedGraph
-from cfpq_algo.all_pairs.all_cfl_pairs_reachability_impls import \
-    ALL_PAIRS_CFL_REACHABILITY_ALGO_NAMES, \
-    get_all_pairs_cfl_reachability_algo
-from cfpq_cli.time_limit import time_limit, TimeoutException
 
 
 def run_all_pairs_cflr(
         algo_name: str,
         graph_path: str,
         grammar_path: str,
         time_limit_sec: Optional[int],
-        out_file: Optional[str],
+        out_path: Optional[str],
         settings: List[AlgoSetting]
 ):
     algo = get_all_pairs_cfl_reachability_algo(algo_name)
     graph = LabelDecomposedGraph.read_from_pocr_graph_file(graph_path)
     grammar = CnfGrammarTemplate.read_from_pocr_cnf_file(grammar_path)
     graph, grammar = preprocess_graph_and_grammar(graph, grammar, settings)
     try:
-        with (time_limit(time_limit_sec)):
+        with time_limit(time_limit_sec):
             start = time()
             res = algo.solve(graph=graph, grammar=grammar, settings=settings)
             finish = time()
             print(f"AnalysisTime\t{finish - start}")
             print(f"#SEdges\t{res.nvals}")
-            if out_file is not None:
-                out_dir = os.path.dirname(out_file)
+            if out_path is not None:
+                out_dir = os.path.dirname(out_path)
                 if out_dir != "" and not os.path.exists(out_dir):
                     os.makedirs(out_dir)
-                with open(out_file, 'w') as out_file:
+                with open(out_path, 'w', encoding="utf-8") as out_file:
                     for (source, target) in res:
                         out_file.write(f"{source}\t{target}\n")
     except TimeoutException:
-        print(f"AnalysisTime\tNaN")
-        print(f"#SEdges\tNaN")
+        print("AnalysisTime\tNaN")
+        print("#SEdges\tNaN")
 
 
 def main(raw_args: List[str]):
     parser = argparse.ArgumentParser(
-        description="Solves the Context-Free Language Reachability (CFL-R) problem for all vertex pairs.",
+        description="Solves the Context-Free Language Reachability (CFL-R) problem "
+                    "for all vertex pairs.",
     )
     parser.add_argument(dest='algo', choices=ALL_PAIRS_CFL_REACHABILITY_ALGO_NAMES,
                         help='Specifies the algorithm to use.')
@@ -62,7 +63,8 @@ def main(raw_args: List[str]):
                         help='Specifies the grammar file in POCR format. '
                              'Non-empty lines (except the last two) denote grammar rules: '
                              'complex rules (`<NON_TERMINAL> <SYMBOL_1> <SYMBOL_2>`), '
-                             'simple rules (`<NON_TERMINAL> <TERMINAL>`), and epsilon rules (`<NON_TERMINAL>`), '
+                             'simple rules (`<NON_TERMINAL> <TERMINAL>`), '
+                             'and epsilon rules (`<NON_TERMINAL>`), '
                              'with values separated by whitespace characters. '
                              'Indexed symbol names should end with `_i`. '
                              'The final two lines define the starting non-terminal as: '
@@ -72,8 +74,9 @@ def main(raw_args: List[str]):
     parser.add_argument('--out', dest='out', default=None,
                         help='Specifies the output file for saving vertex pairs. '
                              'The line format is: `[START_VERTEX]\t[END_VERTEX]`. '
-                             'Each line indicates a path exists from [START_VERTEX] to [END_VERTEX], '
-                             'labels along which spell a word from the specified Context-Free Language (CFL).'
+                             'Each line indicates a path exists from [START_VERTEX] '
+                             'to [END_VERTEX], labels along which spell a word from '
+                             'the specified Context-Free Language (CFL).'
                         )
     settings_manager = AlgoSettingsManager()
     settings_manager.add_args(parser)
@@ -83,7 +86,7 @@ def main(raw_args: List[str]):
         graph_path=args.graph,
         grammar_path=args.grammar,
         time_limit_sec=args.time_limit,
-        out_file=args.out,
+        out_path=args.out,
         settings=settings_manager.read_args(args)
     )
     settings_manager.report_unused()

cfpq_eval/eval_all_pairs_cflr.py

@@ -21,7 +21,7 @@
 
 def is_enough_data_collected(result_file_path: Path, rounds: int):
     try:
-        with open(result_file_path, 'r') as file:
+        with open(result_file_path, 'r', encoding="utf-8") as file:
             reader = list(csv.reader(file))
             if len(reader) - 1 >= rounds or any("OOT" in row or "OOM" in row for row in reader):
                 return True
@@ -31,19 +31,19 @@ def is_enough_data_collected(result_file_path: Path, rounds: int):
 
 
 def run_experiment(
-    algo_settings: str,
-    algo_name: str,
-    graph_path: Path,
-    grammar_path: Path,
-    rounds: int,
-    timeout_sec: Optional[int],
-    result_file_path: Path
+        algo_settings: str,
+        algo_name: str,
+        graph_path: Path,
+        grammar_path: Path,
+        rounds: int,
+        timeout_sec: Optional[int],
+        result_file_path: Path
 ):
     graph_base_name = graph_path.stem
     grammar_base_name = grammar_path.stem
 
     if not os.path.exists(result_file_path):
-        with open(result_file_path, 'w', newline='') as csvfile:
+        with open(result_file_path, 'w', newline='', encoding="utf-8") as csvfile:
             writer = csv.writer(csvfile)
             writer.writerow(["algo", "graph", "grammar", "s_edges", "ram_kb", "time_sec"])
 
@@ -80,7 +80,7 @@ def run_experiment(
                 )
                 s_edges, ram_kb, time_sec = "OOM", "OOM", "OOM"
 
-        with open(result_file_path, 'a', newline='') as csvfile:
+        with open(result_file_path, 'a', newline='', encoding="utf-8") as csvfile:
             print(f"   {s_edges} {ram_kb} {time_sec}")
             writer = csv.writer(csvfile)
             writer.writerow([
@@ -106,7 +106,7 @@ def reduce_result_file_to_one_row(result_file_path: Path) -> pd.DataFrame:
         return df
 
     df['ram_gb'] = df['ram_kb'].apply(
-        lambda x: x / 10**6 if isinstance(x, int) or isinstance(x, float) else x
+        lambda x: x / 10 ** 6 if isinstance(x, (int, float)) else x
     )
     assert df['algo'].nunique() <= 1
     assert df['graph'].nunique() <= 1
@@ -117,8 +117,8 @@ def reduce_result_file_to_one_row(result_file_path: Path) -> pd.DataFrame:
     else:
         unique_s_edges = df['s_edges'].unique()
         if len(unique_s_edges) > 1:
-            warnings.warn(f"Inconsistent 's_edges' values {unique_s_edges} found in {result_file_path}. "
-                          f"Using first 's_edges' value.")
+            warnings.warn(f"Inconsistent 's_edges' values {unique_s_edges} "
+                          f"found in {result_file_path}. Using first 's_edges' value.")
 
         ram_gb_mean = df['ram_gb'].mean()
         time_sec_mean = df['time_sec'].mean()
@@ -135,13 +135,15 @@ def reduce_result_file_to_one_row(result_file_path: Path) -> pd.DataFrame:
             'ram_gb': [
                 round_to_significant_digits(ram_gb_mean)
                 if ram_gb_std < DISPLAY_STD_THRESHOLD * ram_gb_mean
-                else f"{round_to_significant_digits(ram_gb_mean)} ± {round_to_significant_digits(ram_gb_std)}"
+                else f"{round_to_significant_digits(ram_gb_mean)}"
+                     f" ± {round_to_significant_digits(ram_gb_std)}"
             ],
             'time_sec': [
                 # Graspan reports analysis time in whole seconds, so it may report 0
                 (round_to_significant_digits(time_sec_mean) if time_sec_mean != 0 else "< 1")
                 if time_sec_std < DISPLAY_STD_THRESHOLD * time_sec_mean
-                else f"{round_to_significant_digits(time_sec_mean)} ± {round_to_significant_digits(time_sec_std)}"
+                else f"{round_to_significant_digits(time_sec_mean)}"
+                     f" ± {round_to_significant_digits(time_sec_std)}"
             ]
         })
     return df
@@ -205,7 +207,10 @@ def display_results(result_files_paths: List[Path]) -> None:
     print()
 
     df = pd.concat(
-        [reduce_result_file_to_one_row(result_file_path) for result_file_path in result_files_paths],
+        [
+            reduce_result_file_to_one_row(result_file_path)
+            for result_file_path in result_files_paths
+        ],
         ignore_index=True
     )
     df['algo'] = pd.Categorical(df['algo'], categories=df['algo'].unique())
@@ -219,14 +224,14 @@ def display_results(result_files_paths: List[Path]) -> None:
 
 
 def eval_all_pairs_cflr(
-    algo_config: Path,
-    data_config: Path,
-    result_path: Path,
-    rounds: Optional[int],
-    timeout_sec: Optional[int],
+        algo_config: Path,
+        data_config: Path,
+        result_path: Path,
+        rounds: Optional[int],
+        timeout_sec: Optional[int],
 ):
     result_files_paths = []
-    with open(algo_config, mode='r') as algo_file:
+    with open(algo_config, mode='r', encoding="utf-8") as algo_file:
         algo_reader = csv.DictReader(algo_file)
         for algo_row in algo_reader:
             algo_name = algo_row['algo_name']
@@ -236,7 +241,7 @@ def eval_all_pairs_cflr(
             if not os.path.exists(algo_result_path):
                 os.makedirs(algo_result_path)
 
-            with open(data_config, mode='r') as data_file:
+            with open(data_config, mode='r', encoding="utf-8") as data_file:
                 data_reader = csv.DictReader(data_file)
                 for data_row in data_reader:
                     graph_path = Path(data_row['graph_path']).absolute()
@@ -260,7 +265,8 @@ def eval_all_pairs_cflr(
 
 def main(raw_args: List[str]):
     parser = argparse.ArgumentParser(
-        description='Evaluates all vertex pairs Context-Free Language Reachability (CFL-R) algorithms.'
+        description='Evaluates all vertex pairs '
+                    'Context-Free Language Reachability (CFL-R) algorithms.'
     )
 
     parser.add_argument('algo_config', type=str,
@@ -284,5 +290,5 @@ def main(raw_args: List[str]):
     )
 
 
-if __name__ == "__main__":       # pragma: no cover
+if __name__ == "__main__":  # pragma: no cover
     main(raw_args=sys.argv[1:])  # pragma: no cover