fix ruff issues

pyproject.toml

@@ -68,63 +68,63 @@ select = [
     "W",
     # pydocstyle
     "D",
-    # # pep8-naming
-    # "N",
-    # # flake8-2020
-    # "YTT",
-    # # flake8-bugbear
-    # "B",
-    # # flake8-quotes
-    # "Q",
-    # # flake8-debugger
-    # "T10",
-    # # flake8-gettext
-    # "INT",
-    # # pylint
-    # "PL",
-    # # misc lints
-    # "PIE",
-    # # flake8-pyi
+    # pep8-naming
+    "N",
+    # flake8-2020
+    "YTT",
+    # flake8-bugbear
+    "B",
+    # flake8-quotes
+    "Q",
+    # flake8-debugger
+    "T10",
+    # flake8-gettext
+    "INT",
+    # pylint
+    "PL",
+    # misc lints
+    "PIE",
+    # flake8-pyi
     # "PYI",
-    # # tidy imports
-    # "TID",
-    # # implicit string concatenation
-    # "ISC",
-    # # type-checking imports
-    # "TC",
-    # # comprehensions
+    # tidy imports
+    "TID",
+    # implicit string concatenation
+    "ISC",
+    # type-checking imports
+    "TC",
+    # comprehensions
     # "C",
-    # "C4",
-    # # pygrep-hooks
-    # "PGH",
-    # # Ruff-specific rules
-    # "RUF",
-    # # flake8-bandit: exec-builtin
-    # "S102",
-    # # numpy-legacy-random
-    # "NPY002",
-    # # Perflint
+    "C4",
+    # pygrep-hooks
+    "PGH",
+    # Ruff-specific rules
+    "RUF",
+    # flake8-bandit: exec-builtin
+    "S102",
+    # numpy-legacy-random
+    "NPY002",
+    # Perflint
     # "PERF",
-    # # flynt
-    # "FLY",
-    # # flake8-logging-format
-    # "G",
-    # # pyupgrade
-    # "UP",
-    # # annotation
-    # # "ANN"
-    # # bandit
+    # flynt
+    "FLY",
+    # flake8-logging-format
+    "G",
+    # pyupgrade
+    "UP",
+    # annotation
+    # "ANN"
+    # bandit
     # "S",
-    # # Argument
-    # # "ARG",
-    # # Pathlib
+    # Argument
+    # "ARG",
+    # Pathlib
     # "PTH",
-    # # Simplify
-    # # "SIM",
-    # # Return
-    # "RET",
-    # # Raise
-    # "RSE",
+    # Simplify
+    # "SIM",
+    # Return
+    "RET",
+    # Raise
+    "RSE",
 ]
 ignore = [
     # too-many-arguments
@@ -150,6 +150,8 @@ ignore = [
     'TC001',
     # Indent of doctest
     'D412',
+    # unused loop
+    'B007',
 ]
 [tool.ruff.lint.per-file-ignores]
 "tests/*" = [
@@ -164,6 +166,8 @@ ignore = [
     "D103",
     # Unused variables
     "F841",
+    # complexity
+    'PLR0915',
 ]
 
 [tool.ruff.lint.pydocstyle]
@@ -195,7 +199,3 @@ exclude_lines = [
 [tool.mypy]
 disable_error_code = "misc"
 ignore_missing_imports = true
-
-[[tool.mypy.overrides]]
-module = "tests.*"
-allow_untyped_defs = true

src/anytree/__init__.py

@@ -27,10 +27,10 @@
     "ContStyle",
     "CountError",
     "DoubleStyle",
+    "LevelGroupOrderIter",
     "LevelOrderGroupIter",
     "LevelOrderIter",
     "LightNodeMixin",
-    "LevelGroupOrderIter",
     "LoopError",
     "Node",
     "NodeMixin",

src/anytree/config.py

@@ -3,4 +3,4 @@
 import os
 
 # Global Option which enables all internal assertions.
-ASSERTIONS = bool(int(os.environ.get("ANYTREE_ASSERTIONS", 0)))
+ASSERTIONS = bool(int(os.environ.get("ANYTREE_ASSERTIONS", "0")))

src/anytree/dotexport.py

@@ -7,6 +7,8 @@ class RenderTreeGraph(DotExporter):
     def __init__(self, *args, **kwargs):
         """Legacy. Use :any:`anytree.exporter.DotExporter` instead."""
         warnings.warn(
-            ("anytree.RenderTreeGraph has moved. Use anytree.exporter.DotExporter instead"), DeprecationWarning
+            ("anytree.RenderTreeGraph has moved. Use anytree.exporter.DotExporter instead"),
+            DeprecationWarning,
+            stacklevel=2,
         )
-        super(RenderTreeGraph, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)

src/anytree/exporter/__init__.py

@@ -1,7 +1,14 @@
 """Exporter."""
 
-from .dictexporter import DictExporter  # noqa
-from .dotexporter import DotExporter  # noqa
-from .dotexporter import UniqueDotExporter  # noqa
-from .jsonexporter import JsonExporter  # noqa
-from .mermaidexporter import MermaidExporter  # noqa
+from .dictexporter import DictExporter
+from .dotexporter import DotExporter, UniqueDotExporter
+from .jsonexporter import JsonExporter
+from .mermaidexporter import MermaidExporter
+
+__all__ = [
+    "DictExporter",
+    "DotExporter",
+    "JsonExporter",
+    "MermaidExporter",
+    "UniqueDotExporter",
+]

src/anytree/exporter/dotexporter.py

@@ -223,26 +223,23 @@ def _default_filter(node):
 
     def __iter(self, indent, nodenamefunc, nodeattrfunc, edgeattrfunc, edgetypefunc, filter_):
         yield f"{self.graph} {self.name} {{"
-        for option in self.__iter_options(indent):
-            yield option
-        for node in self.__iter_nodes(indent, nodenamefunc, nodeattrfunc, filter_):
-            yield node
-        for edge in self.__iter_edges(indent, nodenamefunc, edgeattrfunc, edgetypefunc, filter_):
-            yield edge
+        yield from self.__iter_options(indent)
+        yield from self.__iter_nodes(indent, nodenamefunc, nodeattrfunc, filter_)
+        yield from self.__iter_edges(indent, nodenamefunc, edgeattrfunc, edgetypefunc, filter_)
         yield "}"
 
     def __iter_options(self, indent):
         options = self.options
         if options:
             for option in options:
-                yield "%s%s" % (indent, option)
+                yield f"{indent}{option}"
 
     def __iter_nodes(self, indent, nodenamefunc, nodeattrfunc, filter_):
         for node in PreOrderIter(self.node, filter_=filter_, stop=self.stop, maxlevel=self.maxlevel):
             nodename = nodenamefunc(node)
             nodeattr = nodeattrfunc(node)
-            nodeattr = " [%s]" % nodeattr if nodeattr is not None else ""
-            yield '%s"%s"%s;' % (indent, DotExporter.esc(nodename), nodeattr)
+            nodeattr = f" [{nodeattr}]" if nodeattr is not None else ""
+            yield f'{indent}"{DotExporter.esc(nodename)}"{nodeattr};'
 
     def __iter_edges(self, indent, nodenamefunc, edgeattrfunc, edgetypefunc, filter_):
         maxlevel = self.maxlevel - 1 if self.maxlevel else None
@@ -254,14 +251,8 @@ def __iter_edges(self, indent, nodenamefunc, edgeattrfunc, edgetypefunc, filter_
                 childname = nodenamefunc(child)
                 edgeattr = edgeattrfunc(node, child)
                 edgetype = edgetypefunc(node, child)
-                edgeattr = " [%s]" % edgeattr if edgeattr is not None else ""
-                yield '%s"%s" %s "%s"%s;' % (
-                    indent,
-                    DotExporter.esc(nodename),
-                    edgetype,
-                    DotExporter.esc(childname),
-                    edgeattr,
-                )
+                edgeattr = f" [{edgeattr}]" if edgeattr is not None else ""
+                yield f'{indent}"{DotExporter.esc(nodename)}" {edgetype} "{DotExporter.esc(childname)}"{edgeattr};'
 
     def to_dotfile(self, filename):
         """
@@ -288,7 +279,7 @@ def to_dotfile(self, filename):
         """
         with codecs.open(filename, "w", "utf-8") as file:
             for line in self:
-                file.write("%s\n" % line)
+                file.write(f"{line}\n")
 
     def to_picture(self, filename):
         """
@@ -302,7 +293,7 @@ def to_picture(self, filename):
         with NamedTemporaryFile("wb", delete=False) as dotfile:
             dotfilename = dotfile.name
             for line in self:
-                dotfile.write(("%s\n" % line).encode("utf-8"))
+                dotfile.write((f"{line}\n").encode())
             dotfile.flush()
             cmd = ["dot", dotfilename, "-T", fileformat, "-o", filename]
             check_call(cmd)
@@ -315,7 +306,7 @@ def to_picture(self, filename):
     @staticmethod
     def esc(value):
         """Escape Strings."""
-        return _RE_ESC.sub(lambda m: r"\%s" % m.group(0), six.text_type(value))
+        return _RE_ESC.sub(lambda m: rf"\{m.group(0)}", six.text_type(value))
 
 
 class UniqueDotExporter(DotExporter):
@@ -438,7 +429,7 @@ def __init__(
         stop=None,
         maxlevel=None,
     ):
-        super(UniqueDotExporter, self).__init__(
+        super().__init__(
             node,
             graph=graph,
             name=name,
@@ -466,4 +457,4 @@ def _default_nodenamefunc(self, node):
 
     @staticmethod
     def _default_nodeattrfunc(node):
-        return 'label="%s"' % (node.name,)
+        return f'label="{node.name}"'

src/anytree/exporter/mermaidexporter.py

@@ -166,12 +166,12 @@ def _default_nodenamefunc(self, node):
             num = self.__node_ids[node_id]
         except KeyError:
             num = self.__node_ids[node_id] = next(self.__node_counter)
-        return "N%d" % (num,)
+        return f"N{num}"
 
     @staticmethod
     def _default_nodefunc(node):
         # pylint: disable=W0613
-        return '["%s"]' % (MermaidExporter.esc(node.name),)
+        return f'["{MermaidExporter.esc(node.name)}"]'
 
     @staticmethod
     def _default_edgefunc(node, child):
@@ -180,24 +180,20 @@ def _default_edgefunc(node, child):
 
     def __iter(self, indent, nodenamefunc, nodefunc, edgefunc, filter_, stop):
         yield f"{self.graph} {self.name}"
-        for option in self.__iter_options(indent):
-            yield option
-        for node in self.__iter_nodes(indent, nodenamefunc, nodefunc, filter_, stop):
-            yield node
-        for edge in self.__iter_edges(indent, nodenamefunc, edgefunc, filter_, stop):
-            yield edge
+        yield from self.__iter_options(indent)
+        yield from self.__iter_nodes(indent, nodenamefunc, nodefunc, filter_, stop)
+        yield from self.__iter_edges(indent, nodenamefunc, edgefunc, filter_, stop)
 
     def __iter_options(self, indent):
         options = self.options
         if options:
             for option in options:
-                yield "%s%s" % (indent, option)
+                yield f"{indent}{option}"
 
     def __iter_nodes(self, indent, nodenamefunc, nodefunc, filter_, stop):
         for node in PreOrderIter(self.node, filter_=filter_, stop=stop, maxlevel=self.maxlevel):
             nodename = nodenamefunc(node)
-            node = nodefunc(node)
-            yield "%s%s%s" % (indent, nodename, node)
+            yield f"{indent}{nodename}{nodefunc(node)}"
 
     def __iter_edges(self, indent, nodenamefunc, edgefunc, filter_, stop):
         maxlevel = self.maxlevel - 1 if self.maxlevel else None
@@ -207,12 +203,7 @@ def __iter_edges(self, indent, nodenamefunc, edgefunc, filter_, stop):
                 if filter_(child) and not stop(child):
                     childname = nodenamefunc(child)
                     edge = edgefunc(node, child)
-                    yield "%s%s%s%s" % (
-                        indent,
-                        nodename,
-                        edge,
-                        childname,
-                    )
+                    yield f"{indent}{nodename}{edge}{childname}"
 
     def to_file(self, filename):
         """
@@ -235,10 +226,10 @@ def to_file(self, filename):
         with codecs.open(filename, "w", "utf-8") as file:
             file.write("```mermaid\n")
             for line in self:
-                file.write("%s\n" % line)
+                file.write(f"{line}\n")
             file.write("```")
 
     @staticmethod
     def esc(value):
         """Escape Strings."""
-        return _RE_ESC.sub(lambda m: r"\%s" % m.group(0), six.text_type(value))
+        return _RE_ESC.sub(lambda m: rf"\{m.group(0)}", six.text_type(value))

src/anytree/importer/__init__.py

@@ -1,4 +1,9 @@
 """Importer."""
 
-from .dictimporter import DictImporter  # noqa
-from .jsonimporter import JsonImporter  # noqa
+from .dictimporter import DictImporter
+from .jsonimporter import JsonImporter
+
+__all__ = [
+    "DictImporter",
+    "JsonImporter",
+]

src/anytree/importer/dictimporter.py

@@ -1,6 +1,5 @@
 from anytree import AnyNode
-
-from ..config import ASSERTIONS
+from anytree.config import ASSERTIONS
 
 
 class DictImporter:

src/anytree/iterators/__init__.py

@@ -8,9 +8,18 @@
 * :any:`ZigZagGroupIter`: iterate over tree using level-order strategy returning group for every level
 """
 
-from .abstractiter import AbstractIter  # noqa
-from .levelordergroupiter import LevelOrderGroupIter  # noqa
-from .levelorderiter import LevelOrderIter  # noqa
-from .postorderiter import PostOrderIter  # noqa
-from .preorderiter import PreOrderIter  # noqa
-from .zigzaggroupiter import ZigZagGroupIter  # noqa
+from .abstractiter import AbstractIter
+from .levelordergroupiter import LevelOrderGroupIter
+from .levelorderiter import LevelOrderIter
+from .postorderiter import PostOrderIter
+from .preorderiter import PreOrderIter
+from .zigzaggroupiter import ZigZagGroupIter
+
+__all__ = [
+    "AbstractIter",
+    "LevelOrderGroupIter",
+    "LevelOrderIter",
+    "PostOrderIter",
+    "PreOrderIter",
+    "ZigZagGroupIter",
+]