reduced typing inconsitencies

Author: julrog

.pre-commit-config.yaml

@@ -1,4 +1,9 @@
 repos:
+  #- repo: https://github.com/pre-commit/mirrors-mypy
+  #  rev: v0.991
+  #  hooks:
+  #    - id: mypy
+  #      args: [--ignore-missing-imports, --disallow-untyped-defs, --disallow-incomplete-defs, --disallow-untyped-calls]
   - repo: https://github.com/timothycrosley/isort
     rev: 5.10.1
     hooks:

data/__init__.py

@@ -1,6 +1,6 @@
 import logging
 import os
-from typing import Any, List, Tuple
+from typing import Any, List, Optional, Tuple
 
 import numpy as np
 from tensorflow import keras
@@ -31,7 +31,7 @@ def get_basic_data(categorical: bool = False) -> Tuple[Tuple[Any, Any], Tuple[An
     return (x_train, y_train), (x_test, y_test), input_shape, num_classes
 
 
-def get_prepared_data(class_selection: List[int] = None) -> Tuple[Tuple[Any, Any], Tuple[Any, Any], Any, Any]:
+def get_prepared_data(class_selection: Optional[List[int]] = None) -> Tuple[Tuple[Any, Any], Tuple[Any, Any], Any, Any]:
     (x_train, y_train), (x_test, y_test), input_shape, num_classes = get_basic_data()
 
     if class_selection is not None:
@@ -61,7 +61,7 @@ def get_prepared_data(class_selection: List[int] = None) -> Tuple[Tuple[Any, Any
     return (x_train, y_train), (x_test, y_test), input_shape, num_classes
 
 
-def get_unbalance_data(main_class: int, other_class_percentage: float, class_selection: List[int] = None) \
+def get_unbalance_data(main_class: int, other_class_percentage: float, class_selection: Optional[List[int]] = None) \
         -> Tuple[Tuple[Any, Any], Tuple[Any, Any], Any, Any]:
     (x_train, y_train), (x_test, y_test), input_shape, num_classes = get_basic_data()
 
@@ -108,7 +108,7 @@ def get_unbalance_data(main_class: int, other_class_percentage: float, class_sel
     return (x_train, y_train), (x_test, y_test), input_shape, num_classes
 
 
-def split_mnist_data(class_selection: List[int] = None):
+def split_mnist_data(class_selection: Optional[List[int]] = None) -> None:
     (x_train, y_train), (x_test, y_test), input_shape, num_classes = get_basic_data()
     logging.info('splitting %i train examples' % x_train.shape[0])
     logging.info('splitting %i test examples' % x_test.shape[0])

data/mnist_data_handler.py

@@ -1,6 +1,6 @@
 import os
 from enum import Enum
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
 from tensorflow import keras
 from tensorflow.keras.models import Model
@@ -20,7 +20,7 @@ class ModelTrainType(Enum):
 
 
 class ModelData:
-    def __init__(self, name: str, description: str = None, model: Model = None):
+    def __init__(self, name: str, description: Optional[str] = None, model: Optional[Model] = None) -> None:
         self.name: str = name
         self.model: Model = model if model is not None else keras.models.load_model(
             self.get_model_path())
@@ -34,7 +34,7 @@ def __init__(self, name: str, description: str = None, model: Model = None):
         self.data_file.read_data()
 
     def set_parameter(self, batch_size: int, epochs: int, layer_data: List[int], learning_rate: float,
-                      training_samples: int, test_samples: int):
+                      training_samples: int, test_samples: int) -> None:
         self.data['batch_size'] = batch_size
         self.data['epochs'] = epochs
         self.data['layer_data'] = layer_data
@@ -44,20 +44,20 @@ def set_parameter(self, batch_size: int, epochs: int, layer_data: List[int], lea
         self.data['test_samples'] = test_samples
 
     def set_initial_performance(self, test_loss: float, test_accuracy: float, train_loss: float, train_accuracy: float,
-                                classification_report: Any):
+                                classification_report: Any) -> None:
         self.data['test_loss'] = str(test_loss)
         self.data['test_accuracy'] = str(test_accuracy)
         self.data['train_loss'] = str(train_loss)
         self.data['train_accuracy'] = str(train_accuracy)
         self.data['classification_report'] = classification_report
 
-    def set_class_selection(self, class_selection: List[int]):
+    def set_class_selection(self, class_selection: List[int]) -> None:
         importance: dict = dict()
         importance['class_selection'] = class_selection
         self.data_file.append_main_data('processed', 'importance', importance)
         self.data_file.write_data()
 
-    def set_importance_type(self, importance_type: int):
+    def set_importance_type(self, importance_type: int) -> None:
         importance: dict = dict()
         importance['importance_type'] = importance_type
         self.data_file.append_main_data('processed', 'importance', importance)
@@ -66,31 +66,31 @@ def set_importance_type(self, importance_type: int):
     def get_num_classes(self) -> int:
         return self.data_file.data_cache['overall']['basic_model']['num_classes']
 
-    def get_class_selection(self) -> List[int] or None:
+    def get_class_selection(self) -> Optional[List[int]]:
         return self.data_file.data_cache['processed']['importance']['class_selection']
 
     def get_importance_type(self) -> int:
         return self.data_file.data_cache['processed']['importance']['importance_type']
 
-    def store_model_data(self):
+    def store_model_data(self) -> None:
         self.data_file.append_main_data('overall', 'basic_model', self.data)
         self.data_file.write_data()
 
-    def store_main_data(self, key: str, sub_key: str, data: Dict[Any, Any]):
+    def store_main_data(self, key: str, sub_key: str, data: Dict[Any, Any]) -> None:
         self.data_file.append_main_data(key, sub_key, data)
         self.data_file.write_data()
 
-    def store_data(self, key: str, sub_key: str, sub_sub_key: str, data: Dict[Any, Any]):
+    def store_data(self, key: str, sub_key: str, sub_sub_key: str, data: Dict[Any, Any]) -> None:
         self.data_file.append_data(key, sub_key, sub_sub_key, data)
         self.data_file.write_data()
 
-    def save_model(self):
+    def save_model(self) -> None:
         path: str = DATA_PATH + 'model/' + self.name + '/tf_model'
         if not os.path.exists(path):
             os.makedirs(path)
         self.model.save(path)
 
-    def reload_model(self):
+    def reload_model(self) -> None:
         self.model = keras.models.load_model(self.get_model_path())
         self.check_model_supported_layer()
 
@@ -100,10 +100,10 @@ def get_model_path(self) -> str:
     def get_path(self) -> str:
         return DATA_PATH + 'model/' + self.name + '/'
 
-    def save_data(self):
+    def save_data(self) -> None:
         self.data_file.write_data()
 
-    def check_model_supported_layer(self):
+    def check_model_supported_layer(self) -> None:
         for index, layer in enumerate(self.model.layers):
             if layer.__class__.__name__ not in SUPPORTED_LAYER and layer.__class__.__name__ not in IGNORED_LAYER:
                 raise Exception(

data/model_data.py

@@ -1,4 +1,8 @@
 import os
+from enum import IntEnum, IntFlag, auto
+from typing import List
+
+from pyrr import Vector3
 
 BASE_PATH = os.path.dirname(os.path.realpath(__file__))
 DATA_PATH = BASE_PATH + '/storage/data/'
@@ -7,6 +11,38 @@
 ADDITIONAL_EDGE_BUFFER_DATA: int = 8
 
 
+class ProcessRenderMode(IntFlag):
+    FINAL = auto()
+    NODE_ITERATIONS = auto()
+    EDGE_ITERATIONS = auto()
+    SMOOTHING = auto()
+
+
+class CameraPose(IntEnum):
+    FRONT = 0
+    RIGHT = 1
+    LEFT = 2
+    LOWER_BACK_RIGHT = 3
+    BACK_RIGHT = 4
+    UPPER_BACK_LEFT = 5
+    UPPER_BACK_RIGHT = 6
+    BACK = 7
+    DEFAULT = 8
+
+
+CAMERA_POSE_POSITION: List[Vector3] = [
+    Vector3([3.5, 0.0, 0.0]),
+    Vector3([0.0, 0.0, 2.5]),
+    Vector3([0.0, 0.0, -2.5]),
+    Vector3([-2.75, -1.0, 1.25]),
+    Vector3([-2.5, 0.0, 2.5]),
+    Vector3([-2.0, 2.0, -2.0]),
+    Vector3([-2.0, 2.0, 2.0]),
+    Vector3([-4.0, 0.0, 0.0]),
+    Vector3([-3.5, 0.0, 0.0])
+]
+
+
 def pairwise(it, size: int):
     it = iter(it)
     while True:

definitions.py

@@ -10,7 +10,7 @@
 from utility.file import EvaluationFile
 
 
-def setup_plot():
+def setup_plot() -> None:
     plt.rc('font', size=14)
     plt.rc('axes', titlesize=14)
     plt.rc('axes', labelsize=14)
@@ -26,7 +26,7 @@ def load_data(name: str, importance_name: str, timed_name: bool = False) -> Dict
     return evaluation_file.data_cache[importance_name]
 
 
-def save_plot(name: str):
+def save_plot(name: str) -> None:
     directory_path: str = os.path.join(
         BASE_PATH, os.path.join('storage', 'evaluation'))
     if not os.path.exists(directory_path):
@@ -37,7 +37,7 @@ def save_plot(name: str):
     plt.savefig(file_path)
 
 
-def create_importance_plot(filename: str, importance_name: str, timed_name: bool = False, show: bool = False):
+def create_importance_plot(filename: str, importance_name: str, timed_name: bool = False, show: bool = False) -> None:
     data: Dict[Any, Any] = load_data(filename, importance_name, timed_name)
 
     converted_data: List[List[Any]] = []
@@ -76,7 +76,7 @@ def create_importance_plot(filename: str, importance_name: str, timed_name: bool
 
 
 def create_importance_plot_compare_regularizer(filename: str, importance_names: List[str], check_importance_type: str,
-                                               timed_name: bool = False, show: bool = False):
+                                               timed_name: bool = False, show: bool = False) -> None:
     plt.rcParams['legend.loc'] = 'lower left'
     converted_data: List[List[Any]] = []
     for importance_name in importance_names:
@@ -117,7 +117,7 @@ def create_importance_plot_compare_regularizer(filename: str, importance_names:
 
 
 def create_importance_plot_compare_bn_parameter(filename: str, importance_names: List[str], check_importance_type: str,
-                                                timed_name: bool = False, show: bool = False):
+                                                timed_name: bool = False, show: bool = False) -> None:
     converted_data: List[List[Any]] = []
     for importance_name in importance_names:
         data: Dict[Any, Any] = load_data(filename, importance_name, timed_name)
@@ -154,7 +154,7 @@ def create_importance_plot_compare_bn_parameter(filename: str, importance_names:
 def create_importance_plot_compare_class_vs_all(filename: str, importance_name: str, class_index: int,
                                                 check_importance_type: str, class_specific_data: bool = True,
                                                 timed_name: bool = False,
-                                                show: bool = False):
+                                                show: bool = False) -> None:
     converted_data: List[List[Any]] = []
 
     importance_data_name: str = '%s_[%s]' % (
@@ -191,7 +191,7 @@ def create_importance_plot_compare_class_vs_all(filename: str, importance_name:
 
 def create_importance_plot_compare_classes_vs_all(filename: str, importance_name: str, check_importance_type: str,
                                                   class_specific_data: bool = True, timed_name: bool = False,
-                                                  show: bool = False):
+                                                  show: bool = False) -> None:
     converted_data: List[List[Any]] = []
 
     for i in range(10):

evaluation/__init__.py

@@ -1,6 +1,6 @@
 import logging
 import time
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
 import numpy as np
 from tensorflow import keras
@@ -13,27 +13,27 @@
 
 
 class ImportanceEvaluator:
-    def __init__(self, model_data: ModelData):
+    def __init__(self, model_data: ModelData) -> None:
         self.model_data: ModelData = model_data
         self.importance_type: ImportanceType = ImportanceType(
             model_data.get_importance_type())
         self.importance_calculation: ImportanceCalculation = ImportanceCalculation.BNN_EDGE
-        self.relevant_classes: List[int] or None = None
+        self.relevant_classes: Optional[List[int]] = None
 
         self.x_train = None
         self.y_train = None
         self.x_test = None
         self.y_test = None
 
-    def set_train_and_test_data(self, x_train, y_train, x_test, y_test):
+    def set_train_and_test_data(self, x_train, y_train, x_test, y_test) -> None:
         self.x_train = x_train
         self.y_train = y_train
         self.x_test = x_test
         self.y_test = y_test
 
-    def setup(self, importance_type: ImportanceType,
+    def setup(self, importance_type: ImportanceType = ImportanceType.L1,
               importance_calculation: ImportanceCalculation = ImportanceCalculation.BNN_EDGE,
-              relevant_classes: List[int] = None):
+              relevant_classes: Optional[List[int]] = None) -> None:
         self.importance_type = importance_type
         self.importance_calculation = importance_calculation
         self.relevant_classes = relevant_classes
@@ -62,7 +62,7 @@ def get_importance(self, edge_alpha: float, classes_importance: List[float]) ->
     def prune_model(self,
                     importance_prune_percent: str,
                     importance_data: ImportanceDataHandler,
-                    importance_threshold: float):
+                    importance_threshold: float) -> None:
         data: Dict[Any, Any] = dict()
 
         pruned_edges: int = 0
@@ -127,7 +127,7 @@ def accuracy_report(self, truths: np.array, predictions: np.array) -> Dict[str,
                 true_positive_rate + true_negative_rate) / 2.0
         return accuracy_report
 
-    def test_model(self, importance_prune_percent: str):
+    def test_model(self, importance_prune_percent: str) -> None:
         self.model_data.model.compile(loss=keras.losses.categorical_crossentropy,
                                       optimizer=keras.optimizers.Adam(0.001),
                                       metrics=['accuracy'])
@@ -171,7 +171,7 @@ def test_model(self, importance_prune_percent: str):
             self.importance_calculation.name,
             importance_prune_data)
 
-    def create_evaluation_data(self, step_size: int = 1, start_percentage: int = 0, end_percentage: int = 100):
+    def create_evaluation_data(self, step_size: int = 1, start_percentage: int = 0, end_percentage: int = 100) -> None:
         importance_data: ImportanceDataHandler = ImportanceDataHandler(
             self.model_data.get_path() + get_importance_type_name(self.importance_type) + '.imp.npz')
 

evaluation/create_plot.py

@@ -2,7 +2,7 @@
 import sys
 
 sys.path.append(os.path.abspath(os.path.join(
-    os.path.dirname(sys.modules[__name__].__file__), '..')))
+    os.path.dirname(sys.modules[__name__].__file__), '..')))  # type: ignore
 
 if True:
     import matplotlib.pyplot as plt

evaluation/evaluator.py

@@ -2,7 +2,7 @@
 import sys
 
 sys.path.append(os.path.abspath(os.path.join(
-    os.path.dirname(sys.modules[__name__].__file__), '..')))
+    os.path.dirname(sys.modules[__name__].__file__), '..')))  # type: ignore
 
 if True:
     from data.mnist_data_handler import get_prepared_data

examples/__init__.py

@@ -4,7 +4,7 @@
 import sys
 
 sys.path.append(os.path.abspath(os.path.join(
-    os.path.dirname(sys.modules[__name__].__file__), '..')))
+    os.path.dirname(sys.modules[__name__].__file__), '..')))  # type: ignore
 
 if True:
     from typing import List

examples/create_images.py

@@ -1,9 +1,9 @@
 import os.path
 import sys
-from typing import List
+from typing import List, Optional
 
 sys.path.append(os.path.abspath(os.path.join(
-    os.path.dirname(sys.modules[__name__].__file__), '..')))
+    os.path.dirname(sys.modules[__name__].__file__), '..')))  # type: ignore
 
 if True:
     from data.mnist_data_handler import split_mnist_data
@@ -22,7 +22,7 @@
 
 # -------------------------------------------------change these settings-----------------------------------------------#
 name: str = 'default'
-class_selection: List[int] or None = None  # [0, 1, 2, 3, 4]
+class_selection: Optional[List[int]] = None  # [0, 1, 2, 3, 4]
 importance_type: ImportanceType = ImportanceType(
     ImportanceType.GAMMA | ImportanceType.L1)
 

examples/evaluate_importance_data.py

@@ -10,7 +10,7 @@
 from rendering.shader_uniforms import EDGE_SHADER_UNIFORM, NODE_SHADER_UNIFORM
 
 
-def set_stat_frame(gui_root: Tk, settings: Dict[Any, Any]):
+def set_stat_frame(gui_root: Tk, settings: Dict[Any, Any]) -> None:
     stats_frame: LabelFrame = LabelFrame(
         gui_root, text='Statistics', width=60, padx=5, pady=5)
     stats_frame.grid(row=0, column=0, padx=5, pady=5)