astToolkit 0.5.2__tar.gz → 0.5.3__tar.gz

{asttoolkit-0.5.2 → asttoolkit-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astToolkit
-Version: 0.5.2
+Version: 0.5.3
 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.5.2 → asttoolkit-0.5.3}/astToolkit/__init__.py

@@ -14,9 +14,9 @@ from astToolkit._astTypes import (
 	hasDOTcases as hasDOTcases, hasDOTcause as hasDOTcause, hasDOTcls as hasDOTcls,
 	hasDOTcomparators as hasDOTcomparators, hasDOTcontext_expr as hasDOTcontext_expr,
 	hasDOTconversion as hasDOTconversion, hasDOTctx as hasDOTctx,
-	hasDOTdecorator_list as hasDOTdecorator_list,
-	hasDOTdefaults as hasDOTdefaults, hasDOTelt as hasDOTelt, hasDOTelts as hasDOTelts,
-	hasDOTexc as hasDOTexc, hasDOTfinalbody as hasDOTfinalbody, hasDOTformat_spec as hasDOTformat_spec,
+	hasDOTdecorator_list as hasDOTdecorator_list, hasDOTdefaults as hasDOTdefaults,
+	hasDOTelt as hasDOTelt, hasDOTelts as hasDOTelts, hasDOTexc as hasDOTexc,
+	hasDOTfinalbody as hasDOTfinalbody, hasDOTformat_spec as hasDOTformat_spec,
 	hasDOTfunc as hasDOTfunc, hasDOTgenerators as hasDOTgenerators, hasDOTguard as hasDOTguard,
 	hasDOThandlers as hasDOThandlers, hasDOTid as hasDOTid, hasDOTifs as hasDOTifs,
 	hasDOTis_async as hasDOTis_async, hasDOTitems as hasDOTitems, hasDOTiter as hasDOTiter,
@@ -50,8 +50,11 @@ from astToolkit._astTypes import (
 	hasDOTvalue_ConstantValueType as hasDOTvalue_ConstantValueType,
 	hasDOTvalue_expr as hasDOTvalue_expr, hasDOTvalue_exprOrNone as hasDOTvalue_exprOrNone,
 	hasDOTvalues as hasDOTvalues, hasDOTvararg as hasDOTvararg,
-	identifierDotAttribute as identifierDotAttribute, 个 as 个, 个return as 个return, 木 as 木,
+	identifierDotAttribute as identifierDotAttribute, 一符 as 一符, 个 as 个, 个return as 个return, 二符 as 二符,
+	俪 as 俪, 口 as 口, 工 as 工, 工位 as 工位, 布尔符 as 布尔符, 常 as 常, 形 as 形, 忽 as 忽, 拦 as 拦, 木 as 木, 本 as 本,
+	比符 as 比符,
 )
+
 if sys.version_info >= (3, 13):
 	from astToolkit._astTypes import hasDOTdefault_value as hasDOTdefault_value
 

{asttoolkit-0.5.2 → asttoolkit-0.5.3}/astToolkit/_astTypes.py

@@ -7,9 +7,22 @@ import sys
 
 ConstantValueType: typing_TypeAlias = bool | bytes | complex | EllipsisType | float | int | None | range | str
 identifierDotAttribute: typing_TypeAlias = str
-木 = typing_TypeVar('木', bound=ast.AST, covariant=True)
 个 = typing_TypeVar('个', covariant=True)
 个return = typing_TypeVar('个return', covariant=True)
+木 = typing_TypeVar('木', bound=ast.AST, covariant=True)
+布尔符 = typing_TypeVar('布尔符', bound=ast.boolop, covariant=True)
+比符 = typing_TypeVar('比符', bound=ast.cmpop, covariant=True)
+常 = typing_TypeVar('常', bound=ast.Constant, covariant=True)
+拦 = typing_TypeVar('拦', bound=ast.excepthandler, covariant=True)
+工位 = typing_TypeVar('工位', bound=ast.expr_context, covariant=True)
+工 = typing_TypeVar('工', bound=ast.expr, covariant=True)
+本 = typing_TypeVar('本', bound=ast.mod, covariant=True)
+二符 = typing_TypeVar('二符', bound=ast.operator, covariant=True)
+俪 = typing_TypeVar('俪', bound=ast.pattern, covariant=True)
+口 = typing_TypeVar('口', bound=ast.stmt, covariant=True)
+忽 = typing_TypeVar('忽', bound=ast.type_ignore, covariant=True)
+形 = typing_TypeVar('形', bound=ast.type_param, covariant=True)
+一符 = typing_TypeVar('一符', bound=ast.unaryop, covariant=True)
 
 class _attributes(TypedDict, total=False):
     lineno: int

{asttoolkit-0.5.2 → asttoolkit-0.5.3}/astToolkit/_dumpHandmade.py

@@ -41,7 +41,7 @@ def dump(node: AST, annotate_fields: bool = True, include_attributes: bool = Fal
                     continue
                 if not show_empty:
                     if value == []:
-                        field_type = cls._field_types.get(name, object)
+                        field_type: ConstantValueType | AST | list[AST] | list[str] = cls._field_types.get(name, object)
                         if getattr(field_type, '__origin__', ...) is list:
                             if not keywords:
                                 args_buffer.append(repr(value))

{asttoolkit-0.5.2 → asttoolkit-0.5.3}/astToolkit/_toolBe.py

@@ -3,27 +3,26 @@ from typing_extensions import TypeIs
 import ast
 
 class Be:
-    """Type guard functions for safe AST node identification and type narrowing.
-    (AI generated docstring)
+    """A comprehensive suite of functions for AST class identification and type narrowing.
 
-    Provides static methods that perform runtime type checking for all AST node types
-    while enabling compile-time type narrowing through `TypeIs` annotations. Forms
-    the foundation of type-safe AST analysis and transformation throughout the toolkit.
+    `class` `Be` has a method for each `ast.AST` subclass, also called "node type", to perform type
+    checking while enabling compile-time type narrowing through `TypeIs` annotations. This tool
+    forms the foundation of type-safe AST analysis and transformation throughout astToolkit.
 
-    Each method takes an `ast.AST` node and returns a `TypeIs` that confirms both
-    runtime type safety and enables static type checkers to narrow the node type in
-    conditional contexts. This eliminates the need for unsafe casting while providing
-    comprehensive coverage of Python's AST node hierarchy.
+    Each method takes an `ast.AST` node and returns a `TypeIs` that confirms both runtime type
+    safety and enables static type checkers to narrow the node type in conditional contexts. This
+    eliminates the need for unsafe casting while providing comprehensive coverage of Python's AST
+    node hierarchy.
 
-    Methods correspond directly to Python AST node types, following the naming convention
-    of the AST classes themselves. Coverage includes expression nodes (`Add`, `Call`,
-    `Name`), statement nodes (`Assign`, `FunctionDef`, `Return`), operator nodes
-    (`And`, `Or`, `Not`), and structural nodes (`Module`, `arguments`, `keyword`).
+    Methods correspond directly to Python AST node types, following the naming convention of the AST
+    classes themselves. Coverage includes expression nodes (`Add`, `Call`, `Name`), statement nodes
+    (`Assign`, `FunctionDef`, `Return`), operator nodes (`And`, `Or`, `Not`), and structural nodes
+    (`Module`, `arguments`, `keyword`).
 
-    The class serves as the primary type-checking component in the antecedent-action
-    pattern, where predicates identify target nodes and actions specify operations.
-    Type guards from this class are commonly used as building blocks in `IfThis`
-    predicates and directly as `findThis` parameters in visitor classes.
+    The `class` is the primary type-checker in the antecedent-action pattern, where
+    predicates identify target nodes and actions, uh... act on nodes and their attributes. Type guards from this class are
+    commonly used as building blocks in `IfThis` predicates and directly as `findThis` parameters in
+    visitor classes.
 
     Parameters:
 
@@ -37,18 +36,24 @@ class Be:
 
         Type-safe node processing with automatic type narrowing:
 
+        ```python
             if Be.FunctionDef(node):
-                functionName = node.name  # Type-safe access to name attribute
-                parameterCount = len(node.args.args)
+                functionName = node.name  # Type-safe access to name attribute parameterCount =
+                len(node.args.args)
+        ```
 
-        Building complex predicates for visitor patterns:
+        Using type guards in visitor patterns:
 
+        ```python
             NodeTourist(Be.Return, Then.extractIt(DOT.value)).visit(functionNode)
+        ```
 
-        Combining type guards in conditional logic:
+        Type-safe access to attributes of specific node types:
 
+        ```python
             if Be.Call(node) and Be.Name(node.func):
                 callableName = node.func.id  # Type-safe access to function name
+        ```
     """
 
     @staticmethod

{asttoolkit-0.5.2 → asttoolkit-0.5.3}/astToolkit/_toolClassIsAndAttribute.py

@@ -1,31 +1,20 @@
 # pyright: reportMatchNotExhaustive=false
-# pyright: reportArgumentType=false
 """This file is generated automatically, so changes to this file will be lost."""
 from astToolkit import (
-	ConstantValueType, hasDOTannotation, hasDOTannotation_expr, hasDOTannotation_exprOrNone, hasDOTarg,
-	hasDOTarg_str, hasDOTarg_strOrNone, hasDOTargs, hasDOTargs_arguments, hasDOTargs_list_arg,
-	hasDOTargs_list_expr, hasDOTargtypes, hasDOTasname, hasDOTattr, hasDOTbases, hasDOTbody,
-	hasDOTbody_expr, hasDOTbody_list_stmt, hasDOTbound, hasDOTcases, hasDOTcause, hasDOTcls,
+	ConstantValueType, hasDOTannotation, hasDOTarg, hasDOTargs, hasDOTargtypes, hasDOTasname,
+	hasDOTattr, hasDOTbases, hasDOTbody, hasDOTbound, hasDOTcases, hasDOTcause, hasDOTcls,
 	hasDOTcomparators, hasDOTcontext_expr, hasDOTconversion, hasDOTctx, hasDOTdecorator_list,
 	hasDOTdefaults, hasDOTelt, hasDOTelts, hasDOTexc, hasDOTfinalbody, hasDOTformat_spec, hasDOTfunc,
 	hasDOTgenerators, hasDOTguard, hasDOThandlers, hasDOTid, hasDOTifs, hasDOTis_async, hasDOTitems,
-	hasDOTiter, hasDOTkey, hasDOTkeys, hasDOTkeys_list_expr, hasDOTkeys_list_exprOrNone,
-	hasDOTkeywords, hasDOTkind, hasDOTkw_defaults, hasDOTkwarg, hasDOTkwd_attrs, hasDOTkwd_patterns,
-	hasDOTkwonlyargs, hasDOTleft, hasDOTlevel, hasDOTlineno, hasDOTlower, hasDOTmodule, hasDOTmsg,
-	hasDOTname, hasDOTname_Name, hasDOTname_str, hasDOTname_strOrNone, hasDOTnames,
-	hasDOTnames_list_alias, hasDOTnames_list_str, hasDOTop, hasDOTop_boolop, hasDOTop_operator,
-	hasDOTop_unaryop, hasDOToperand, hasDOTops, hasDOToptional_vars, hasDOTorelse, hasDOTorelse_expr,
-	hasDOTorelse_list_stmt, hasDOTpattern, hasDOTpattern_pattern, hasDOTpattern_patternOrNone,
-	hasDOTpatterns, hasDOTposonlyargs, hasDOTrest, hasDOTreturns, hasDOTreturns_expr,
-	hasDOTreturns_exprOrNone, hasDOTright, hasDOTsimple, hasDOTslice, hasDOTstep, hasDOTsubject,
-	hasDOTtag, hasDOTtarget, hasDOTtarget_expr, hasDOTtarget_Name,
-	hasDOTtarget_NameOrAttributeOrSubscript, hasDOTtargets, hasDOTtest, hasDOTtype, hasDOTtype_comment,
-	hasDOTtype_ignores, hasDOTtype_params, hasDOTupper, hasDOTvalue, hasDOTvalue_boolOrNone,
-	hasDOTvalue_ConstantValueType, hasDOTvalue_expr, hasDOTvalue_exprOrNone, hasDOTvalues,
-	hasDOTvararg,
+	hasDOTiter, hasDOTkey, hasDOTkeys, hasDOTkeywords, hasDOTkind, hasDOTkw_defaults, hasDOTkwarg,
+	hasDOTkwd_attrs, hasDOTkwd_patterns, hasDOTkwonlyargs, hasDOTleft, hasDOTlevel, hasDOTlineno,
+	hasDOTlower, hasDOTmodule, hasDOTmsg, hasDOTname, hasDOTnames, hasDOTop, hasDOToperand, hasDOTops,
+	hasDOToptional_vars, hasDOTorelse, hasDOTpattern, hasDOTpatterns, hasDOTposonlyargs, hasDOTrest,
+	hasDOTreturns, hasDOTright, hasDOTsimple, hasDOTslice, hasDOTstep, hasDOTsubject, hasDOTtag,
+	hasDOTtarget, hasDOTtargets, hasDOTtest, hasDOTtype, hasDOTtype_comment, hasDOTtype_ignores,
+	hasDOTtype_params, hasDOTupper, hasDOTvalue, hasDOTvalues, hasDOTvararg,
 )
 from collections.abc import Callable, Sequence
-from typing import overload
 from typing_extensions import TypeIs
 import ast
 import sys
@@ -49,56 +38,21 @@ class ClassIsAndAttribute:
     """
 
     @staticmethod
-    @overload
-    def annotationIs(astClass: type[hasDOTannotation_expr], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOTannotation_expr] | bool]:
-        ...
-
-    @staticmethod
-    @overload
-    def annotationIs(astClass: type[hasDOTannotation_exprOrNone], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOTannotation_exprOrNone] | bool]:
-        ...
-
-    @staticmethod
-    def annotationIs(astClass: type[hasDOTannotation], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOTannotation] | bool]:
+    def annotationIs(astClass: type[hasDOTannotation], attributeCondition: Callable[[ast.expr | (ast.expr | None)], bool]) -> Callable[[ast.AST], TypeIs[hasDOTannotation] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTannotation] | bool:
             return isinstance(node, astClass) and node.annotation is not None and attributeCondition(node.annotation)
         return workhorse
 
     @staticmethod
-    @overload
-    def argIs(astClass: type[hasDOTarg_str], attributeCondition: Callable[[str], bool]) -> Callable[[ast.AST], TypeIs[hasDOTarg_str] | bool]:
-        ...
-
-    @staticmethod
-    @overload
-    def argIs(astClass: type[hasDOTarg_strOrNone], attributeCondition: Callable[[str], bool]) -> Callable[[ast.AST], TypeIs[hasDOTarg_strOrNone] | bool]:
-        ...
-
-    @staticmethod
-    def argIs(astClass: type[hasDOTarg], attributeCondition: Callable[[str], bool]) -> Callable[[ast.AST], TypeIs[hasDOTarg] | bool]:
+    def argIs(astClass: type[hasDOTarg], attributeCondition: Callable[[str | (str | None)], bool]) -> Callable[[ast.AST], TypeIs[hasDOTarg] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTarg] | bool:
             return isinstance(node, astClass) and node.arg is not None and attributeCondition(node.arg)
         return workhorse
 
     @staticmethod
-    @overload
-    def argsIs(astClass: type[hasDOTargs_arguments], attributeCondition: Callable[[ast.arguments], bool]) -> Callable[[ast.AST], TypeIs[hasDOTargs_arguments] | bool]:
-        ...
-
-    @staticmethod
-    @overload
-    def argsIs(astClass: type[hasDOTargs_list_arg], attributeCondition: Callable[[list[ast.arg]], bool]) -> Callable[[ast.AST], TypeIs[hasDOTargs_list_arg] | bool]:
-        ...
-
-    @staticmethod
-    @overload
-    def argsIs(astClass: type[hasDOTargs_list_expr], attributeCondition: Callable[[Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeIs[hasDOTargs_list_expr] | bool]:
-        ...
-
-    @staticmethod
-    def argsIs(astClass: type[hasDOTargs], attributeCondition: Callable[[ast.arguments], bool] | Callable[[list[ast.arg]], bool] | Callable[[Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeIs[hasDOTargs] | bool]:
+    def argsIs(astClass: type[hasDOTargs], attributeCondition: Callable[[ast.arguments | list[ast.arg] | Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeIs[hasDOTargs] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTargs] | bool:
             return isinstance(node, astClass) and attributeCondition(node.args)
@@ -112,7 +66,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def asnameIs(astClass: type[hasDOTasname], attributeCondition: Callable[[str], bool]) -> Callable[[ast.AST], TypeIs[hasDOTasname] | bool]:
+    def asnameIs(astClass: type[hasDOTasname], attributeCondition: Callable[[str | None], bool]) -> Callable[[ast.AST], TypeIs[hasDOTasname] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTasname] | bool:
             return isinstance(node, astClass) and node.asname is not None and attributeCondition(node.asname)
@@ -133,24 +87,14 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    @overload
-    def bodyIs(astClass: type[hasDOTbody_expr], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOTbody_expr] | bool]:
-        ...
-
-    @staticmethod
-    @overload
-    def bodyIs(astClass: type[hasDOTbody_list_stmt], attributeCondition: Callable[[Sequence[ast.stmt]], bool]) -> Callable[[ast.AST], TypeIs[hasDOTbody_list_stmt] | bool]:
-        ...
-
-    @staticmethod
-    def bodyIs(astClass: type[hasDOTbody], attributeCondition: Callable[[ast.expr], bool] | Callable[[Sequence[ast.stmt]], bool]) -> Callable[[ast.AST], TypeIs[hasDOTbody] | bool]:
+    def bodyIs(astClass: type[hasDOTbody], attributeCondition: Callable[[ast.expr | Sequence[ast.stmt]], bool]) -> Callable[[ast.AST], TypeIs[hasDOTbody] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTbody] | bool:
             return isinstance(node, astClass) and attributeCondition(node.body)
         return workhorse
 
     @staticmethod
-    def boundIs(astClass: type[hasDOTbound], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOTbound] | bool]:
+    def boundIs(astClass: type[hasDOTbound], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeIs[hasDOTbound] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTbound] | bool:
             return isinstance(node, astClass) and node.bound is not None and attributeCondition(node.bound)
@@ -164,7 +108,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def causeIs(astClass: type[hasDOTcause], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOTcause] | bool]:
+    def causeIs(astClass: type[hasDOTcause], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeIs[hasDOTcause] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTcause] | bool:
             return isinstance(node, astClass) and node.cause is not None and attributeCondition(node.cause)
@@ -215,7 +159,7 @@ class ClassIsAndAttribute:
         case version if version >= (3, 13):
 
             @staticmethod
-            def default_valueIs(astClass: type[hasDOTdefault_value], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOTdefault_value] | bool]:
+            def default_valueIs(astClass: type[hasDOTdefault_value], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeIs[hasDOTdefault_value] | bool]:
 
                 def workhorse(node: ast.AST) -> TypeIs[hasDOTdefault_value] | bool:
                     return isinstance(node, astClass) and node.default_value is not None and attributeCondition(node.default_value)
@@ -243,7 +187,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def excIs(astClass: type[hasDOTexc], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOTexc] | bool]:
+    def excIs(astClass: type[hasDOTexc], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeIs[hasDOTexc] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTexc] | bool:
             return isinstance(node, astClass) and node.exc is not None and attributeCondition(node.exc)
@@ -257,7 +201,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def format_specIs(astClass: type[hasDOTformat_spec], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOTformat_spec] | bool]:
+    def format_specIs(astClass: type[hasDOTformat_spec], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeIs[hasDOTformat_spec] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTformat_spec] | bool:
             return isinstance(node, astClass) and node.format_spec is not None and attributeCondition(node.format_spec)
@@ -278,7 +222,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def guardIs(astClass: type[hasDOTguard], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOTguard] | bool]:
+    def guardIs(astClass: type[hasDOTguard], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeIs[hasDOTguard] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTguard] | bool:
             return isinstance(node, astClass) and node.guard is not None and attributeCondition(node.guard)
@@ -334,17 +278,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    @overload
-    def keysIs(astClass: type[hasDOTkeys_list_expr], attributeCondition: Callable[[Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeIs[hasDOTkeys_list_expr] | bool]:
-        ...
-
-    @staticmethod
-    @overload
-    def keysIs(astClass: type[hasDOTkeys_list_exprOrNone], attributeCondition: Callable[[Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeIs[hasDOTkeys_list_exprOrNone] | bool]:
-        ...
-
-    @staticmethod
-    def keysIs(astClass: type[hasDOTkeys], attributeCondition: Callable[[Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeIs[hasDOTkeys] | bool]:
+    def keysIs(astClass: type[hasDOTkeys], attributeCondition: Callable[[Sequence[ast.expr | None] | Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeIs[hasDOTkeys] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTkeys] | bool:
             return isinstance(node, astClass) and node.keys != [None] and attributeCondition(node.keys)
@@ -358,21 +292,21 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def kindIs(astClass: type[hasDOTkind], attributeCondition: Callable[[str], bool]) -> Callable[[ast.AST], TypeIs[hasDOTkind] | bool]:
+    def kindIs(astClass: type[hasDOTkind], attributeCondition: Callable[[str | None], bool]) -> Callable[[ast.AST], TypeIs[hasDOTkind] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTkind] | bool:
             return isinstance(node, astClass) and node.kind is not None and attributeCondition(node.kind)
         return workhorse
 
     @staticmethod
-    def kw_defaultsIs(astClass: type[hasDOTkw_defaults], attributeCondition: Callable[[Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeIs[hasDOTkw_defaults] | bool]:
+    def kw_defaultsIs(astClass: type[hasDOTkw_defaults], attributeCondition: Callable[[Sequence[ast.expr | None]], bool]) -> Callable[[ast.AST], TypeIs[hasDOTkw_defaults] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTkw_defaults] | bool:
             return isinstance(node, astClass) and node.kw_defaults != [None] and attributeCondition(node.kw_defaults)
         return workhorse
 
     @staticmethod
-    def kwargIs(astClass: type[hasDOTkwarg], attributeCondition: Callable[[ast.arg], bool]) -> Callable[[ast.AST], TypeIs[hasDOTkwarg] | bool]:
+    def kwargIs(astClass: type[hasDOTkwarg], attributeCondition: Callable[[ast.arg | None], bool]) -> Callable[[ast.AST], TypeIs[hasDOTkwarg] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTkwarg] | bool:
             return isinstance(node, astClass) and node.kwarg is not None and attributeCondition(node.kwarg)
@@ -421,82 +355,42 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def lowerIs(astClass: type[hasDOTlower], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOTlower] | bool]:
+    def lowerIs(astClass: type[hasDOTlower], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeIs[hasDOTlower] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTlower] | bool:
             return isinstance(node, astClass) and node.lower is not None and attributeCondition(node.lower)
         return workhorse
 
     @staticmethod
-    def moduleIs(astClass: type[hasDOTmodule], attributeCondition: Callable[[str], bool]) -> Callable[[ast.AST], TypeIs[hasDOTmodule] | bool]:
+    def moduleIs(astClass: type[hasDOTmodule], attributeCondition: Callable[[str | None], bool]) -> Callable[[ast.AST], TypeIs[hasDOTmodule] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTmodule] | bool:
             return isinstance(node, astClass) and node.module is not None and attributeCondition(node.module)
         return workhorse
 
     @staticmethod
-    def msgIs(astClass: type[hasDOTmsg], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOTmsg] | bool]:
+    def msgIs(astClass: type[hasDOTmsg], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeIs[hasDOTmsg] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTmsg] | bool:
             return isinstance(node, astClass) and node.msg is not None and attributeCondition(node.msg)
         return workhorse
 
     @staticmethod
-    @overload
-    def nameIs(astClass: type[hasDOTname_Name], attributeCondition: Callable[[ast.Name], bool]) -> Callable[[ast.AST], TypeIs[hasDOTname_Name] | bool]:
-        ...
-
-    @staticmethod
-    @overload
-    def nameIs(astClass: type[hasDOTname_str], attributeCondition: Callable[[str], bool]) -> Callable[[ast.AST], TypeIs[hasDOTname_str] | bool]:
-        ...
-
-    @staticmethod
-    @overload
-    def nameIs(astClass: type[hasDOTname_strOrNone], attributeCondition: Callable[[str], bool]) -> Callable[[ast.AST], TypeIs[hasDOTname_strOrNone] | bool]:
-        ...
-
-    @staticmethod
-    def nameIs(astClass: type[hasDOTname], attributeCondition: Callable[[ast.Name], bool] | Callable[[str], bool]) -> Callable[[ast.AST], TypeIs[hasDOTname] | bool]:
+    def nameIs(astClass: type[hasDOTname], attributeCondition: Callable[[ast.Name | str | (str | None)], bool]) -> Callable[[ast.AST], TypeIs[hasDOTname] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTname] | bool:
             return isinstance(node, astClass) and node.name is not None and attributeCondition(node.name)
         return workhorse
 
     @staticmethod
-    @overload
-    def namesIs(astClass: type[hasDOTnames_list_alias], attributeCondition: Callable[[list[ast.alias]], bool]) -> Callable[[ast.AST], TypeIs[hasDOTnames_list_alias] | bool]:
-        ...
-
-    @staticmethod
-    @overload
-    def namesIs(astClass: type[hasDOTnames_list_str], attributeCondition: Callable[[list[str]], bool]) -> Callable[[ast.AST], TypeIs[hasDOTnames_list_str] | bool]:
-        ...
-
-    @staticmethod
-    def namesIs(astClass: type[hasDOTnames], attributeCondition: Callable[[list[ast.alias]], bool] | Callable[[list[str]], bool]) -> Callable[[ast.AST], TypeIs[hasDOTnames] | bool]:
+    def namesIs(astClass: type[hasDOTnames], attributeCondition: Callable[[list[ast.alias] | list[str]], bool]) -> Callable[[ast.AST], TypeIs[hasDOTnames] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTnames] | bool:
             return isinstance(node, astClass) and attributeCondition(node.names)
         return workhorse
 
     @staticmethod
-    @overload
-    def opIs(astClass: type[hasDOTop_boolop], attributeCondition: Callable[[ast.boolop], bool]) -> Callable[[ast.AST], TypeIs[hasDOTop_boolop] | bool]:
-        ...
-
-    @staticmethod
-    @overload
-    def opIs(astClass: type[hasDOTop_operator], attributeCondition: Callable[[ast.operator], bool]) -> Callable[[ast.AST], TypeIs[hasDOTop_operator] | bool]:
-        ...
-
-    @staticmethod
-    @overload
-    def opIs(astClass: type[hasDOTop_unaryop], attributeCondition: Callable[[ast.unaryop], bool]) -> Callable[[ast.AST], TypeIs[hasDOTop_unaryop] | bool]:
-        ...
-
-    @staticmethod
-    def opIs(astClass: type[hasDOTop], attributeCondition: Callable[[ast.boolop], bool] | Callable[[ast.operator], bool] | Callable[[ast.unaryop], bool]) -> Callable[[ast.AST], TypeIs[hasDOTop] | bool]:
+    def opIs(astClass: type[hasDOTop], attributeCondition: Callable[[ast.boolop | ast.operator | ast.unaryop], bool]) -> Callable[[ast.AST], TypeIs[hasDOTop] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTop] | bool:
             return isinstance(node, astClass) and attributeCondition(node.op)
@@ -517,41 +411,21 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def optional_varsIs(astClass: type[hasDOToptional_vars], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOToptional_vars] | bool]:
+    def optional_varsIs(astClass: type[hasDOToptional_vars], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeIs[hasDOToptional_vars] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOToptional_vars] | bool:
             return isinstance(node, astClass) and node.optional_vars is not None and attributeCondition(node.optional_vars)
         return workhorse
 
     @staticmethod
-    @overload
-    def orelseIs(astClass: type[hasDOTorelse_expr], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOTorelse_expr] | bool]:
-        ...
-
-    @staticmethod
-    @overload
-    def orelseIs(astClass: type[hasDOTorelse_list_stmt], attributeCondition: Callable[[Sequence[ast.stmt]], bool]) -> Callable[[ast.AST], TypeIs[hasDOTorelse_list_stmt] | bool]:
-        ...
-
-    @staticmethod
-    def orelseIs(astClass: type[hasDOTorelse], attributeCondition: Callable[[ast.expr], bool] | Callable[[Sequence[ast.stmt]], bool]) -> Callable[[ast.AST], TypeIs[hasDOTorelse] | bool]:
+    def orelseIs(astClass: type[hasDOTorelse], attributeCondition: Callable[[ast.expr | Sequence[ast.stmt]], bool]) -> Callable[[ast.AST], TypeIs[hasDOTorelse] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTorelse] | bool:
             return isinstance(node, astClass) and attributeCondition(node.orelse)
         return workhorse
 
     @staticmethod
-    @overload
-    def patternIs(astClass: type[hasDOTpattern_pattern], attributeCondition: Callable[[ast.pattern], bool]) -> Callable[[ast.AST], TypeIs[hasDOTpattern_pattern] | bool]:
-        ...
-
-    @staticmethod
-    @overload
-    def patternIs(astClass: type[hasDOTpattern_patternOrNone], attributeCondition: Callable[[ast.pattern], bool]) -> Callable[[ast.AST], TypeIs[hasDOTpattern_patternOrNone] | bool]:
-        ...
-
-    @staticmethod
-    def patternIs(astClass: type[hasDOTpattern], attributeCondition: Callable[[ast.pattern], bool]) -> Callable[[ast.AST], TypeIs[hasDOTpattern] | bool]:
+    def patternIs(astClass: type[hasDOTpattern], attributeCondition: Callable[[ast.pattern | (ast.pattern | None)], bool]) -> Callable[[ast.AST], TypeIs[hasDOTpattern] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTpattern] | bool:
             return isinstance(node, astClass) and node.pattern is not None and attributeCondition(node.pattern)
@@ -572,24 +446,14 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def restIs(astClass: type[hasDOTrest], attributeCondition: Callable[[str], bool]) -> Callable[[ast.AST], TypeIs[hasDOTrest] | bool]:
+    def restIs(astClass: type[hasDOTrest], attributeCondition: Callable[[str | None], bool]) -> Callable[[ast.AST], TypeIs[hasDOTrest] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTrest] | bool:
             return isinstance(node, astClass) and node.rest is not None and attributeCondition(node.rest)
         return workhorse
 
     @staticmethod
-    @overload
-    def returnsIs(astClass: type[hasDOTreturns_expr], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOTreturns_expr] | bool]:
-        ...
-
-    @staticmethod
-    @overload
-    def returnsIs(astClass: type[hasDOTreturns_exprOrNone], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOTreturns_exprOrNone] | bool]:
-        ...
-
-    @staticmethod
-    def returnsIs(astClass: type[hasDOTreturns], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOTreturns] | bool]:
+    def returnsIs(astClass: type[hasDOTreturns], attributeCondition: Callable[[ast.expr | (ast.expr | None)], bool]) -> Callable[[ast.AST], TypeIs[hasDOTreturns] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTreturns] | bool:
             return isinstance(node, astClass) and node.returns is not None and attributeCondition(node.returns)
@@ -617,7 +481,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def stepIs(astClass: type[hasDOTstep], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOTstep] | bool]:
+    def stepIs(astClass: type[hasDOTstep], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeIs[hasDOTstep] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTstep] | bool:
             return isinstance(node, astClass) and node.step is not None and attributeCondition(node.step)
@@ -638,22 +502,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    @overload
-    def targetIs(astClass: type[hasDOTtarget_expr], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOTtarget_expr] | bool]:
-        ...
-
-    @staticmethod
-    @overload
-    def targetIs(astClass: type[hasDOTtarget_Name], attributeCondition: Callable[[ast.Name], bool]) -> Callable[[ast.AST], TypeIs[hasDOTtarget_Name] | bool]:
-        ...
-
-    @staticmethod
-    @overload
-    def targetIs(astClass: type[hasDOTtarget_NameOrAttributeOrSubscript], attributeCondition: Callable[[ast.Name | ast.Attribute | ast.Subscript], bool]) -> Callable[[ast.AST], TypeIs[hasDOTtarget_NameOrAttributeOrSubscript] | 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], TypeIs[hasDOTtarget] | bool]:
+    def targetIs(astClass: type[hasDOTtarget], attributeCondition: Callable[[ast.expr | ast.Name | (ast.Name | ast.Attribute | ast.Subscript)], bool]) -> Callable[[ast.AST], TypeIs[hasDOTtarget] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTtarget] | bool:
             return isinstance(node, astClass) and attributeCondition(node.target)
@@ -674,14 +523,14 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def typeIs(astClass: type[hasDOTtype], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOTtype] | bool]:
+    def typeIs(astClass: type[hasDOTtype], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeIs[hasDOTtype] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTtype] | bool:
             return isinstance(node, astClass) and node.type is not None and attributeCondition(node.type)
         return workhorse
 
     @staticmethod
-    def type_commentIs(astClass: type[hasDOTtype_comment], attributeCondition: Callable[[str], bool]) -> Callable[[ast.AST], TypeIs[hasDOTtype_comment] | bool]:
+    def type_commentIs(astClass: type[hasDOTtype_comment], attributeCondition: Callable[[str | None], bool]) -> Callable[[ast.AST], TypeIs[hasDOTtype_comment] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTtype_comment] | bool:
             return isinstance(node, astClass) and node.type_comment is not None and attributeCondition(node.type_comment)
@@ -702,34 +551,14 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def upperIs(astClass: type[hasDOTupper], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOTupper] | bool]:
+    def upperIs(astClass: type[hasDOTupper], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeIs[hasDOTupper] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTupper] | bool:
             return isinstance(node, astClass) and node.upper is not None and attributeCondition(node.upper)
         return workhorse
 
     @staticmethod
-    @overload
-    def valueIs(astClass: type[hasDOTvalue_boolOrNone], attributeCondition: Callable[[bool], bool]) -> Callable[[ast.AST], TypeIs[hasDOTvalue_boolOrNone] | bool]:
-        ...
-
-    @staticmethod
-    @overload
-    def valueIs(astClass: type[hasDOTvalue_ConstantValueType], attributeCondition: Callable[[ConstantValueType], bool]) -> Callable[[ast.AST], TypeIs[hasDOTvalue_ConstantValueType] | bool]:
-        ...
-
-    @staticmethod
-    @overload
-    def valueIs(astClass: type[hasDOTvalue_expr], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOTvalue_expr] | bool]:
-        ...
-
-    @staticmethod
-    @overload
-    def valueIs(astClass: type[hasDOTvalue_exprOrNone], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeIs[hasDOTvalue_exprOrNone] | bool]:
-        ...
-
-    @staticmethod
-    def valueIs(astClass: type[hasDOTvalue], attributeCondition: Callable[[ast.expr], bool] | Callable[[bool], bool] | Callable[[ConstantValueType], bool]) -> Callable[[ast.AST], TypeIs[hasDOTvalue] | bool]:
+    def valueIs(astClass: type[hasDOTvalue], attributeCondition: Callable[[ast.expr | (ast.expr | None) | (bool | None) | ConstantValueType], bool]) -> Callable[[ast.AST], TypeIs[hasDOTvalue] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTvalue] | bool:
             return isinstance(node, astClass) and node.value is not None and attributeCondition(node.value)
@@ -743,7 +572,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def varargIs(astClass: type[hasDOTvararg], attributeCondition: Callable[[ast.arg], bool]) -> Callable[[ast.AST], TypeIs[hasDOTvararg] | bool]:
+    def varargIs(astClass: type[hasDOTvararg], attributeCondition: Callable[[ast.arg | None], bool]) -> Callable[[ast.AST], TypeIs[hasDOTvararg] | bool]:
 
         def workhorse(node: ast.AST) -> TypeIs[hasDOTvararg] | bool:
             return isinstance(node, astClass) and node.vararg is not None and attributeCondition(node.vararg)