swcgeom 0.15.0__py3-none-any.whl → 0.18.3__py3-none-any.whl

swcgeom/core/swc_utils/assembler.py

@@ -1,3 +1,18 @@
+# Copyright 2022-2025 Zexin Yuan
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
 """Assemble lines to swc.
 
 Notes
@@ -6,11 +21,16 @@ This module is deprecated, please use `~.transforms.LinesToTree`
 instead.
 """
 
-
 __all__ = ["assemble_lines", "try_assemble_lines"]
 
 
 def assemble_lines(*args, **kwargs):
+    """Assemble lines to tree.
+
+    .. deprecated:: 0.15.0
+        Use :meth:`~.transforms.LinesToTree` instead.
+    """
+
     raise DeprecationWarning(
         "`assemble_lines` has been replaced by "
         "`~.transforms.LinesToTree` because it can be easy assemble "
@@ -19,6 +39,12 @@ def assemble_lines(*args, **kwargs):
 
 
 def try_assemble_lines(*args, **kwargs):
+    """Try assemble lines to tree.
+
+    .. deprecated:: 0.15.0
+        Use :meth:`~.transforms.LinesToTree` instead.
+    """
+
     raise DeprecationWarning(
         "`try_assemble_lines` has been replaced by "
         "`~.transforms.LinesToTree` because it can be easy assemble "

swcgeom/core/swc_utils/base.py

@@ -1,7 +1,22 @@
+# Copyright 2022-2025 Zexin Yuan
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
 """Base SWC format utils."""
 
-from dataclasses import dataclass
-from typing import Callable, List, Literal, Optional, Tuple, TypeVar, overload
+from collections.abc import Callable
+from typing import Literal, NamedTuple, Optional, TypeVar, overload
 
 import numpy as np
 import numpy.typing as npt
@@ -20,11 +35,10 @@ __all__ = [
 ]
 
 T, K = TypeVar("T"), TypeVar("K")
-Topology = Tuple[npt.NDArray[np.int32], npt.NDArray[np.int32]]  # (id, pid)
+Topology = tuple[npt.NDArray[np.int32], npt.NDArray[np.int32]]  # (id, pid)
 
 
-@dataclass
-class SWCNames:
+class SWCNames(NamedTuple):
     """SWC format column names."""
 
     id: str = "id"
@@ -35,7 +49,7 @@ class SWCNames:
     r: str = "r"
     pid: str = "pid"
 
-    def cols(self) -> List[str]:
+    def cols(self) -> list[str]:
         return [self.id, self.type, self.x, self.y, self.z, self.r, self.pid]
 
 
@@ -46,8 +60,7 @@ def get_names(names: Optional[SWCNames] = None) -> SWCNames:
     return names or swc_names
 
 
-@dataclass
-class SWCTypes:
+class SWCTypes(NamedTuple):
     """SWC format types.
 
     See Also
@@ -107,10 +120,10 @@ def get_dsu(
 @overload
 def traverse(topology: Topology, *, enter: Callable[[int, T | None], T], root: int | np.integer = ..., mode: Literal["dfs"] = ...) -> None: ...
 @overload
-def traverse(topology: Topology, *, leave: Callable[[int, List[K]], K], root: int | np.integer = ..., mode: Literal["dfs"] = ...) -> K: ...
+def traverse(topology: Topology, *, leave: Callable[[int, list[K]], K], root: int | np.integer = ..., mode: Literal["dfs"] = ...) -> K: ...
 @overload
 def traverse(
-    topology: Topology, *, enter: Callable[[int, T | None], T], leave: Callable[[int, List[K]], K],
+    topology: Topology, *, enter: Callable[[int, T | None], T], leave: Callable[[int, list[K]], K],
     root: int | np.integer = ..., mode: Literal["dfs"] = ...,
 ) -> K: ...
 # fmt: on
@@ -123,7 +136,7 @@ def traverse(topology: Topology, *, mode="dfs", **kwargs):
         The callback when entering node, which accepts two parameters,
         the current node id and the return value of it parent node. In
         particular, the root node receives an `None`.
-    leave : (id: int, children: List[T]) => T, optional
+    leave : (id: int, children: list[T]) => T, optional
         The callback when leaving node. When leaving a node, subtree
         has already been traversed. Callback accepts two parameters,
         the current node id and list of the return value of children,
@@ -148,7 +161,7 @@ def _traverse_dfs(topology: Topology, *, enter=None, leave=None, root=0):
         children_map[pid].append(idx)
 
     # manual dfs to avoid stack overflow in long branch
-    stack: List[Tuple[int, bool]] = [(root, True)]  # (idx, is_enter)
+    stack: list[tuple[int, bool]] = [(root, True)]  # (idx, is_enter)
     params = {root: None}
     vals = {}
 

swcgeom/core/swc_utils/checker.py

@@ -1,16 +1,30 @@
-"""Check common """
+# Copyright 2022-2025 Zexin Yuan
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""Check common"""
 
-import warnings
 from collections import defaultdict
 from typing import Optional
 
 import numpy as np
 import pandas as pd
+from typing_extensions import deprecated
 
 from swcgeom.core.swc_utils.base import SWCNames, Topology, get_dsu, get_names, traverse
 from swcgeom.utils import DisjointSetUnion
 
-
 __all__ = [
     "is_single_root",
     "is_bifurcate",
@@ -82,24 +96,27 @@ def has_cyclic(topology: Topology) -> bool:
     return False
 
 
+@deprecated("Use `is_single_root` instead")
 def check_single_root(*args, **kwargs) -> bool:
-    warnings.warn(
-        "`check_single_root` has been renamed to `is_single_root` since"
-        "v0.5.0, and will be removed in next version",
-        DeprecationWarning,
-    )
+    """Check if the tree is single root.
+
+    .. deprecated:: 0.5.0
+        Use :meth:`is_single_root` instead.
+    """
+
     return is_single_root(*args, **kwargs)
 
 
+@deprecated("Use `is_bifurcate` instead")
 def is_binary_tree(
     df: pd.DataFrame, exclude_root: bool = True, *, names: Optional[SWCNames] = None
 ) -> bool:
-    """Check is it a binary tree."""
-    warnings.warn(
-        "`is_binary_tree` has been replaced by to `is_bifurcate` since"
-        "v0.8.0, and will be removed in next version",
-        DeprecationWarning,
-    )
+    """Check is it a binary tree.
+
+    .. deprecated:: 0.8.0
+        Use :meth:`is_bifurcate` instead.
+    """
+
     names = get_names(names)
     topo = (df[names.id].to_numpy(), df[names.pid].to_numpy())
     return is_bifurcate(topo, exclude_root=exclude_root)

swcgeom/core/swc_utils/io.py

@@ -1,8 +1,24 @@
+# Copyright 2022-2025 Zexin Yuan
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
 """Read and write swc format."""
 
 import re
 import warnings
-from typing import Callable, Iterable, List, Literal, Optional, Tuple
+from collections.abc import Callable, Iterable
+from typing import Literal, Optional
 
 import numpy as np
 import numpy.typing as npt
@@ -30,7 +46,7 @@ def read_swc(
     *,
     encoding: Literal["detect"] | str = "utf-8",
     names: Optional[SWCNames] = None,
-) -> Tuple[pd.DataFrame, List[str]]:
+) -> tuple[pd.DataFrame, list[str]]:
     """Read swc file.
 
     Parameters
@@ -55,7 +71,7 @@ def read_swc(
     Returns
     -------
     df : ~pandas.DataFrame
-    comments : list of string
+    comments : List of string
     """
 
     names = get_names(names)
@@ -137,14 +153,14 @@ def parse_swc(
     names: SWCNames,
     extra_cols: Iterable[str] | None = None,
     encoding: Literal["detect"] | str = "utf-8",
-) -> Tuple[pd.DataFrame, List[str]]:
+) -> tuple[pd.DataFrame, list[str]]:
     """Parse swc file.
 
     Parameters
     ----------
     fname : PathOrIO
     names : SWCNames
-    extra_cols : list of str, optional
+    extra_cols : List of str, optional
     encoding : str | 'detect', default `utf-8`
         The name of the encoding used to decode the file. If is
         `detect`, we will try to detect the character encoding.
@@ -152,7 +168,7 @@ def parse_swc(
     Returns
     -------
     df : ~pandas.DataFrame
-    comments : list of string
+    comments : List of string
     """
 
     # pylint: disable=too-many-locals
@@ -171,7 +187,8 @@ def parse_swc(
         RE_FLOAT,  # r
         r"(-?[0-9]+)",  # pid
     ] + [
-        RE_FLOAT for _ in extras  # assert float
+        RE_FLOAT
+        for _ in extras  # assert float
     ]
 
     re_swc_cols_str = r"\s+".join(re_swc_cols)

swcgeom/core/swc_utils/normalizer.py

@@ -1,9 +1,25 @@
+# Copyright 2022-2025 Zexin Yuan
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
 """SWC format utils.
 
 Methods ending with a underline imply an in-place transformation.
 """
 
-from typing import Callable, List, Literal, Optional, Tuple
+from collections.abc import Callable
+from typing import Literal, Optional
 
 import numpy as np
 import numpy.typing as npt
@@ -76,7 +92,7 @@ def link_roots_to_nearest_(
         vs = df[[names.x, names.y, names.z]] - row[[names.x, names.y, names.z]]
         dis = np.linalg.norm(vs.to_numpy(), axis=1)
         subtree = dsu == dsu[i]  # type: ignore
-        dis = np.where(subtree, np.Infinity, dis)  # avoid link to same tree
+        dis = np.where(subtree, np.inf, dis)  # avoid link to same tree
         dsu = np.where(subtree, dsu[dis.argmin()], dsu)  # merge set
         df.loc[i, names.pid] = df[names.id].iloc[dis.argmin()]  # type: ignore
 
@@ -111,7 +127,7 @@ def sort_nodes_(df: pd.DataFrame, *, names: Optional[SWCNames] = None) -> None:
     df[names.id], df[names.pid] = new_ids, new_pids
 
 
-def sort_nodes_impl(topology: Topology) -> Tuple[Topology, npt.NDArray[np.int32]]:
+def sort_nodes_impl(topology: Topology) -> tuple[Topology, npt.NDArray[np.int32]]:
     """Sort the indices of neuron tree.
 
     Returns
@@ -127,7 +143,7 @@ def sort_nodes_impl(topology: Topology) -> Tuple[Topology, npt.NDArray[np.int32]
     new_pids = np.full_like(old_ids, fill_value=-3)
     new_id = 0
     first_root = old_ids[(old_pids == -1).argmax()]
-    s: List[Tuple[npt.NDArray[np.int32], int]] = [(first_root, -1)]
+    s: list[tuple[npt.NDArray[np.int32], int]] = [(first_root, -1)]
     while len(s) != 0:
         old_id, new_pid = s.pop()
         id_map[new_id] = old_id

swcgeom/core/swc_utils/subtree.py

@@ -1,3 +1,18 @@
+# Copyright 2022-2025 Zexin Yuan
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
 """Cut subtree.
 
 This module provides a series of low-level topological subtree methods,
@@ -6,7 +21,7 @@ but in more cases, you can use the high-level methods provided in
 high-level API.
 """
 
-from typing import Tuple, cast
+from typing import cast
 
 import numpy as np
 import numpy.typing as npt
@@ -18,7 +33,7 @@ __all__ = ["REMOVAL", "to_sub_topology", "propagate_removal"]
 REMOVAL = -2  # A marker in utils, place in the ids to mark it removal
 
 
-def to_sub_topology(sub: Topology) -> Tuple[Topology, npt.NDArray[np.int32]]:
+def to_sub_topology(sub: Topology) -> tuple[Topology, npt.NDArray[np.int32]]:
     """Create sub tree from origin tree.
 
     Mark the node to be removed, then use this method to get a child

swcgeom/core/tree.py

@@ -1,30 +1,34 @@
+# Copyright 2022-2025 Zexin Yuan
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
 """Neuron tree."""
 
 import itertools
 import os
-import warnings
-from typing import (
-    Callable,
-    Dict,
-    Iterable,
-    Iterator,
-    List,
-    Literal,
-    Optional,
-    Tuple,
-    TypeVar,
-    Union,
-    overload,
-)
+from collections.abc import Callable, Iterable, Iterator
+from typing import Literal, Optional, TypeVar, Union, overload
 
 import numpy as np
 import numpy.typing as npt
 import pandas as pd
+from typing_extensions import deprecated
 
 from swcgeom.core.branch import Branch
+from swcgeom.core.compartment import Compartment, Compartments
 from swcgeom.core.node import Node
 from swcgeom.core.path import Path
-from swcgeom.core.segment import Segment, Segments
 from swcgeom.core.swc import DictSWC, eswc_cols
 from swcgeom.core.swc_utils import SWCNames, get_names, read_swc, traverse
 from swcgeom.core.tree_utils_impl import Mapping, get_subtree_impl
@@ -44,26 +48,17 @@ class Tree(DictSWC):
         def parent(self) -> Union["Tree.Node", None]:
             return Tree.Node(self.attach, self.pid) if self.pid != -1 else None
 
-        def children(self) -> List["Tree.Node"]:
+        def children(self) -> list["Tree.Node"]:
             children = self.attach.id()[self.attach.pid() == self.id]
             return [Tree.Node(self.attach, idx) for idx in children]
 
-        def get_branch(self) -> "Tree.Branch":
-            warnings.warn(
-                "`Tree.Node.get_branch` has been renamed to "
-                "`Tree.Node.branch` since v0.3.1 and will be removed "
-                "in next version",
-                DeprecationWarning,
-            )
-            return self.branch()
-
         def branch(self) -> "Tree.Branch":
-            ns: List["Tree.Node"] = [self]
-            while not ns[-1].is_bifurcation() and (p := ns[-1].parent()) is not None:
+            ns: list["Tree.Node"] = [self]
+            while not ns[-1].is_furcation() and (p := ns[-1].parent()) is not None:
                 ns.append(p)
 
             ns.reverse()
-            while not (ns[-1].is_bifurcation() or ns[-1].is_tip()):
+            while not (ns[-1].is_furcation() or ns[-1].is_tip()):
                 ns.append(ns[-1].children()[0])
 
             return Tree.Branch(self.attach, [n.id for n in ns])
@@ -77,7 +72,7 @@ class Tree(DictSWC):
 
             Parameters
             ----------
-            out_mapping : List of int or Dict[int, int], optional
+            out_mapping : List of int or dict[int, int], optional
                 Map from new id to old id.
             """
 
@@ -115,9 +110,11 @@ class Tree(DictSWC):
         # TODO: should returns `Tree.Node`
         """Neural path."""
 
-    class Segment(Segment["Tree"]):
+    class Compartment(Compartment["Tree"]):
         # TODO: should returns `Tree.Node`
-        """Neural segment."""
+        """Neural compartment."""
+
+    Segment = Compartment  # Alias
 
     class Branch(Branch["Tree"]):
         # TODO: should returns `Tree.Node`
@@ -127,33 +124,33 @@ class Tree(DictSWC):
         self,
         n_nodes: int,
         *,
-        # pylint: disable-next=redefined-builtin
-        id: Optional[npt.NDArray[np.int32]] = None,
-        # pylint: disable-next=redefined-builtin
-        type: Optional[npt.NDArray[np.int32]] = None,
-        x: Optional[npt.NDArray[np.float32]] = None,
-        y: Optional[npt.NDArray[np.float32]] = None,
-        z: Optional[npt.NDArray[np.float32]] = None,
-        r: Optional[npt.NDArray[np.float32]] = None,
-        pid: Optional[npt.NDArray[np.int32]] = None,
         source: str = "",
         comments: Optional[Iterable[str]] = None,
         names: Optional[SWCNames] = None,
         **kwargs: npt.NDArray,
     ) -> None:
         names = get_names(names)
-        id = np.arange(0, n_nodes, step=1, dtype=np.int32) if id is None else id
-        pid = np.arange(-1, n_nodes - 1, step=1, dtype=np.int32) if pid is None else pid
+
+        if names.id not in kwargs:
+            kwargs[names.id] = np.arange(0, n_nodes, step=1, dtype=np.int32)
+
+        if names.pid not in kwargs:
+            kwargs[names.pid] = np.arange(-1, n_nodes - 1, step=1, dtype=np.int32)
 
         ndata = {
-            names.id: padding1d(n_nodes, id, dtype=np.int32),
-            names.type: padding1d(n_nodes, type, dtype=np.int32),
-            names.x: padding1d(n_nodes, x),
-            names.y: padding1d(n_nodes, y),
-            names.z: padding1d(n_nodes, z),
-            names.r: padding1d(n_nodes, r, padding_value=1),
-            names.pid: padding1d(n_nodes, pid, dtype=np.int32),
+            names.id: padding1d(n_nodes, kwargs.pop(names.id, None), dtype=np.int32),
+            names.type: padding1d(
+                n_nodes, kwargs.pop(names.type, None), dtype=np.int32
+            ),
+            names.x: padding1d(n_nodes, kwargs.pop(names.x, None), dtype=np.float32),
+            names.y: padding1d(n_nodes, kwargs.pop(names.y, None), dtype=np.float32),
+            names.z: padding1d(n_nodes, kwargs.pop(names.z, None), dtype=np.float32),
+            names.r: padding1d(
+                n_nodes, kwargs.pop(names.r, None), dtype=np.float32, padding_value=1
+            ),
+            names.pid: padding1d(n_nodes, kwargs.pop(names.pid, None), dtype=np.int32),
         }
+        # ? padding other columns
         super().__init__(
             **ndata, **kwargs, source=source, comments=comments, names=names
         )
@@ -167,7 +164,7 @@ class Tree(DictSWC):
 
     # fmt:off
     @overload
-    def __getitem__(self, key: slice) -> List[Node]: ...
+    def __getitem__(self, key: slice) -> list[Node]: ...
     @overload
     def __getitem__(self, key: int) -> Node: ...
     @overload
@@ -206,35 +203,50 @@ class Tree(DictSWC):
             raise ValueError(f"no soma found in: {self.source}")
         return n
 
-    def get_bifurcations(self) -> List[Node]:
-        """Get all node of bifurcations."""
-        bifurcations: List[int] = []
+    def get_furcations(self) -> list[Node]:
+        """Get all node of furcations."""
+        furcations: list[int] = []
 
-        def collect_bifurcations(n: Tree.Node, children: List[None]) -> None:
+        def collect_furcations(n: Tree.Node, children: list[None]) -> None:
             if len(children) > 1:
-                bifurcations.append(n.id)
+                furcations.append(n.id)
+
+        self.traverse(leave=collect_furcations)
+        return [self.node(i) for i in furcations]
 
-        self.traverse(leave=collect_bifurcations)
-        return [self.node(i) for i in bifurcations]
+    @deprecated("Use `get_furcations` instead")
+    def get_bifurcations(self) -> list[Node]:
+        """Get all node of furcations.
+
+        Notes
+        -----
+        Deprecated due to the wrong spelling of furcation. For now, it
+        is just an alias of `get_furcations` and raise a warning. It
+        will be change to raise an error in the future.
+        """
+        return self.get_furcations()
 
-    def get_tips(self) -> List[Node]:
+    def get_tips(self) -> list[Node]:
         """Get all node of tips."""
         tip_ids = np.setdiff1d(self.id(), self.pid(), assume_unique=True)
         return [self.node(i) for i in tip_ids]
 
-    def get_segments(self) -> Segments[Segment]:
-        return Segments(self.Segment(self, n.pid, n.id) for n in self[1:])
+    def get_compartments(self) -> Compartments[Compartment]:
+        return Compartments(self.Compartment(self, n.pid, n.id) for n in self[1:])
 
-    def get_branches(self) -> List[Branch]:
-        Info = Tuple[List[Tree.Branch], List[int]]
+    def get_segments(self) -> Compartments[Compartment]:  # Alias
+        return self.get_compartments()
 
-        def collect_branches(node: "Tree.Node", pre: List[Info]) -> Info:
+    def get_branches(self) -> list[Branch]:
+        def collect_branches(
+            node: "Tree.Node", pre: list[tuple[list[Tree.Branch], list[int]]]
+        ) -> tuple[list[Tree.Branch], list[int]]:
             if len(pre) == 1:
                 branches, child = pre[0]
                 child.append(node.id)
                 return branches, child
 
-            branches: List[Tree.Branch] = []
+            branches: list[Tree.Branch] = []
 
             for sub_branches, child in pre:
                 child.append(node.id)
@@ -248,18 +260,19 @@ class Tree(DictSWC):
         branches, _ = self.traverse(leave=collect_branches)
         return branches
 
-    def get_paths(self) -> List[Path]:
+    def get_paths(self) -> list[Path]:
         """Get all path from soma to tips."""
-        path_dic: Dict[int, List[int]] = {}
-        Paths = List[List[int]]
+        path_dic: dict[int, list[int]] = {}
 
-        def assign_path(n: Tree.Node, pre_path: List[int] | None) -> List[int]:
+        def assign_path(n: Tree.Node, pre_path: list[int] | None) -> list[int]:
             path = [] if pre_path is None else pre_path.copy()
             path.append(n.id)
             path_dic[n.id] = path
             return path
 
-        def collect_path(n: Tree.Node, children: List[Paths]) -> Paths:
+        def collect_path(
+            n: Tree.Node, children: list[list[list[int]]]
+        ) -> list[list[int]]:
             if len(children) == 0:
                 return [path_dic[n.id]]
 
@@ -286,7 +299,7 @@ class Tree(DictSWC):
     @overload
     def traverse(self, *,
                  enter: Optional[Callable[[Node, T | None], T]] = ...,
-                 leave: Callable[[Node, List[K]], K],
+                 leave: Callable[[Node, list[K]], K],
                  root: int | np.integer = ..., mode: Literal["dfs"] = ...) -> K: ...
     # fmt: on
 
@@ -296,7 +309,7 @@ class Tree(DictSWC):
         Parameters
         ----------
         enter : (n: Node, parent: T | None) => T, optional
-        leave : (n: Node, children: List[T]) => T, optional
+        leave : (n: Node, children: list[T]) => T, optional
 
         See Also
         --------
@@ -358,7 +371,7 @@ class Tree(DictSWC):
 
     @classmethod
     def from_eswc(
-        cls, swc_file: str, extra_cols: Optional[List[str]] = None, **kwargs
+        cls, swc_file: str, extra_cols: Optional[list[str]] = None, **kwargs
     ) -> "Tree":
         """Read neuron tree from eswc file.