Merge pull request #10 from ikamensh/black-formatting

Black formatting for the whole repository

Author: Iffi

.pre-commit-config.yaml

@@ -0,0 +1,6 @@
+repos:
+  - repo: https://github.com/psf/black
+    rev: 20.8b1 # Replace by any tag/version: https://github.com/psf/black/tags
+    hooks:
+      - id: black
+        language_version: python3 # Should be a command that runs python3.6+

DEVELOPMENT.md

@@ -0,0 +1,5 @@
+# Code style
+The code follows code styling by [black](https://github.com/psf/black).
+
+To automate code formatting, [pre-commit](https://github.com/pre-commit/pre-commit) is used, to run code checks before commiting changes.
+If you have pre-commit installed from the requirements-dev.txt simple run ``pre-commit install`` to install the hooks for this repo.

machin/auto/__init__.py

@@ -4,6 +4,4 @@
 from . import pl_logger
 from . import pl_plugin
 
-__all__ = [
-    "config", "dataset", "launcher", "pl_logger", "pl_plugin"
-]
+__all__ = ["config", "dataset", "launcher", "pl_logger", "pl_plugin"]

machin/auto/config.py

@@ -6,8 +6,9 @@
 import machin.frame.algorithms as algorithms
 
 
-def fill_default(default: Union[Dict[str, Any], Config],
-                  config: Union[Dict[str, Any], Config]):
+def fill_default(
+    default: Union[Dict[str, Any], Config], config: Union[Dict[str, Any], Config]
+):
     for key in default:
         if key not in config:
             config[key] = default[key]
@@ -18,46 +19,56 @@ def _get_available_algorithms():
     algos = []
     for algo in dir(algorithms):
         algo_cls = getattr(algorithms, algo)
-        if (inspect.isclass(algo_cls)
-                and issubclass(algo_cls, TorchFramework)
-                and algo_cls != TorchFramework):
+        if (
+            inspect.isclass(algo_cls)
+            and issubclass(algo_cls, TorchFramework)
+            and algo_cls != TorchFramework
+        ):
             algos.append(algo)
     return algos
 
 
-def generate_algorithm_config(algorithm: str,
-                              config: Union[Dict[str, Any], Config] = None):
+def generate_algorithm_config(
+    algorithm: str, config: Union[Dict[str, Any], Config] = None
+):
     config = deepcopy(config) or {}
     if hasattr(algorithms, algorithm):
         algo_obj = getattr(algorithms, algorithm)
         if issubclass(algo_obj, TorchFramework):
             return algo_obj.generate_config(config)
-    raise ValueError("Invalid algorithm: {}, valid ones are: {}"
-                     .format(algorithm, _get_available_algorithms()))
+    raise ValueError(
+        "Invalid algorithm: {}, valid ones are: {}".format(
+            algorithm, _get_available_algorithms()
+        )
+    )
 
 
 def init_algorithm_from_config(config: Union[Dict[str, Any], Config]):
     assert_config_complete(config)
     frame = getattr(algorithms, config["frame"], None)
     if not inspect.isclass(frame) or not issubclass(frame, TorchFramework):
-        raise ValueError("Invalid algorithm: {}, valid ones are: {}"
-                         .format(config["frame"], _get_available_algorithms()))
+        raise ValueError(
+            "Invalid algorithm: {}, valid ones are: {}".format(
+                config["frame"], _get_available_algorithms()
+            )
+        )
     return frame.init_from_config(config)
 
 
 def is_algorithm_distributed(config: Union[Dict[str, Any], Config]):
     assert_config_complete(config)
     frame = getattr(algorithms, config["frame"], None)
     if not inspect.isclass(frame) or not issubclass(frame, TorchFramework):
-        raise ValueError("Invalid algorithm: {}, valid ones are: {}"
-                         .format(config["frame"], _get_available_algorithms()))
+        raise ValueError(
+            "Invalid algorithm: {}, valid ones are: {}".format(
+                config["frame"], _get_available_algorithms()
+            )
+        )
     return frame.is_distributed()
 
 
 def assert_config_complete(config: Union[Dict[str, Any], Config]):
     assert "frame" in config, 'Missing key "frame" in config.'
     assert "frame_config" in config, 'Missing key "frame_config" in config.'
-    assert "train_env_config" in config, 'Missing key "train_env_config" ' \
-                                         'in config.'
-    assert "test_env_config" in config, 'Missing key "test_env_config" ' \
-                                        'in config.'
+    assert "train_env_config" in config, 'Missing key "train_env_config" ' "in config."
+    assert "test_env_config" in config, 'Missing key "test_env_config" ' "in config."

machin/auto/dataset.py

@@ -18,11 +18,12 @@ def determine_precision(models):
             dtype.add(v.dtype)
     dtype = list(dtype)
     if len(dtype) > 1:
-        raise RuntimeError("Multiple data types of parameters detected "
-                           "in models: {}, this is currently not supported "
-                           "since we need to determine the data type of your "
-                           "model input from your model parameter data type."
-                           .format(dtype))
+        raise RuntimeError(
+            "Multiple data types of parameters detected "
+            "in models: {}, this is currently not supported "
+            "since we need to determine the data type of your "
+            "model input from your model parameter data type.".format(dtype)
+        )
     return dtype[0]
 
 
@@ -43,9 +44,7 @@ def log_video(module, name, video_frames: List[np.ndarray]):
     # create video temp file
     _fd, path = tempfile.mkstemp(suffix=".gif")
     try:
-        create_video(video_frames,
-                     os.path.dirname(path),
-                     os.path.basename(path))
+        create_video(video_frames, os.path.dirname(path), os.path.basename(path))
     except Exception as e:
         print(e)
         os.remove(path)
@@ -58,10 +57,11 @@ def log_video(module, name, video_frames: List[np.ndarray]):
 
 
 class DatasetResult:
-    def __init__(self,
-                 observations: List[Dict[str, Any]] = None,
-                 logs: List[Dict[str, Union[Scalar, Tuple[Scalar, str]]]]
-                 = None):
+    def __init__(
+        self,
+        observations: List[Dict[str, Any]] = None,
+        logs: List[Dict[str, Union[Scalar, Tuple[Scalar, str]]]] = None,
+    ):
         self.observations = observations or []
         self.logs = logs or []
 
@@ -79,6 +79,7 @@ class RLDataset(IterableDataset):
     """
     Base class for all RL Datasets.
     """
+
     def __init__(self, **_kwargs):
         super(RLDataset, self).__init__()