astToolkit 0.3.6__tar.gz → 0.3.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astToolkit
-Version: 0.3.6
+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

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

@@ -25,7 +25,7 @@ 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

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

@@ -1,13 +1,12 @@
 """This file is generated automatically, so changes to this file will be lost."""
-from types import EllipsisType, NotImplementedType
+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)
@@ -129,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.6 → 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.6 → 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.6 → 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