astToolkit 0.3.5__tar.gz → 0.3.7__tar.gz

{asttoolkit-0.3.5 → asttoolkit-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astToolkit
-Version: 0.3.5
+Version: 0.3.7
 Summary: A powerfully composable, type-safe toolkit for Python abstract syntax tree (AST) manipulation, analysis, transformation, and code generation with a layered architecture designed for building sophisticated code processing assembly-lines.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -8,7 +8,7 @@ Project-URL: Donate, https://www.patreon.com/integrated
 Project-URL: Homepage, https://github.com/hunterhogan/astToolkit
 Project-URL: Issues, https://github.com/hunterhogan/astToolkit/issues
 Project-URL: Repository, https://github.com/hunterhogan/astToolkit.git
-Keywords: ast,abstract syntax tree,code generation,code transformation,ast-analysis,ast-manipulation,ast-traversal,ast-visitor,code-analysis,code-refactoring,static-analysis,python-ast,metaprogramming,visitor-pattern,typed-ast,type-safe,composable-apis,function-inlining,source-code-generation,ast-predicate
+Keywords: abstract syntax tree,ast,ast-analysis,ast-manipulation,ast-predicate,ast-traversal,ast-visitor,code generation,code transformation,code-analysis,code-refactoring,composable-apis,function-inlining,metaprogramming,python-ast,source-code-generation,static-analysis,type-safe,typed-ast,visitor-pattern
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -19,17 +19,17 @@ Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Classifier: Typing :: Typed
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: Software Development :: Code Generators
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: Z0Z_tools
 Requires-Dist: autoflake
 Requires-Dist: python_minifier
 Requires-Dist: tomli
-Requires-Dist: Z0Z_tools
 Provides-Extra: testing
 Requires-Dist: mypy; extra == "testing"
 Requires-Dist: pytest; extra == "testing"

{asttoolkit-0.3.5 → asttoolkit-0.3.7}/astToolkit/__init__.py

@@ -25,10 +25,11 @@ maintaining type safety and providing a declarative approach to code transformat
 from astToolkit._astTypes import *  # noqa: F403
 
 from astToolkit._types import (
-	str_nameDOTname as str_nameDOTname,
+	identifierDotAttribute as identifierDotAttribute,
 )
 
-from astToolkit._dumpFunctionDef import dump as dump
+# from astToolkit._dumpFunctionDef import dump as dump
+from astToolkit._dumpHandmade import dump as dump
 
 from astToolkit._toolkitNodeVisitor import (
 	NodeChanger as NodeChanger,

{asttoolkit-0.3.5 → asttoolkit-0.3.7}/astToolkit/_astTypes.py

@@ -1,14 +1,12 @@
 """This file is generated automatically, so changes to this file will be lost."""
-from types import EllipsisType, NotImplementedType
-from typing import Any, TypeAlias as typing_TypeAlias, TypedDict, TypeVar as typing_TypeVar
+from types import EllipsisType
+from typing import Any, TypeAlias as typing_TypeAlias, TypeVar as typing_TypeVar, TypedDict
 import ast
 import sys
-
 intORstr: typing_TypeAlias = Any
 intORstrORtype_params: typing_TypeAlias = Any
 intORtype_params: typing_TypeAlias = Any
-_Scalar: typing_TypeAlias = bool | bytes | complex | EllipsisType | float | int | None | NotImplementedType | range | str
-ScalarOrContainerOfScalar: typing_TypeAlias = _Scalar | frozenset['ScalarOrContainerOfScalar'] | tuple['ScalarOrContainerOfScalar', ...]
+ConstantValueType: typing_TypeAlias = bool | bytes | complex | EllipsisType | float | int | None | range | str
 木 = typing_TypeVar('木', bound=ast.AST, covariant=True)
 个 = typing_TypeVar('个', covariant=True)
 个return = typing_TypeVar('个return', covariant=True)
@@ -130,10 +128,10 @@ hasDOTtype_comment: typing_TypeAlias = ast.arg | ast.Assign | ast.AsyncFor | ast
 hasDOTtype_ignores: typing_TypeAlias = ast.Module
 hasDOTtype_params: typing_TypeAlias = ast.AsyncFunctionDef | ast.ClassDef | ast.FunctionDef | ast.TypeAlias
 hasDOTupper: typing_TypeAlias = ast.Slice
-hasDOTvalue_ScalarOrContainerOfScalar: typing_TypeAlias = ast.Constant
+hasDOTvalue_ConstantValueType: typing_TypeAlias = ast.Constant
 hasDOTvalue_boolOrNone: typing_TypeAlias = ast.MatchSingleton
 hasDOTvalue_expr: typing_TypeAlias = ast.Assign | ast.Attribute | ast.AugAssign | ast.Await | ast.DictComp | ast.Expr | ast.FormattedValue | ast.keyword | ast.MatchValue | ast.NamedExpr | ast.Starred | ast.Subscript | ast.TypeAlias | ast.YieldFrom
 hasDOTvalue_exprOrNone: typing_TypeAlias = ast.AnnAssign | ast.Return | ast.Yield
-hasDOTvalue: typing_TypeAlias = hasDOTvalue_ScalarOrContainerOfScalar | hasDOTvalue_boolOrNone | hasDOTvalue_expr | hasDOTvalue_exprOrNone
+hasDOTvalue: typing_TypeAlias = hasDOTvalue_ConstantValueType | hasDOTvalue_boolOrNone | hasDOTvalue_expr | hasDOTvalue_exprOrNone
 hasDOTvalues: typing_TypeAlias = ast.BoolOp | ast.Dict | ast.JoinedStr
 hasDOTvararg: typing_TypeAlias = ast.arguments

asttoolkit-0.3.7/astToolkit/_dumpHandmade.py

@@ -0,0 +1,91 @@
+from ast import AST, Constant, MatchSingleton
+
+def dump(
+    node, annotate_fields=True, include_attributes=False,
+    *,
+    indent=None, show_empty=False,
+):
+    """
+    Return a formatted dump of the tree in node.  This is mainly useful for
+    debugging purposes.  If annotate_fields is true (by default),
+    the returned string will show the names and the values for fields.
+    If annotate_fields is false, the result string will be more compact by
+    omitting unambiguous field names.  Attributes such as line
+    numbers and column offsets are not dumped by default.  If this is wanted,
+    include_attributes can be set to true.  If indent is a non-negative
+    integer or string, then the tree will be pretty-printed with that indent
+    level. None (the default) selects the single line representation.
+    If show_empty is False, then empty lists and fields that are None
+    will be omitted from the output for better readability.
+    """
+    def _format(node, level=0):
+        if indent_str is not None:
+            level += 1
+            prefix = '\n' + indent_str * level
+            sep = ',\n' + indent_str * level
+        else:
+            prefix = ''
+            sep = ', '
+        if isinstance(node, AST):
+            cls = type(node)
+            args = []
+            args_buffer = []
+            allsimple = True
+            keywords = annotate_fields
+            for name in node._fields:
+                try:
+                    value = getattr(node, name)
+                except AttributeError:
+                    keywords = True
+                    continue
+                if value is None and getattr(cls, name, ...) is None:
+                    if show_empty:
+                        args.append('%s=%s' % (name, value))
+                    keywords = True
+                    continue
+                elif (
+                    not show_empty
+                    and (value is None or value == [])
+                    # Special cases:
+                    # `Constant(value=None)` and `MatchSingleton(value=None)`
+                    and not isinstance(node, (Constant, MatchSingleton))
+                ):
+                    args_buffer.append(repr(value))
+                    continue
+                elif not keywords:
+                    args.extend(args_buffer)
+                    args_buffer = []
+                value_formatted, simple = _format(value, level)
+                allsimple = allsimple and simple
+                if keywords:
+                    args.append('%s=%s' % (name, value_formatted))
+                else:
+                    args.append(value_formatted)
+            if include_attributes and node._attributes:
+                for name_attributes in node._attributes:
+                    try:
+                        value_attributes = getattr(node, name_attributes)
+                    except AttributeError:
+                        continue
+                    if value_attributes is None and getattr(cls, name_attributes, ...) is None:
+                        continue
+                    value_attributes_formatted, simple = _format(value_attributes, level)
+                    allsimple = allsimple and simple
+                    args.append('%s=%s' % (name_attributes, value_attributes_formatted))
+            if allsimple and len(args) <= 3:
+                return ('%s(%s)' % (f"{node.__class__.__module__}.{node.__class__.__name__}", ', '.join(args)), not args)
+            return ('%s(%s%s)' % (f"{node.__class__.__module__}.{node.__class__.__name__}", prefix, sep.join(args)), False)
+        elif isinstance(node, list):
+            if not node:
+                return ('[]', True)
+            return '[%s%s]' % (prefix, sep.join(_format(x, level)[0] for x in node)), False
+        return (repr(node), True)
+
+    if not isinstance(node, AST):
+        raise TypeError('expected AST, got %r' % node.__class__.__name__)
+    if indent is not None and not isinstance(indent, str):
+        indent_str = ' ' * indent
+    else:
+        indent_str = indent
+    return _format(node)[0]
+

asttoolkit-0.3.7/astToolkit/_dumpHandmade.pyi

@@ -0,0 +1,43 @@
+from ast import AST
+from types import EllipsisType, NotImplementedType
+from typing import TypeAlias
+
+_Constant: TypeAlias = bool | bytes | complex | EllipsisType | float | int | None | NotImplementedType | range | str
+
+ConstantType: TypeAlias = _Constant | frozenset['ConstantType'] | tuple['ConstantType', ...]
+
+def dump(
+    node: AST,
+    annotate_fields: bool = ...,
+    include_attributes: bool = ...,
+    *,
+    indent: int | str | None = ...,
+    show_empty: bool = ...,
+) -> str:
+    def _format(node: ConstantType | AST | list[AST] | list[str], level: int = ...) -> tuple[str, bool]:
+        # Local variables in _format function
+        prefix: str
+        sep: str
+        cls: type[AST]
+        args: list[str]
+        args_buffer: list[str]
+        allsimple: bool
+        keywords: bool
+        
+        name: str
+        value: AST | list[AST] | list[str] | ConstantType | bool | bytes | complex | float | int | str
+        value_formatted: str
+        simple: bool
+
+        name_attributes: str
+        value_attributes: int | None
+        value_attributes_formatted: str
+
+        x: AST | str
+        
+        ...
+    
+    # Local variables in dump function
+    indent_str: str | None
+    
+    ...

{asttoolkit-0.3.5 → asttoolkit-0.3.7}/astToolkit/_joinClassmethod.py

@@ -1,9 +1,20 @@
 """This file is generated automatically, so changes to this file will be lost."""
 from astToolkit import ast_attributes, Make
-from collections.abc import Iterable
+from collections.abc import Iterable, Sequence
 from typing import Unpack
 import ast
 
+def boolopJoinMethod(ast_operator: type[ast.boolop], expressions: Sequence[ast.expr], **keywordArguments: Unpack[ast_attributes]) -> ast.expr | ast.BoolOp:
+    listExpressions: list[ast.expr] = list(expressions)
+    match len(listExpressions):
+        case 0:
+            expressionsJoined = Make.Constant('', **keywordArguments)
+        case 1:
+            expressionsJoined = listExpressions[0]
+        case _:
+            expressionsJoined = Make.BoolOp(ast_operator(), listExpressions, **keywordArguments)
+    return expressionsJoined
+
 def operatorJoinMethod(ast_operator: type[ast.operator], expressions: Iterable[ast.expr], **keywordArguments: Unpack[ast_attributes]) -> ast.expr:
     listExpressions: list[ast.expr] = list(expressions)
     if not listExpressions:
@@ -13,6 +24,86 @@ def operatorJoinMethod(ast_operator: type[ast.operator], expressions: Iterable[a
         expressionsJoined = ast.BinOp(left=expressionsJoined, op=ast_operator(), right=expression, **keywordArguments)
     return expressionsJoined
 
+class And(ast.And):
+    """Identical to the `ast` class but with a method, `join()`, that "joins" expressions using the `ast.BoolOp` class."""
+
+    @classmethod
+    def join(cls, expressions: Sequence[ast.expr], **keywordArguments: Unpack[ast_attributes]) -> ast.expr:
+        """
+        Create a single `ast.expr` from a sequence of `ast.expr` by forming an `ast.BoolOp`
+        that logically "joins" expressions using the `ast.BoolOp` subclass. Like str.join() but for AST expressions.
+
+        Parameters
+        ----------
+        expressions : Sequence[ast.expr]
+            Collection of expressions to join.
+        **keywordArguments : ast._attributes
+
+        Returns
+        -------
+        joinedExpression : ast.expr
+            Single expression representing the joined expressions.
+
+        Examples
+        --------
+        Instead of manually constructing ast.BoolOp structures:
+        ```
+        ast.BoolOp(
+            op=ast.And(),
+            values=[ast.Name('Lions'), ast.Name('tigers'), ast.Name('bears')]
+        )
+        ```
+
+        Simply use:
+        ```
+        astToolkit.And.join([ast.Name('Lions'), ast.Name('tigers'), ast.Name('bears')])
+        ```
+
+        Both produce the same AST structure but the join() method eliminates the manual construction.
+        Handles single expressions and empty sequences gracefully.
+        """
+        return boolopJoinMethod(cls, expressions, **keywordArguments)
+
+class Or(ast.Or):
+    """Identical to the `ast` class but with a method, `join()`, that "joins" expressions using the `ast.BoolOp` class."""
+
+    @classmethod
+    def join(cls, expressions: Sequence[ast.expr], **keywordArguments: Unpack[ast_attributes]) -> ast.expr:
+        """
+        Create a single `ast.expr` from a sequence of `ast.expr` by forming an `ast.BoolOp`
+        that logically "joins" expressions using the `ast.BoolOp` subclass. Like str.join() but for AST expressions.
+
+        Parameters
+        ----------
+        expressions : Sequence[ast.expr]
+            Collection of expressions to join.
+        **keywordArguments : ast._attributes
+
+        Returns
+        -------
+        joinedExpression : ast.expr
+            Single expression representing the joined expressions.
+
+        Examples
+        --------
+        Instead of manually constructing ast.BoolOp structures:
+        ```
+        ast.BoolOp(
+            op=ast.And(),
+            values=[ast.Name('Lions'), ast.Name('tigers'), ast.Name('bears')]
+        )
+        ```
+
+        Simply use:
+        ```
+        astToolkit.And.join([ast.Name('Lions'), ast.Name('tigers'), ast.Name('bears')])
+        ```
+
+        Both produce the same AST structure but the join() method eliminates the manual construction.
+        Handles single expressions and empty sequences gracefully.
+        """
+        return boolopJoinMethod(cls, expressions, **keywordArguments)
+
 class Add(ast.Add):
     """Identical to the `ast` class but with a method, `join()`, that "joins" expressions using the `ast.BinOp` class."""
 

{asttoolkit-0.3.5 → asttoolkit-0.3.7}/astToolkit/_toolBe.py

@@ -52,7 +52,7 @@ class Be:
 
     @staticmethod
     def AST(node: ast.AST) -> TypeGuard[ast.AST]:
-        return isinstance(node, ast.AST) # pyright: ignore[reportUnnecessaryIsInstance]
+        return isinstance(node, ast.AST)
 
     @staticmethod
     def AsyncFor(node: ast.AST) -> TypeGuard[ast.AsyncFor]:

{asttoolkit-0.3.5 → asttoolkit-0.3.7}/astToolkit/_toolClassIsAndAttribute.py

@@ -2,9 +2,10 @@
 # ruff: noqa: F403, F405
 """This file is generated automatically, so changes to this file will be lost."""
 from astToolkit._astTypes import *
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
 from typing import overload, TypeGuard
 import ast
+import sys
 
 class ClassIsAndAttribute:
     """
@@ -67,18 +68,18 @@ class ClassIsAndAttribute:
 
     @staticmethod
     @overload
-    def argsIs(astClass: type[hasDOTargs_list_expr], attributeCondition: Callable[[list[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTargs_list_expr] | bool]:
+    def argsIs(astClass: type[hasDOTargs_list_expr], attributeCondition: Callable[[Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTargs_list_expr] | bool]:
         ...
 
     @staticmethod
-    def argsIs(astClass: type[hasDOTargs], attributeCondition: Callable[[ast.arguments], bool] | Callable[[list[ast.arg]], bool] | Callable[[list[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTargs] | bool]:
+    def argsIs(astClass: type[hasDOTargs], attributeCondition: Callable[[ast.arguments], bool] | Callable[[Sequence[ast.expr]], bool] | Callable[[list[ast.arg]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTargs] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTargs] | bool:
             return isinstance(node, astClass) and attributeCondition(node.args)
         return workhorse
 
     @staticmethod
-    def argtypesIs(astClass: type[hasDOTargtypes], attributeCondition: Callable[[list[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTargtypes] | bool]:
+    def argtypesIs(astClass: type[hasDOTargtypes], attributeCondition: Callable[[Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTargtypes] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTargtypes] | bool:
             return isinstance(node, astClass) and attributeCondition(node.argtypes)
@@ -99,7 +100,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def basesIs(astClass: type[hasDOTbases], attributeCondition: Callable[[list[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTbases] | bool]:
+    def basesIs(astClass: type[hasDOTbases], attributeCondition: Callable[[Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTbases] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTbases] | bool:
             return isinstance(node, astClass) and attributeCondition(node.bases)
@@ -112,11 +113,11 @@ class ClassIsAndAttribute:
 
     @staticmethod
     @overload
-    def bodyIs(astClass: type[hasDOTbody_list_stmt], attributeCondition: Callable[[list[ast.stmt]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTbody_list_stmt] | bool]:
+    def bodyIs(astClass: type[hasDOTbody_list_stmt], attributeCondition: Callable[[Sequence[ast.stmt]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTbody_list_stmt] | bool]:
         ...
 
     @staticmethod
-    def bodyIs(astClass: type[hasDOTbody], attributeCondition: Callable[[ast.expr], bool] | Callable[[list[ast.stmt]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTbody] | bool]:
+    def bodyIs(astClass: type[hasDOTbody], attributeCondition: Callable[[ast.expr], bool] | Callable[[Sequence[ast.stmt]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTbody] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTbody] | bool:
             return isinstance(node, astClass) and attributeCondition(node.body)
@@ -130,7 +131,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def casesIs(astClass: type[hasDOTcases], attributeCondition: Callable[[list[ast.match_case]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTcases] | bool]:
+    def casesIs(astClass: type[hasDOTcases], attributeCondition: Callable[[Sequence[ast.match_case]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTcases] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTcases] | bool:
             return isinstance(node, astClass) and attributeCondition(node.cases)
@@ -151,7 +152,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def comparatorsIs(astClass: type[hasDOTcomparators], attributeCondition: Callable[[list[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTcomparators] | bool]:
+    def comparatorsIs(astClass: type[hasDOTcomparators], attributeCondition: Callable[[Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTcomparators] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTcomparators] | bool:
             return isinstance(node, astClass) and attributeCondition(node.comparators)
@@ -179,7 +180,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def decorator_listIs(astClass: type[hasDOTdecorator_list], attributeCondition: Callable[[list[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTdecorator_list] | bool]:
+    def decorator_listIs(astClass: type[hasDOTdecorator_list], attributeCondition: Callable[[Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTdecorator_list] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTdecorator_list] | bool:
             return isinstance(node, astClass) and attributeCondition(node.decorator_list)
@@ -194,7 +195,7 @@ class ClassIsAndAttribute:
             return workhorse
 
     @staticmethod
-    def defaultsIs(astClass: type[hasDOTdefaults], attributeCondition: Callable[[list[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTdefaults] | bool]:
+    def defaultsIs(astClass: type[hasDOTdefaults], attributeCondition: Callable[[Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTdefaults] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTdefaults] | bool:
             return isinstance(node, astClass) and attributeCondition(node.defaults)
@@ -208,7 +209,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def eltsIs(astClass: type[hasDOTelts], attributeCondition: Callable[[list[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTelts] | bool]:
+    def eltsIs(astClass: type[hasDOTelts], attributeCondition: Callable[[Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTelts] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTelts] | bool:
             return isinstance(node, astClass) and attributeCondition(node.elts)
@@ -222,7 +223,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def finalbodyIs(astClass: type[hasDOTfinalbody], attributeCondition: Callable[[list[ast.stmt]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTfinalbody] | bool]:
+    def finalbodyIs(astClass: type[hasDOTfinalbody], attributeCondition: Callable[[Sequence[ast.stmt]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTfinalbody] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTfinalbody] | bool:
             return isinstance(node, astClass) and attributeCondition(node.finalbody)
@@ -243,7 +244,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def generatorsIs(astClass: type[hasDOTgenerators], attributeCondition: Callable[[list[ast.comprehension]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTgenerators] | bool]:
+    def generatorsIs(astClass: type[hasDOTgenerators], attributeCondition: Callable[[Sequence[ast.comprehension]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTgenerators] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTgenerators] | bool:
             return isinstance(node, astClass) and attributeCondition(node.generators)
@@ -271,7 +272,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def ifsIs(astClass: type[hasDOTifs], attributeCondition: Callable[[list[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTifs] | bool]:
+    def ifsIs(astClass: type[hasDOTifs], attributeCondition: Callable[[Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTifs] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTifs] | bool:
             return isinstance(node, astClass) and attributeCondition(node.ifs)
@@ -285,7 +286,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def itemsIs(astClass: type[hasDOTitems], attributeCondition: Callable[[list[ast.withitem]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTitems] | bool]:
+    def itemsIs(astClass: type[hasDOTitems], attributeCondition: Callable[[Sequence[ast.withitem]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTitems] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTitems] | bool:
             return isinstance(node, astClass) and attributeCondition(node.items)
@@ -307,23 +308,23 @@ class ClassIsAndAttribute:
 
     @staticmethod
     @overload
-    def keysIs(astClass: type[hasDOTkeys_list_expr], attributeCondition: Callable[[list[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTkeys_list_expr] | bool]:
+    def keysIs(astClass: type[hasDOTkeys_list_expr], attributeCondition: Callable[[Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTkeys_list_expr] | bool]:
         ...
 
     @staticmethod
     @overload
-    def keysIs(astClass: type[hasDOTkeys_list_exprOrNone], attributeCondition: Callable[[list[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTkeys_list_exprOrNone] | bool]:
+    def keysIs(astClass: type[hasDOTkeys_list_exprOrNone], attributeCondition: Callable[[Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTkeys_list_exprOrNone] | bool]:
         ...
 
     @staticmethod
-    def keysIs(astClass: type[hasDOTkeys], attributeCondition: Callable[[list[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTkeys] | bool]:
+    def keysIs(astClass: type[hasDOTkeys], attributeCondition: Callable[[Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTkeys] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTkeys] | bool:
             return isinstance(node, astClass) and node.keys != [None] and attributeCondition(node.keys)
         return workhorse
 
     @staticmethod
-    def keywordsIs(astClass: type[hasDOTkeywords], attributeCondition: Callable[[list[ast.keyword]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTkeywords] | bool]:
+    def keywordsIs(astClass: type[hasDOTkeywords], attributeCondition: Callable[[Sequence[ast.keyword]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTkeywords] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTkeywords] | bool:
             return isinstance(node, astClass) and attributeCondition(node.keywords)
@@ -337,7 +338,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def kw_defaultsIs(astClass: type[hasDOTkw_defaults], attributeCondition: Callable[[list[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTkw_defaults] | bool]:
+    def kw_defaultsIs(astClass: type[hasDOTkw_defaults], attributeCondition: Callable[[Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTkw_defaults] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTkw_defaults] | bool:
             return isinstance(node, astClass) and node.kw_defaults != [None] and attributeCondition(node.kw_defaults)
@@ -358,7 +359,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def kwd_patternsIs(astClass: type[hasDOTkwd_patterns], attributeCondition: Callable[[list[ast.pattern]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTkwd_patterns] | bool]:
+    def kwd_patternsIs(astClass: type[hasDOTkwd_patterns], attributeCondition: Callable[[Sequence[ast.pattern]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTkwd_patterns] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTkwd_patterns] | bool:
             return isinstance(node, astClass) and attributeCondition(node.kwd_patterns)
@@ -482,7 +483,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def opsIs(astClass: type[hasDOTops], attributeCondition: Callable[[list[ast.cmpop]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTops] | bool]:
+    def opsIs(astClass: type[hasDOTops], attributeCondition: Callable[[Sequence[ast.cmpop]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTops] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTops] | bool:
             return isinstance(node, astClass) and attributeCondition(node.ops)
@@ -502,11 +503,11 @@ class ClassIsAndAttribute:
 
     @staticmethod
     @overload
-    def orelseIs(astClass: type[hasDOTorelse_list_stmt], attributeCondition: Callable[[list[ast.stmt]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTorelse_list_stmt] | bool]:
+    def orelseIs(astClass: type[hasDOTorelse_list_stmt], attributeCondition: Callable[[Sequence[ast.stmt]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTorelse_list_stmt] | bool]:
         ...
 
     @staticmethod
-    def orelseIs(astClass: type[hasDOTorelse], attributeCondition: Callable[[ast.expr], bool] | Callable[[list[ast.stmt]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTorelse] | bool]:
+    def orelseIs(astClass: type[hasDOTorelse], attributeCondition: Callable[[ast.expr], bool] | Callable[[Sequence[ast.stmt]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTorelse] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTorelse] | bool:
             return isinstance(node, astClass) and attributeCondition(node.orelse)
@@ -530,7 +531,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def patternsIs(astClass: type[hasDOTpatterns], attributeCondition: Callable[[list[ast.pattern]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTpatterns] | bool]:
+    def patternsIs(astClass: type[hasDOTpatterns], attributeCondition: Callable[[Sequence[ast.pattern]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTpatterns] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTpatterns] | bool:
             return isinstance(node, astClass) and attributeCondition(node.patterns)
@@ -611,28 +612,28 @@ class ClassIsAndAttribute:
 
     @staticmethod
     @overload
-    def targetIs(astClass: type[hasDOTtarget_expr], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTtarget_expr] | bool]:
+    def targetIs(astClass: type[hasDOTtarget_Name], attributeCondition: Callable[[ast.Name], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTtarget_Name] | bool]:
         ...
 
     @staticmethod
     @overload
-    def targetIs(astClass: type[hasDOTtarget_Name], attributeCondition: Callable[[ast.Name], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTtarget_Name] | bool]:
+    def targetIs(astClass: type[hasDOTtarget_NameOrAttributeOrSubscript], attributeCondition: Callable[[ast.Name | ast.Attribute | ast.Subscript], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTtarget_NameOrAttributeOrSubscript] | bool]:
         ...
 
     @staticmethod
     @overload
-    def targetIs(astClass: type[hasDOTtarget_NameOrAttributeOrSubscript], attributeCondition: Callable[[ast.Name | ast.Attribute | ast.Subscript], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTtarget_NameOrAttributeOrSubscript] | bool]:
+    def targetIs(astClass: type[hasDOTtarget_expr], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTtarget_expr] | bool]:
         ...
 
     @staticmethod
-    def targetIs(astClass: type[hasDOTtarget], attributeCondition: Callable[[ast.expr], bool] | Callable[[ast.Name], bool] | Callable[[ast.Name | ast.Attribute | ast.Subscript], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTtarget] | bool]:
+    def targetIs(astClass: type[hasDOTtarget], attributeCondition: Callable[[ast.Name], bool] | Callable[[ast.expr], bool] | Callable[[ast.Name | ast.Attribute | ast.Subscript], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTtarget] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTtarget] | bool:
             return isinstance(node, astClass) and attributeCondition(node.target)
         return workhorse
 
     @staticmethod
-    def targetsIs(astClass: type[hasDOTtargets], attributeCondition: Callable[[list[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTtargets] | bool]:
+    def targetsIs(astClass: type[hasDOTtargets], attributeCondition: Callable[[Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTtargets] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTtargets] | bool:
             return isinstance(node, astClass) and attributeCondition(node.targets)
@@ -667,7 +668,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def type_paramsIs(astClass: type[hasDOTtype_params], attributeCondition: Callable[[list[ast.type_param]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTtype_params] | bool]:
+    def type_paramsIs(astClass: type[hasDOTtype_params], attributeCondition: Callable[[Sequence[ast.type_param]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTtype_params] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTtype_params] | bool:
             return isinstance(node, astClass) and attributeCondition(node.type_params)
@@ -682,7 +683,7 @@ class ClassIsAndAttribute:
 
     @staticmethod
     @overload
-    def valueIs(astClass: type[hasDOTvalue_ScalarOrContainerOfScalar], attributeCondition: Callable[[ScalarOrContainerOfScalar], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTvalue_ScalarOrContainerOfScalar] | bool]:
+    def valueIs(astClass: type[hasDOTvalue_ConstantValueType], attributeCondition: Callable[[ConstantValueType], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTvalue_ConstantValueType] | bool]:
         ...
 
     @staticmethod
@@ -701,14 +702,14 @@ class ClassIsAndAttribute:
         ...
 
     @staticmethod
-    def valueIs(astClass: type[hasDOTvalue], attributeCondition: Callable[[ScalarOrContainerOfScalar], bool] | Callable[[bool], bool] | Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTvalue] | bool]:
+    def valueIs(astClass: type[hasDOTvalue], attributeCondition: Callable[[ast.expr], bool] | Callable[[ConstantValueType], bool] | Callable[[bool], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTvalue] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTvalue] | bool:
             return isinstance(node, astClass) and node.value is not None and attributeCondition(node.value)
         return workhorse
 
     @staticmethod
-    def valuesIs(astClass: type[hasDOTvalues], attributeCondition: Callable[[list[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTvalues] | bool]:
+    def valuesIs(astClass: type[hasDOTvalues], attributeCondition: Callable[[Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTvalues] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTvalues] | bool:
             return isinstance(node, astClass) and attributeCondition(node.values)
@@ -719,4 +720,4 @@ class ClassIsAndAttribute:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTvararg] | bool:
             return isinstance(node, astClass) and node.vararg is not None and attributeCondition(node.vararg)
-        return workhorse
+        return workhorse