make format

features/steps/core.py

@@ -214,14 +214,17 @@ def open_editor_and_enter(context, method, text=""):
 
     # fmt: on
 
+
 @then("the runtime config should have {key_as_dots} set to {override_value}")
 def config_override(context, key_as_dots: str, override_value: str):
     with open(context.config_path) as f:
         loaded_cfg = yaml.load(f, Loader=yaml.FullLoader)
-        loaded_cfg['journal']='features/journals/simple.journal'
+        loaded_cfg["journal"] = "features/journals/simple.journal"
     base_cfg = loaded_cfg.copy()
+
     def _mock_callback(**args):
         print("callback executed")
+
     # fmt: off
     try: 
         with \
@@ -241,6 +244,8 @@ def config_override(context, key_as_dots:str, override_value: str):
     except SystemExit as e :
         context.exit_status = e.code
     # fmt: on
+
+
 @then("the editor {editor} should have been called")
 def editor_override(context, editor):
     def _mock_editor(command_and_journal_file):

jrnl/jrnl.py

@@ -52,6 +52,7 @@ def run(args):
     # Apply config overrides
     overrides = args.config_override
     from .override import apply_overrides
+
     config = apply_overrides(overrides, config)
 
     # --- All the standalone commands are now done --- #

jrnl/override.py

@@ -2,7 +2,7 @@
 def apply_overrides(overrides: dict, base_config: dict) -> dict:
     config = base_config.copy()
     for k in overrides:
-        nodes = k.split('.') 
+        nodes = k.split(".")
         config = recursively_apply(config, nodes, overrides[k])
     return config
 
@@ -18,8 +18,11 @@ def recursively_apply(config: dict, nodes: list, override_value) -> dict:
         override_value (str): runtime override passed from the command-line
     """
     key = nodes[0]
-    config[key] = override_value \
+    config[key] = (
-        if len(nodes) == 1 \
+        override_value
-        else \
+        if len(nodes) == 1
-        recursively_apply(config[key] if key in config else {}, nodes[1:], override_value)
+        else recursively_apply(
+            config[key] if key in config else {}, nodes[1:], override_value
+        )
+    )
     return config

tests/test_config.py

@@ -44,6 +44,7 @@ def test_override_configured_editor(
     parser = parse_args(cli_args)
     assert parser.config_override.__len__() == 1
     assert "editor" in parser.config_override.keys()
+
     def mock_editor_launch(editor):
         print("%s launched! Success!" % editor)
 
@@ -56,6 +57,7 @@ def test_override_configured_editor(
         run(parser)
     mock_write_in_editor.assert_called_once_with(expected_override)
 
+
 @pytest.fixture()
 def expected_color_override(minimal_config):
     exp_out_cfg = minimal_config.copy()
@@ -63,6 +65,7 @@ def expected_color_override(minimal_config):
     exp_out_cfg["journal"] = "features/journals/simple.journal"
     yield exp_out_cfg
 
+
 # @mock.patch.object(install,'load_or_install_jrnl')
 # @mock.patch('subprocess.call')
 # def test_override_configured_colors(mock_load_or_install, mock_subprocess_call, minimal_config, expected_color_override, capsys):
@@ -72,5 +75,3 @@ def expected_color_override(minimal_config):
 #     parser = parse_args(cli_args)
 #     assert "colors.body" in parser.config_override.keys()
 #     run(parser)
-
-    

tests/test_override.py

@@ -1,41 +1,34 @@
 import pytest
 
 from jrnl.override import apply_overrides, recursively_apply
+
+
 @pytest.fixture()
 def minimal_config():
     cfg = {
-        "colors":{ 
+        "colors": {"body": "red", "date": "green"},
-            "body":"red",
-            "date":"green"
-        },
         "default": "/tmp/journal.jrnl",
-        "editor":"vim"
+        "editor": "vim",
     }
     yield cfg
 
+
 def test_apply_override(minimal_config):
     config = minimal_config.copy()
-    overrides = {
+    overrides = {"editor": "nano"}
-        'editor':'nano'
-    }
     config = apply_overrides(overrides, config)
-    assert config['editor']=='nano'
+    assert config["editor"] == "nano"
+
 
 def test_override_dot_notation(minimal_config):
     cfg = minimal_config.copy()
-    overrides = { 
+    overrides = {"colors.body": "blue"}
-        "colors.body": "blue"
-    }
     cfg = apply_overrides(overrides=overrides, base_config=cfg)
     assert cfg["colors"] == {"body": "blue", "date": "green"}
 
+
 def test_recursive_override(minimal_config):
 
-    cfg = { 
+    cfg = {"colors": {"body": "red", "title": "green"}}
-        "colors": { 
+    cfg = recursively_apply(cfg, ["colors", "body"], "blue")
-            "body": "red",
-            "title": "green"
-        }
-    }
-    cfg = recursively_apply(cfg,["colors",'body'],"blue")
     assert cfg["colors"]["body"] == "blue"

tests/test_parse_args.py

@@ -211,10 +211,13 @@ def test_editor_override():
     assert cli_as_dict('--config-override \'{"editor": "nano"}\'') == expected_args(
         config_override={"editor": "nano"}
     )
+
+
 def test_color_override():
-    assert cli_as_dict('--config-override \'{"colors.body": "blue"}\'') == expected_args(
+    assert cli_as_dict(
-        config_override={"colors.body":"blue"}
+        '--config-override \'{"colors.body": "blue"}\''
-    )
+    ) == expected_args(config_override={"colors.body": "blue"})
+
 
 # @see https://github.com/jrnl-org/jrnl/issues/520
 @pytest.mark.parametrize(