Inspect code (#418)

* use PyCharm 'Inspect Code' for small Code improvements

* Some 'pylint' and 'perflint' updates

* Rollback

* Rollback

tests/integration_tests/examples/test_example_06.py

@@ -23,7 +23,7 @@ def arg(request):
 
 @pytest.fixture
 def fix_list() -> list:
-    return [x for x in range(10)]
+    return list(range(10))
 
 
 @pytest.fixture

tests/integration_tests/function_wrapper/test_func_func_deps.py

@@ -11,12 +11,12 @@ def func_1(cfg: NodeConfig):
 
 @nodify(outs=pathlib.Path("test2.txt"), deps=pathlib.Path("test.txt"))
 def func_2(cfg: NodeConfig):
-    cfg.outs.write_text(cfg.deps.read_text() + " 2")
+    cfg.outs.write_text(f"{cfg.deps.read_text()} 2")
 
 
 @nodify(outs=pathlib.Path("test3.txt"), deps=pathlib.Path("test.txt"))
 def func_3(cfg: NodeConfig):
-    cfg.outs.write_text(cfg.deps.read_text() + " 3")
+    cfg.outs.write_text(f"{cfg.deps.read_text()} 3")
 
 
 def test_example_func(proj_path):

tests/integration_tests/interface/test_base_interface.py

@@ -53,19 +53,13 @@ def test_experiments(loaded_dvc_interface):
 
 
 def test_exp_list(loaded_dvc_interface):
-    assert (
-        loaded_dvc_interface.exp_list[0].name == "master"
-        or loaded_dvc_interface.exp_list[0].name == "main"
-    )
+    assert loaded_dvc_interface.exp_list[0].name in ["master", "main"]
     assert len(loaded_dvc_interface.exp_list) == 1
 
 
 def test__reset(loaded_dvc_interface):
     loaded_dvc_interface._reset()
-    assert (
-        loaded_dvc_interface.exp_list[0].name == "master"
-        or loaded_dvc_interface.exp_list[0].name == "main"
-    )
+    assert loaded_dvc_interface.exp_list[0].name in ["master", "main"]
 
 
 def test_load_files_into_directory(multi_experiment_path):

tests/integration_tests/test_dvc_outs.py

@@ -72,4 +72,4 @@ def test_SingleNodeInNodeDirMulti(proj_path):
 
     result = SingleNodeInNodeDir["TestNode"]
     assert result.path == [pathlib.Path("nodes", "TestNode", "test.json"), "file.txt"]
-    assert all([pathlib.Path(x).exists() for x in result.path])
+    assert all(pathlib.Path(x).exists() for x in result.path)

tests/integration_tests/test_zn_methods.py

@@ -76,7 +76,7 @@ def __init__(self, data_classes=None, **kwargs):
         self.data_classes = data_classes
 
     def run(self):
-        self.result = sum([x.param1 + x.param2 for x in self.data_classes])
+        self.result = sum(x.param1 + x.param2 for x in self.data_classes)
 
 
 def test_methods_list(proj_path):

tests/integration_tests/test_zn_plots.py

@@ -12,22 +12,22 @@ class WritePlots(Node):
     plots: pd.DataFrame = zn.plots()
 
     def run(self):
-        self.plots = pd.DataFrame({"value": [x for x in range(100)]})
+        self.plots = pd.DataFrame({"value": list(range(100))})
         self.plots.index.name = "my_index"
 
 
 class WritePlotsNoIndex(Node):
     plots: pd.DataFrame = zn.plots()
 
     def run(self):
-        self.plots = pd.DataFrame({"value": [x for x in range(100)]})
+        self.plots = pd.DataFrame({"value": list(range(100))})
 
 
 class WritePlotsWrongData(Node):
     plots: pd.DataFrame = zn.plots()
 
     def run(self):
-        self.plots = {"value": [x for x in range(100)]}
+        self.plots = {"value": list(range(100))}
 
 
 def test_write_plots(proj_path):
@@ -41,7 +41,7 @@ def test_write_plots(proj_path):
 def test_load_plots(proj_path):
     WritePlots().run_and_save()
 
-    df = pd.DataFrame({"value": [x for x in range(100)]})
+    df = pd.DataFrame({"value": list(range(100))})
     df.index.name = "index"
 
     assert df.equals(WritePlots.load().plots)
@@ -71,7 +71,7 @@ class WriteTwoPlots(Node):
     plots_b: pd.DataFrame = zn.plots()
 
     def run(self):
-        self.plots_a = pd.DataFrame({"value": [x for x in range(100)]})
+        self.plots_a = pd.DataFrame({"value": list(range(100))})
         self.plots_a.index.name = "my_index_a"
 
         self.plots_b = pd.DataFrame({"value": [-x for x in range(100)]})
@@ -94,7 +94,7 @@ class WritePlotsModify(Node):
     plots = zn.plots(x_label="test_label", title="My Plot", template="smooth")
 
     def run(self):
-        self.plots = pd.DataFrame({"value": [x for x in range(100)]})
+        self.plots = pd.DataFrame({"value": list(range(100))})
 
 
 class WritePlotsModifyDVC(Node):

tests/integration_tests/various_tests.py

@@ -28,7 +28,7 @@ class DepsCollector(Node):
     outs = zn.outs()
 
     def run(self):
-        self.outs = sum([x.outs for x in self.deps])
+        self.outs = sum(x.outs for x in self.deps)
 
 
 def test_multi_deps(proj_path):

zntrack/core/base.py

@@ -1,6 +1,8 @@
 """ZnTrack Node class module"""
+
 from __future__ import annotations
 
+import contextlib
 import json
 import logging
 import pathlib
@@ -59,16 +61,13 @@ def handle_deps(value) -> typing.List[str]:
     if isinstance(value, (list, tuple)):
         for lst_val in value:
             deps_files += handle_deps(lst_val)
-    else:
-        if isinstance(value, (Node, NodeAttribute)):
-            for file in value.affected_files:
-                deps_files.append(pathlib.Path(file).as_posix())
-        elif isinstance(value, (str, pathlib.Path)):
-            deps_files.append(pathlib.Path(value).as_posix())
-        elif value is None:
-            pass
-        else:
-            raise ValueError(f"Type {type(value)} ({value}) is not supported!")
+    elif isinstance(value, (Node, NodeAttribute)):
+        for file in value.affected_files:
+            deps_files.append(pathlib.Path(file).as_posix())
+    elif isinstance(value, (str, pathlib.Path)):
+        deps_files.append(pathlib.Path(value).as_posix())
+    elif value is not None:
+        raise ValueError(f"Type {type(value)} ({value}) is not supported!")
 
     return deps_files
 
@@ -86,13 +85,12 @@ def _handle_nodes_as_methods(nodes: dict):
     nodes: dict
         A dictionary of {option_name: zntrack.Node}
     """
-    for attribute, node in nodes.items():
-        if node is None:
-            continue
-        node.write_graph(
-            run=True,
-            call_args=f".load(name='{node.node_name}').save(hash_only=True)",
-        )
+    for node in nodes.values():
+        if node is not None:
+            node.write_graph(
+                run=True,
+                call_args=f".load(name='{node.node_name}').save(hash_only=True)",
+            )
 
 
 BaseNodeTypeT = typing.TypeVar("BaseNodeTypeT", bound="Node")
@@ -119,9 +117,8 @@ def __getitem__(cls: Node, item: typing.Union[str, dict]) -> BaseNodeTypeT:
             raise ValueError(
                 f"Can only load {cls} with type (str, dict). Found {type(item)}"
             )
-        if isinstance(item, dict):
-            return cls.load(**item)
-        return cls.load(name=item)
+
+        return cls.load(**item) if isinstance(item, dict) else cls.load(name=item)
 
     def __matmul__(cls, other: str) -> typing.Union[NodeAttribute, typing.Any]:
         """Shorthand for: getdeps(Node, other)
@@ -151,7 +148,7 @@ class NodeBase(zninit.ZnInit):
     is_loaded: bool
         if the class is loaded this can be used to only run certain code, e.g. in the init
     node_name: str
-        first priority is by passing it through kwargs
+        first priority is if requested via kwargs
         second is having the class attribute set in the class definition
         last if both above are None it will be set to __class__.__name__
     is_attribute: bool, default = False
@@ -168,7 +165,7 @@ class NodeBase(zninit.ZnInit):
     def __init__(self, **kwargs):
         self.is_loaded = kwargs.pop("is_loaded", False)
         name = kwargs.pop("name", None)
-        if len(kwargs) > 0:
+        if kwargs:
             raise TypeError(f"'{kwargs}' are an invalid keyword argument")
         if name is not None:
             # overwrite node_name attribute
@@ -307,12 +304,8 @@ def _update_options(self, lazy=None):
             if not lazy:
                 # trigger loading the data into memory
                 value = getattr(self, option.name)
-                try:
+                with contextlib.suppress(AttributeError):
                     value._update_options(lazy=False)
-                except AttributeError:
-                    # if lazy=False trigger update_options iteratively on
-                    # all dependency Nodes
-                    pass
         self.is_loaded = True
 
     @classmethod
@@ -351,15 +344,11 @@ def __init__(self, **kwargs):
         try:
             instance = cls(name=name, is_loaded=True)
         except TypeError as type_error:
-            if getattr(cls.__init__, "uses_auto_init", False):
+            if not getattr(cls.__init__, "uses_auto_init", False):
+                # when not using the automatic init all arguments must have a
+                # default value and the super call is required. It would still be
                 # using new + init from Node class to circumvent required
                 # arguments in the automatic init
-                instance = object.__new__(cls)
-                Node.__init__(instance, name=name, is_loaded=True)
-            else:
-                # when not using the automatic init all arguments must have a
-                # default value and the super call is required. It would still
-                # be
                 raise TypeError(
                     f"Unable to create a new instance of {cls}. Check that all arguments"
                     " default to None. It must be possible to instantiate the class via"
@@ -368,6 +357,8 @@ def __init__(self, **kwargs):
                     "See the ZnTrack documentation for more information."
                 ) from type_error
 
+            instance = object.__new__(cls)
+            Node.__init__(instance, name=name, is_loaded=True)
         assert instance.node_name is not None, (
             "The name of the Node is not set. Probably missing"
             " 'super().__init__(**kwargs)' inside the custom '__init__'."
@@ -480,7 +471,7 @@ def write_graph(
         """Write the DVC file using run.
 
         If it already exists it'll tell you that the stage is already persistent and
-        has been run before. Otherwise it'll run the stage for you.
+        has been run before. Otherwise, it'll run the stage for you.
 
         Parameters
         ----------

zntrack/core/dvcgraph.py

@@ -105,8 +105,8 @@ def filter_ZnTrackOption(
         {descriptor.dvc_option: {attr_name: attr_value}}
 
     """
-    if not isinstance(zn_type, list):
-        zn_type = [zn_type]
+    if not isinstance(zn_type, (list, tuple)):
+        zn_type = (zn_type,)
     data = [x for x in data if x.zn_type in zn_type]
     if return_with_type:
         types_dict = {x.dvc_option: {} for x in data}

zntrack/core/functions/decorator.py

@@ -50,18 +50,17 @@ def __post_init__(self):
                 # params does not have to be a string
                 if not isinstance(option_value, dict) and option_value is not None:
                     raise ValueError("Parameter must be dict or dot4dict.dotdict.")
-            else:
-                if not utils.check_type(
-                    option_value,
-                    (str, pathlib.Path),
-                    allow_iterable=True,
-                    allow_none=True,
-                    allow_dict=True,
-                ):
-                    raise ValueError(
-                        f"{option_value} is not a supported type. "
-                        "Please use single values or lists of <str> and <pathlib.Path>."
-                    )
+            elif not utils.check_type(
+                option_value,
+                (str, pathlib.Path),
+                allow_iterable=True,
+                allow_none=True,
+                allow_dict=True,
+            ):
+                raise ValueError(
+                    f"{option_value} is not a supported type. "
+                    "Please use single values or lists of <str> and <pathlib.Path>."
+                )
 
     def convert_fields_to_dotdict(self):
         """Update all fields to dotdict, if they are of type dict"""
@@ -86,9 +85,8 @@ def write_dvc_command(self, node_name: str) -> list:
 
         """
         script = []
-        if self.params is not None:
-            if len(self.params) > 0:
-                script += ["--params", f"{utils.Files.params}:{node_name}"]
+        if self.params is not None and len(self.params) > 0:
+            script += ["--params", f"{utils.Files.params}:{node_name}"]
         for datacls_field in dataclasses.fields(self):
             if datacls_field.name == "params":
                 continue
@@ -278,36 +276,35 @@ def wrapper(
             if exec_func:
                 return execute_function_call(func)
 
-            else:
-                cfg = copy.deepcopy(cfg_)
-                save_node_config_to_files(cfg=cfg, node_name=func.__name__)
-                dvc_run_option = DVCRunOptions(
-                    no_commit=no_commit,
-                    external=external,
-                    always_changed=always_changed,
-                    no_run_cache=no_run_cache,
-                    force=force,
-                )
+            cfg = copy.deepcopy(cfg_)
+            save_node_config_to_files(cfg=cfg, node_name=func.__name__)
+            dvc_run_option = DVCRunOptions(
+                no_commit=no_commit,
+                external=external,
+                always_changed=always_changed,
+                no_run_cache=no_run_cache,
+                force=force,
+            )
 
-                script = prepare_dvc_script(
-                    node_name=func.__name__,
-                    dvc_run_option=dvc_run_option,
-                    custom_args=cfg.write_dvc_command(func.__name__),
-                    nb_name=nb_name,
-                    module=module,
-                    func_or_cls=func.__name__,
-                    call_args="(exec_func=True)",
-                )
+            script = prepare_dvc_script(
+                node_name=func.__name__,
+                dvc_run_option=dvc_run_option,
+                custom_args=cfg.write_dvc_command(func.__name__),
+                nb_name=nb_name,
+                module=module,
+                func_or_cls=func.__name__,
+                call_args="(exec_func=True)",
+            )
 
-                if dry_run:
-                    return script
-                utils.run_dvc_cmd(script)
+            if dry_run:
+                return script
+            utils.run_dvc_cmd(script)
 
-                if not no_exec:
-                    utils.run_dvc_cmd(["dvc", "repro", func.__name__])
+            if not no_exec:
+                utils.run_dvc_cmd(["dvc", "repro", func.__name__])
 
-                cfg.convert_fields_to_dotdict()
-                return cfg
+            cfg.convert_fields_to_dotdict()
+            return cfg
 
         return wrapper
 

zntrack/metadata/decorators.py

@@ -1,3 +1,4 @@
+import contextlib
 import dataclasses
 import statistics
 from time import time
@@ -15,11 +16,9 @@ class AggregateData:
 
     def update(self):
         """Recompute mean and standard deviation"""
-        try:
+        with contextlib.suppress(statistics.StatisticsError):
             self.mean = statistics.mean(self.values)
             self.std = statistics.stdev(self.values)
-        except statistics.StatisticsError:
-            pass
 
 
 class TimeIt(MetaData):

zntrack/utils/__init__.py

@@ -39,7 +39,6 @@
     "check_type",
     "get_python_interpreter",
     "run_dvc_cmd",
-    "get_auto_init",
     "FILE_DVC_TRACKED",
     "VALUE_DVC_TRACKED",
     "DVCOptions",