astToolkit 0.3.1__tar.gz → 0.3.2__tar.gz

{asttoolkit-0.3.1 → asttoolkit-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astToolkit
-Version: 0.3.1
+Version: 0.3.2
 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.1 → asttoolkit-0.3.2}/astToolkit/_toolClassIsAndAttribute.py

@@ -28,11 +28,11 @@ class ClassIsAndAttribute:
 
     @staticmethod
     @overload
-    def annotationIs(astClass: type[hasDOTannotation_exprOrNone], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTannotation_exprOrNone] | bool]:
+    def annotationIs(astClass: type[hasDOTannotation_exprOrNone], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTannotation_exprOrNone] | bool]:
         ...
 
     @staticmethod
-    def annotationIs(astClass: type[hasDOTannotation], attributeCondition: Callable[[ast.expr], bool] | Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTannotation] | bool]:
+    def annotationIs(astClass: type[hasDOTannotation], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTannotation] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTannotation] | bool:
             return isinstance(node, astClass) and node.annotation is not None and attributeCondition(node.annotation)
@@ -45,11 +45,11 @@ class ClassIsAndAttribute:
 
     @staticmethod
     @overload
-    def argIs(astClass: type[hasDOTarg_strOrNone], attributeCondition: Callable[[str | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTarg_strOrNone] | bool]:
+    def argIs(astClass: type[hasDOTarg_strOrNone], attributeCondition: Callable[[str], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTarg_strOrNone] | bool]:
         ...
 
     @staticmethod
-    def argIs(astClass: type[hasDOTarg], attributeCondition: Callable[[str], bool] | Callable[[str | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTarg] | bool]:
+    def argIs(astClass: type[hasDOTarg], attributeCondition: Callable[[str], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTarg] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTarg] | bool:
             return isinstance(node, astClass) and node.arg is not None and attributeCondition(node.arg)
@@ -85,7 +85,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def asnameIs(astClass: type[hasDOTasname], attributeCondition: Callable[[str | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTasname] | bool]:
+    def asnameIs(astClass: type[hasDOTasname], attributeCondition: Callable[[str], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTasname] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTasname] | bool:
             return isinstance(node, astClass) and node.asname is not None and attributeCondition(node.asname)
@@ -123,7 +123,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def boundIs(astClass: type[hasDOTbound], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTbound] | bool]:
+    def boundIs(astClass: type[hasDOTbound], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTbound] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTbound] | bool:
             return isinstance(node, astClass) and node.bound is not None and attributeCondition(node.bound)
@@ -137,7 +137,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def causeIs(astClass: type[hasDOTcause], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTcause] | bool]:
+    def causeIs(astClass: type[hasDOTcause], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTcause] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTcause] | bool:
             return isinstance(node, astClass) and node.cause is not None and attributeCondition(node.cause)
@@ -187,7 +187,7 @@ class ClassIsAndAttribute:
     if sys.version_info >= (3, 13):
 
         @staticmethod
-        def default_valueIs(astClass: type[hasDOTdefault_value], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTdefault_value] | bool]:
+        def default_valueIs(astClass: type[hasDOTdefault_value], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTdefault_value] | bool]:
 
             def workhorse(node: ast.AST) -> TypeGuard[hasDOTdefault_value] | bool:
                 return isinstance(node, astClass) and node.default_value is not None and attributeCondition(node.default_value)
@@ -215,7 +215,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def excIs(astClass: type[hasDOTexc], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTexc] | bool]:
+    def excIs(astClass: type[hasDOTexc], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTexc] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTexc] | bool:
             return isinstance(node, astClass) and node.exc is not None and attributeCondition(node.exc)
@@ -229,7 +229,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def format_specIs(astClass: type[hasDOTformat_spec], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTformat_spec] | bool]:
+    def format_specIs(astClass: type[hasDOTformat_spec], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTformat_spec] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTformat_spec] | bool:
             return isinstance(node, astClass) and node.format_spec is not None and attributeCondition(node.format_spec)
@@ -250,7 +250,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def guardIs(astClass: type[hasDOTguard], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTguard] | bool]:
+    def guardIs(astClass: type[hasDOTguard], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTguard] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTguard] | bool:
             return isinstance(node, astClass) and node.guard is not None and attributeCondition(node.guard)
@@ -312,11 +312,11 @@ class ClassIsAndAttribute:
 
     @staticmethod
     @overload
-    def keysIs(astClass: type[hasDOTkeys_list_exprOrNone], attributeCondition: Callable[[list[ast.expr | None]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTkeys_list_exprOrNone] | bool]:
+    def keysIs(astClass: type[hasDOTkeys_list_exprOrNone], attributeCondition: Callable[[list[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTkeys_list_exprOrNone] | bool]:
         ...
 
     @staticmethod
-    def keysIs(astClass: type[hasDOTkeys], attributeCondition: Callable[[list[ast.expr]], bool] | Callable[[list[ast.expr | None]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTkeys] | bool]:
+    def keysIs(astClass: type[hasDOTkeys], attributeCondition: Callable[[list[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)
@@ -330,21 +330,21 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def kindIs(astClass: type[hasDOTkind], attributeCondition: Callable[[str | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTkind] | bool]:
+    def kindIs(astClass: type[hasDOTkind], attributeCondition: Callable[[str], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTkind] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[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[[list[ast.expr | None]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTkw_defaults] | bool]:
+    def kw_defaultsIs(astClass: type[hasDOTkw_defaults], attributeCondition: Callable[[list[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)
         return workhorse
 
     @staticmethod
-    def kwargIs(astClass: type[hasDOTkwarg], attributeCondition: Callable[[ast.arg | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTkwarg] | bool]:
+    def kwargIs(astClass: type[hasDOTkwarg], attributeCondition: Callable[[ast.arg], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTkwarg] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTkwarg] | bool:
             return isinstance(node, astClass) and node.kwarg is not None and attributeCondition(node.kwarg)
@@ -393,21 +393,21 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def lowerIs(astClass: type[hasDOTlower], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTlower] | bool]:
+    def lowerIs(astClass: type[hasDOTlower], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTlower] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[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 | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTmodule] | bool]:
+    def moduleIs(astClass: type[hasDOTmodule], attributeCondition: Callable[[str], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTmodule] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[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 | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTmsg] | bool]:
+    def msgIs(astClass: type[hasDOTmsg], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTmsg] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTmsg] | bool:
             return isinstance(node, astClass) and node.msg is not None and attributeCondition(node.msg)
@@ -425,11 +425,11 @@ class ClassIsAndAttribute:
 
     @staticmethod
     @overload
-    def nameIs(astClass: type[hasDOTname_strOrNone], attributeCondition: Callable[[str | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTname_strOrNone] | bool]:
+    def nameIs(astClass: type[hasDOTname_strOrNone], attributeCondition: Callable[[str], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTname_strOrNone] | bool]:
         ...
 
     @staticmethod
-    def nameIs(astClass: type[hasDOTname], attributeCondition: Callable[[ast.Name], bool] | Callable[[str], bool] | Callable[[str | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTname] | bool]:
+    def nameIs(astClass: type[hasDOTname], attributeCondition: Callable[[ast.Name], bool] | Callable[[str], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTname] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTname] | bool:
             return isinstance(node, astClass) and node.name is not None and attributeCondition(node.name)
@@ -489,7 +489,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def optional_varsIs(astClass: type[hasDOToptional_vars], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOToptional_vars] | bool]:
+    def optional_varsIs(astClass: type[hasDOToptional_vars], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeGuard[hasDOToptional_vars] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOToptional_vars] | bool:
             return isinstance(node, astClass) and node.optional_vars is not None and attributeCondition(node.optional_vars)
@@ -519,11 +519,11 @@ class ClassIsAndAttribute:
 
     @staticmethod
     @overload
-    def patternIs(astClass: type[hasDOTpattern_patternOrNone], attributeCondition: Callable[[ast.pattern | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTpattern_patternOrNone] | bool]:
+    def patternIs(astClass: type[hasDOTpattern_patternOrNone], attributeCondition: Callable[[ast.pattern], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTpattern_patternOrNone] | bool]:
         ...
 
     @staticmethod
-    def patternIs(astClass: type[hasDOTpattern], attributeCondition: Callable[[ast.pattern], bool] | Callable[[ast.pattern | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTpattern] | bool]:
+    def patternIs(astClass: type[hasDOTpattern], attributeCondition: Callable[[ast.pattern], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTpattern] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTpattern] | bool:
             return isinstance(node, astClass) and node.pattern is not None and attributeCondition(node.pattern)
@@ -544,7 +544,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def restIs(astClass: type[hasDOTrest], attributeCondition: Callable[[str | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTrest] | bool]:
+    def restIs(astClass: type[hasDOTrest], attributeCondition: Callable[[str], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTrest] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTrest] | bool:
             return isinstance(node, astClass) and node.rest is not None and attributeCondition(node.rest)
@@ -557,11 +557,11 @@ class ClassIsAndAttribute:
 
     @staticmethod
     @overload
-    def returnsIs(astClass: type[hasDOTreturns_exprOrNone], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTreturns_exprOrNone] | bool]:
+    def returnsIs(astClass: type[hasDOTreturns_exprOrNone], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTreturns_exprOrNone] | bool]:
         ...
 
     @staticmethod
-    def returnsIs(astClass: type[hasDOTreturns], attributeCondition: Callable[[ast.expr], bool] | Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTreturns] | bool]:
+    def returnsIs(astClass: type[hasDOTreturns], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTreturns] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTreturns] | bool:
             return isinstance(node, astClass) and node.returns is not None and attributeCondition(node.returns)
@@ -589,7 +589,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def stepIs(astClass: type[hasDOTstep], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTstep] | bool]:
+    def stepIs(astClass: type[hasDOTstep], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTstep] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTstep] | bool:
             return isinstance(node, astClass) and node.step is not None and attributeCondition(node.step)
@@ -646,14 +646,14 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def typeIs(astClass: type[hasDOTtype], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTtype] | bool]:
+    def typeIs(astClass: type[hasDOTtype], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTtype] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[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 | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTtype_comment] | bool]:
+    def type_commentIs(astClass: type[hasDOTtype_comment], attributeCondition: Callable[[str], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTtype_comment] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTtype_comment] | bool:
             return isinstance(node, astClass) and node.type_comment is not None and attributeCondition(node.type_comment)
@@ -674,7 +674,7 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def upperIs(astClass: type[hasDOTupper], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTupper] | bool]:
+    def upperIs(astClass: type[hasDOTupper], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTupper] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTupper] | bool:
             return isinstance(node, astClass) and node.upper is not None and attributeCondition(node.upper)
@@ -687,7 +687,7 @@ class ClassIsAndAttribute:
 
     @staticmethod
     @overload
-    def valueIs(astClass: type[hasDOTvalue_boolOrNone], attributeCondition: Callable[[bool | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTvalue_boolOrNone] | bool]:
+    def valueIs(astClass: type[hasDOTvalue_boolOrNone], attributeCondition: Callable[[bool], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTvalue_boolOrNone] | bool]:
         ...
 
     @staticmethod
@@ -697,11 +697,11 @@ class ClassIsAndAttribute:
 
     @staticmethod
     @overload
-    def valueIs(astClass: type[hasDOTvalue_exprOrNone], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTvalue_exprOrNone] | bool]:
+    def valueIs(astClass: type[hasDOTvalue_exprOrNone], attributeCondition: Callable[[ast.expr], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTvalue_exprOrNone] | bool]:
         ...
 
     @staticmethod
-    def valueIs(astClass: type[hasDOTvalue], attributeCondition: Callable[[Any], bool] | Callable[[bool | None], bool] | Callable[[ast.expr], bool] | Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTvalue] | bool]:
+    def valueIs(astClass: type[hasDOTvalue], attributeCondition: Callable[[Any], bool] | Callable[[bool], bool] | Callable[[ast.expr], 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)
@@ -715,8 +715,8 @@ class ClassIsAndAttribute:
         return workhorse
 
     @staticmethod
-    def varargIs(astClass: type[hasDOTvararg], attributeCondition: Callable[[ast.arg | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTvararg] | bool]:
+    def varargIs(astClass: type[hasDOTvararg], attributeCondition: Callable[[ast.arg], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTvararg] | bool]:
 
         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

{asttoolkit-0.3.1 → asttoolkit-0.3.2}/astToolkit/_toolDOT.py

@@ -25,11 +25,11 @@ class DOT:
 
     @staticmethod
     @overload
-    def annotation(node: hasDOTannotation_exprOrNone) -> ast.expr | None:
+    def annotation(node: hasDOTannotation_exprOrNone) -> ast.expr:
         ...
 
     @staticmethod
-    def annotation(node: hasDOTannotation) -> ast.expr | (ast.expr | None):
+    def annotation(node: hasDOTannotation) -> ast.expr:
         return node.annotation
 
     @staticmethod
@@ -39,11 +39,11 @@ class DOT:
 
     @staticmethod
     @overload
-    def arg(node: hasDOTarg_strOrNone) -> str | None:
+    def arg(node: hasDOTarg_strOrNone) -> str:
         ...
 
     @staticmethod
-    def arg(node: hasDOTarg) -> str | (str | None):
+    def arg(node: hasDOTarg) -> str:
         return node.arg
 
     @staticmethod
@@ -70,7 +70,7 @@ class DOT:
         return node.argtypes
 
     @staticmethod
-    def asname(node: hasDOTasname) -> str | None:
+    def asname(node: hasDOTasname) -> str:
         return node.asname
 
     @staticmethod
@@ -96,7 +96,7 @@ class DOT:
         return node.body
 
     @staticmethod
-    def bound(node: hasDOTbound) -> ast.expr | None:
+    def bound(node: hasDOTbound) -> ast.expr:
         return node.bound
 
     @staticmethod
@@ -104,7 +104,7 @@ class DOT:
         return node.cases
 
     @staticmethod
-    def cause(node: hasDOTcause) -> ast.expr | None:
+    def cause(node: hasDOTcause) -> ast.expr:
         return node.cause
 
     @staticmethod
@@ -133,7 +133,7 @@ class DOT:
     if sys.version_info >= (3, 13):
 
         @staticmethod
-        def default_value(node: hasDOTdefault_value) -> ast.expr | None:
+        def default_value(node: hasDOTdefault_value) -> ast.expr:
             return node.default_value
 
     @staticmethod
@@ -149,7 +149,7 @@ class DOT:
         return node.elts
 
     @staticmethod
-    def exc(node: hasDOTexc) -> ast.expr | None:
+    def exc(node: hasDOTexc) -> ast.expr:
         return node.exc
 
     @staticmethod
@@ -157,7 +157,7 @@ class DOT:
         return node.finalbody
 
     @staticmethod
-    def format_spec(node: hasDOTformat_spec) -> ast.expr | None:
+    def format_spec(node: hasDOTformat_spec) -> ast.expr:
         return node.format_spec
 
     @staticmethod
@@ -169,7 +169,7 @@ class DOT:
         return node.generators
 
     @staticmethod
-    def guard(node: hasDOTguard) -> ast.expr | None:
+    def guard(node: hasDOTguard) -> ast.expr:
         return node.guard
 
     @staticmethod
@@ -207,11 +207,11 @@ class DOT:
 
     @staticmethod
     @overload
-    def keys(node: hasDOTkeys_list_exprOrNone) -> list[ast.expr | None]:
+    def keys(node: hasDOTkeys_list_exprOrNone) -> list[ast.expr]:
         ...
 
     @staticmethod
-    def keys(node: hasDOTkeys) -> list[ast.expr] | list[ast.expr | None]:
+    def keys(node: hasDOTkeys) -> list[ast.expr]:
         return node.keys
 
     @staticmethod
@@ -219,15 +219,15 @@ class DOT:
         return node.keywords
 
     @staticmethod
-    def kind(node: hasDOTkind) -> str | None:
+    def kind(node: hasDOTkind) -> str:
         return node.kind
 
     @staticmethod
-    def kw_defaults(node: hasDOTkw_defaults) -> list[ast.expr | None]:
+    def kw_defaults(node: hasDOTkw_defaults) -> list[ast.expr]:
         return node.kw_defaults
 
     @staticmethod
-    def kwarg(node: hasDOTkwarg) -> ast.arg | None:
+    def kwarg(node: hasDOTkwarg) -> ast.arg:
         return node.kwarg
 
     @staticmethod
@@ -255,15 +255,15 @@ class DOT:
         return node.lineno
 
     @staticmethod
-    def lower(node: hasDOTlower) -> ast.expr | None:
+    def lower(node: hasDOTlower) -> ast.expr:
         return node.lower
 
     @staticmethod
-    def module(node: hasDOTmodule) -> str | None:
+    def module(node: hasDOTmodule) -> str:
         return node.module
 
     @staticmethod
-    def msg(node: hasDOTmsg) -> ast.expr | None:
+    def msg(node: hasDOTmsg) -> ast.expr:
         return node.msg
 
     @staticmethod
@@ -278,11 +278,11 @@ class DOT:
 
     @staticmethod
     @overload
-    def name(node: hasDOTname_strOrNone) -> str | None:
+    def name(node: hasDOTname_strOrNone) -> str:
         ...
 
     @staticmethod
-    def name(node: hasDOTname) -> ast.Name | str | (str | None):
+    def name(node: hasDOTname) -> ast.Name | str:
         return node.name
 
     @staticmethod
@@ -327,7 +327,7 @@ class DOT:
         return node.ops
 
     @staticmethod
-    def optional_vars(node: hasDOToptional_vars) -> ast.expr | None:
+    def optional_vars(node: hasDOToptional_vars) -> ast.expr:
         return node.optional_vars
 
     @staticmethod
@@ -351,11 +351,11 @@ class DOT:
 
     @staticmethod
     @overload
-    def pattern(node: hasDOTpattern_patternOrNone) -> ast.pattern | None:
+    def pattern(node: hasDOTpattern_patternOrNone) -> ast.pattern:
         ...
 
     @staticmethod
-    def pattern(node: hasDOTpattern) -> ast.pattern | (ast.pattern | None):
+    def pattern(node: hasDOTpattern) -> ast.pattern:
         return node.pattern
 
     @staticmethod
@@ -367,7 +367,7 @@ class DOT:
         return node.posonlyargs
 
     @staticmethod
-    def rest(node: hasDOTrest) -> str | None:
+    def rest(node: hasDOTrest) -> str:
         return node.rest
 
     @staticmethod
@@ -377,11 +377,11 @@ class DOT:
 
     @staticmethod
     @overload
-    def returns(node: hasDOTreturns_exprOrNone) -> ast.expr | None:
+    def returns(node: hasDOTreturns_exprOrNone) -> ast.expr:
         ...
 
     @staticmethod
-    def returns(node: hasDOTreturns) -> ast.expr | (ast.expr | None):
+    def returns(node: hasDOTreturns) -> ast.expr:
         return node.returns
 
     @staticmethod
@@ -397,7 +397,7 @@ class DOT:
         return node.slice
 
     @staticmethod
-    def step(node: hasDOTstep) -> ast.expr | None:
+    def step(node: hasDOTstep) -> ast.expr:
         return node.step
 
     @staticmethod
@@ -436,11 +436,11 @@ class DOT:
         return node.test
 
     @staticmethod
-    def type(node: hasDOTtype) -> ast.expr | None:
+    def type(node: hasDOTtype) -> ast.expr:
         return node.type
 
     @staticmethod
-    def type_comment(node: hasDOTtype_comment) -> str | None:
+    def type_comment(node: hasDOTtype_comment) -> str:
         return node.type_comment
 
     @staticmethod
@@ -452,7 +452,7 @@ class DOT:
         return node.type_params
 
     @staticmethod
-    def upper(node: hasDOTupper) -> ast.expr | None:
+    def upper(node: hasDOTupper) -> ast.expr:
         return node.upper
 
     @staticmethod
@@ -462,7 +462,7 @@ class DOT:
 
     @staticmethod
     @overload
-    def value(node: hasDOTvalue_boolOrNone) -> bool | None:
+    def value(node: hasDOTvalue_boolOrNone) -> bool:
         ...
 
     @staticmethod
@@ -472,11 +472,11 @@ class DOT:
 
     @staticmethod
     @overload
-    def value(node: hasDOTvalue_exprOrNone) -> ast.expr | None:
+    def value(node: hasDOTvalue_exprOrNone) -> ast.expr:
         ...
 
     @staticmethod
-    def value(node: hasDOTvalue) -> Any | (bool | None) | ast.expr | (ast.expr | None):
+    def value(node: hasDOTvalue) -> Any | bool | ast.expr:
         return node.value
 
     @staticmethod
@@ -484,5 +484,5 @@ class DOT:
         return node.values
 
     @staticmethod
-    def vararg(node: hasDOTvararg) -> ast.arg | None:
-        return node.vararg
+    def vararg(node: hasDOTvararg) -> ast.arg:
+        return node.vararg

{asttoolkit-0.3.1 → asttoolkit-0.3.2}/astToolkit/_toolGrab.py

@@ -29,7 +29,7 @@ class Grab:
         return workhorse
 
     @staticmethod
-    def annotationAttribute(action: Callable[[ast.expr], ast.expr] | Callable[[ast.expr | None], ast.expr | None]) -> Callable[[hasDOTannotation], hasDOTannotation]:
+    def annotationAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[hasDOTannotation], hasDOTannotation]:
 
         def workhorse(node: hasDOTannotation) -> hasDOTannotation:
             node.annotation = action(node.annotation) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
@@ -37,7 +37,7 @@ class Grab:
         return workhorse
 
     @staticmethod
-    def argAttribute(action: Callable[[str | None], str | None] | Callable[[str], str]) -> Callable[[hasDOTarg], hasDOTarg]:
+    def argAttribute(action: Callable[[str], str]) -> Callable[[hasDOTarg], hasDOTarg]:
 
         def workhorse(node: hasDOTarg) -> hasDOTarg:
             node.arg = action(node.arg) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
@@ -61,10 +61,10 @@ class Grab:
         return workhorse
 
     @staticmethod
-    def asnameAttribute(action: Callable[[str | None], str | None]) -> Callable[[hasDOTasname], hasDOTasname]:
+    def asnameAttribute(action: Callable[[str], str]) -> Callable[[hasDOTasname], hasDOTasname]:
 
         def workhorse(node: hasDOTasname) -> hasDOTasname:
-            node.asname = action(node.asname)
+            node.asname = action(node.asname) # pyright: ignore[reportArgumentType]
             return node
         return workhorse
 
@@ -93,10 +93,10 @@ class Grab:
         return workhorse
 
     @staticmethod
-    def boundAttribute(action: Callable[[ast.expr | None], ast.expr | None]) -> Callable[[hasDOTbound], hasDOTbound]:
+    def boundAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[hasDOTbound], hasDOTbound]:
 
         def workhorse(node: hasDOTbound) -> hasDOTbound:
-            node.bound = action(node.bound)
+            node.bound = action(node.bound) # pyright: ignore[reportArgumentType]
             return node
         return workhorse
 
@@ -109,10 +109,10 @@ class Grab:
         return workhorse
 
     @staticmethod
-    def causeAttribute(action: Callable[[ast.expr | None], ast.expr | None]) -> Callable[[hasDOTcause], hasDOTcause]:
+    def causeAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[hasDOTcause], hasDOTcause]:
 
         def workhorse(node: hasDOTcause) -> hasDOTcause:
-            node.cause = action(node.cause)
+            node.cause = action(node.cause) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
             return node
         return workhorse
 
@@ -166,10 +166,10 @@ class Grab:
     if sys.version_info >= (3, 13):
 
         @staticmethod
-        def default_valueAttribute(action: Callable[[ast.expr | None], ast.expr | None]) -> Callable[[hasDOTdefault_value], hasDOTdefault_value]:
+        def default_valueAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[hasDOTdefault_value], hasDOTdefault_value]:
 
             def workhorse(node: hasDOTdefault_value) -> hasDOTdefault_value:
-                node.default_value = action(node.default_value)
+                node.default_value = action(node.default_value) # pyright: ignore[reportArgumentType]
                 return node
             return workhorse
 
@@ -198,10 +198,10 @@ class Grab:
         return workhorse
 
     @staticmethod
-    def excAttribute(action: Callable[[ast.expr | None], ast.expr | None]) -> Callable[[hasDOTexc], hasDOTexc]:
+    def excAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[hasDOTexc], hasDOTexc]:
 
         def workhorse(node: hasDOTexc) -> hasDOTexc:
-            node.exc = action(node.exc)
+            node.exc = action(node.exc) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
             return node
         return workhorse
 
@@ -214,10 +214,10 @@ class Grab:
         return workhorse
 
     @staticmethod
-    def format_specAttribute(action: Callable[[ast.expr | None], ast.expr | None]) -> Callable[[hasDOTformat_spec], hasDOTformat_spec]:
+    def format_specAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[hasDOTformat_spec], hasDOTformat_spec]:
 
         def workhorse(node: hasDOTformat_spec) -> hasDOTformat_spec:
-            node.format_spec = action(node.format_spec)
+            node.format_spec = action(node.format_spec) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
             return node
         return workhorse
 
@@ -238,10 +238,10 @@ class Grab:
         return workhorse
 
     @staticmethod
-    def guardAttribute(action: Callable[[ast.expr | None], ast.expr | None]) -> Callable[[hasDOTguard], hasDOTguard]:
+    def guardAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[hasDOTguard], hasDOTguard]:
 
         def workhorse(node: hasDOTguard) -> hasDOTguard:
-            node.guard = action(node.guard)
+            node.guard = action(node.guard) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
             return node
         return workhorse
 
@@ -302,7 +302,7 @@ class Grab:
         return workhorse
 
     @staticmethod
-    def keysAttribute(action: Callable[[Sequence[ast.expr]], Sequence[ast.expr]] | Callable[[Sequence[ast.expr | None]], Sequence[ast.expr | None]]) -> Callable[[hasDOTkeys], hasDOTkeys]:
+    def keysAttribute(action: Callable[[Sequence[ast.expr]], Sequence[ast.expr]]) -> Callable[[hasDOTkeys], hasDOTkeys]:
 
         def workhorse(node: hasDOTkeys) -> hasDOTkeys:
             node.keys = action(node.keys) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
@@ -318,15 +318,15 @@ class Grab:
         return workhorse
 
     @staticmethod
-    def kindAttribute(action: Callable[[str | None], str | None]) -> Callable[[hasDOTkind], hasDOTkind]:
+    def kindAttribute(action: Callable[[str], str]) -> Callable[[hasDOTkind], hasDOTkind]:
 
         def workhorse(node: hasDOTkind) -> hasDOTkind:
-            node.kind = action(node.kind)
+            node.kind = action(node.kind) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
             return node
         return workhorse
 
     @staticmethod
-    def kw_defaultsAttribute(action: Callable[[Sequence[ast.expr | None]], Sequence[ast.expr | None]]) -> Callable[[hasDOTkw_defaults], hasDOTkw_defaults]:
+    def kw_defaultsAttribute(action: Callable[[Sequence[ast.expr]], Sequence[ast.expr]]) -> Callable[[hasDOTkw_defaults], hasDOTkw_defaults]:
 
         def workhorse(node: hasDOTkw_defaults) -> hasDOTkw_defaults:
             node.kw_defaults = action(node.kw_defaults) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
@@ -334,10 +334,10 @@ class Grab:
         return workhorse
 
     @staticmethod
-    def kwargAttribute(action: Callable[[ast.arg | None], ast.arg | None]) -> Callable[[hasDOTkwarg], hasDOTkwarg]:
+    def kwargAttribute(action: Callable[[ast.arg], ast.arg]) -> Callable[[hasDOTkwarg], hasDOTkwarg]:
 
         def workhorse(node: hasDOTkwarg) -> hasDOTkwarg:
-            node.kwarg = action(node.kwarg)
+            node.kwarg = action(node.kwarg) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
             return node
         return workhorse
 
@@ -390,31 +390,31 @@ class Grab:
         return workhorse
 
     @staticmethod
-    def lowerAttribute(action: Callable[[ast.expr | None], ast.expr | None]) -> Callable[[hasDOTlower], hasDOTlower]:
+    def lowerAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[hasDOTlower], hasDOTlower]:
 
         def workhorse(node: hasDOTlower) -> hasDOTlower:
-            node.lower = action(node.lower)
+            node.lower = action(node.lower) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
             return node
         return workhorse
 
     @staticmethod
-    def moduleAttribute(action: Callable[[str | None], str | None]) -> Callable[[hasDOTmodule], hasDOTmodule]:
+    def moduleAttribute(action: Callable[[str], str]) -> Callable[[hasDOTmodule], hasDOTmodule]:
 
         def workhorse(node: hasDOTmodule) -> hasDOTmodule:
-            node.module = action(node.module)
+            node.module = action(node.module) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
             return node
         return workhorse
 
     @staticmethod
-    def msgAttribute(action: Callable[[ast.expr | None], ast.expr | None]) -> Callable[[hasDOTmsg], hasDOTmsg]:
+    def msgAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[hasDOTmsg], hasDOTmsg]:
 
         def workhorse(node: hasDOTmsg) -> hasDOTmsg:
-            node.msg = action(node.msg)
+            node.msg = action(node.msg) # pyright: ignore[reportArgumentType]
             return node
         return workhorse
 
     @staticmethod
-    def nameAttribute(action: Callable[[ast.Name], ast.Name] | Callable[[str | None], str | None] | Callable[[str], str]) -> Callable[[hasDOTname], hasDOTname]:
+    def nameAttribute(action: Callable[[ast.Name], ast.Name] | Callable[[str], str]) -> Callable[[hasDOTname], hasDOTname]:
 
         def workhorse(node: hasDOTname) -> hasDOTname:
             node.name = action(node.name) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
@@ -454,10 +454,10 @@ class Grab:
         return workhorse
 
     @staticmethod
-    def optional_varsAttribute(action: Callable[[ast.expr | None], ast.expr | None]) -> Callable[[hasDOToptional_vars], hasDOToptional_vars]:
+    def optional_varsAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[hasDOToptional_vars], hasDOToptional_vars]:
 
         def workhorse(node: hasDOToptional_vars) -> hasDOToptional_vars:
-            node.optional_vars = action(node.optional_vars)
+            node.optional_vars = action(node.optional_vars) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
             return node
         return workhorse
 
@@ -470,7 +470,7 @@ class Grab:
         return workhorse
 
     @staticmethod
-    def patternAttribute(action: Callable[[ast.pattern], ast.pattern] | Callable[[ast.pattern | None], ast.pattern | None]) -> Callable[[hasDOTpattern], hasDOTpattern]:
+    def patternAttribute(action: Callable[[ast.pattern], ast.pattern]) -> Callable[[hasDOTpattern], hasDOTpattern]:
 
         def workhorse(node: hasDOTpattern) -> hasDOTpattern:
             node.pattern = action(node.pattern) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
@@ -494,15 +494,15 @@ class Grab:
         return workhorse
 
     @staticmethod
-    def restAttribute(action: Callable[[str | None], str | None]) -> Callable[[hasDOTrest], hasDOTrest]:
+    def restAttribute(action: Callable[[str], str]) -> Callable[[hasDOTrest], hasDOTrest]:
 
         def workhorse(node: hasDOTrest) -> hasDOTrest:
-            node.rest = action(node.rest)
+            node.rest = action(node.rest) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
             return node
         return workhorse
 
     @staticmethod
-    def returnsAttribute(action: Callable[[ast.expr], ast.expr] | Callable[[ast.expr | None], ast.expr | None]) -> Callable[[hasDOTreturns], hasDOTreturns]:
+    def returnsAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[hasDOTreturns], hasDOTreturns]:
 
         def workhorse(node: hasDOTreturns) -> hasDOTreturns:
             node.returns = action(node.returns) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
@@ -534,10 +534,10 @@ class Grab:
         return workhorse
 
     @staticmethod
-    def stepAttribute(action: Callable[[ast.expr | None], ast.expr | None]) -> Callable[[hasDOTstep], hasDOTstep]:
+    def stepAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[hasDOTstep], hasDOTstep]:
 
         def workhorse(node: hasDOTstep) -> hasDOTstep:
-            node.step = action(node.step)
+            node.step = action(node.step) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
             return node
         return workhorse
 
@@ -582,18 +582,18 @@ class Grab:
         return workhorse
 
     @staticmethod
-    def typeAttribute(action: Callable[[ast.expr | None], ast.expr | None]) -> Callable[[hasDOTtype], hasDOTtype]:
+    def typeAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[hasDOTtype], hasDOTtype]:
 
         def workhorse(node: hasDOTtype) -> hasDOTtype:
-            node.type = action(node.type)
+            node.type = action(node.type) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
             return node
         return workhorse
 
     @staticmethod
-    def type_commentAttribute(action: Callable[[str | None], str | None]) -> Callable[[hasDOTtype_comment], hasDOTtype_comment]:
+    def type_commentAttribute(action: Callable[[str], str]) -> Callable[[hasDOTtype_comment], hasDOTtype_comment]:
 
         def workhorse(node: hasDOTtype_comment) -> hasDOTtype_comment:
-            node.type_comment = action(node.type_comment)
+            node.type_comment = action(node.type_comment) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
             return node
         return workhorse
 
@@ -614,15 +614,15 @@ class Grab:
         return workhorse
 
     @staticmethod
-    def upperAttribute(action: Callable[[ast.expr | None], ast.expr | None]) -> Callable[[hasDOTupper], hasDOTupper]:
+    def upperAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[hasDOTupper], hasDOTupper]:
 
         def workhorse(node: hasDOTupper) -> hasDOTupper:
-            node.upper = action(node.upper)
+            node.upper = action(node.upper) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
             return node
         return workhorse
 
     @staticmethod
-    def valueAttribute(action: Callable[[ast.expr], ast.expr] | Callable[[ast.expr | None], ast.expr | None] | Callable[[bool | None], bool | None] | Callable[[Any], Any]) -> Callable[[hasDOTvalue], hasDOTvalue]:
+    def valueAttribute(action: Callable[[ast.expr], ast.expr] | Callable[[bool], bool] | Callable[[Any], Any]) -> Callable[[hasDOTvalue], hasDOTvalue]:
 
         def workhorse(node: hasDOTvalue) -> hasDOTvalue:
             node.value = action(node.value) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
@@ -638,9 +638,9 @@ class Grab:
         return workhorse
 
     @staticmethod
-    def varargAttribute(action: Callable[[ast.arg | None], ast.arg | None]) -> Callable[[hasDOTvararg], hasDOTvararg]:
+    def varargAttribute(action: Callable[[ast.arg], ast.arg]) -> Callable[[hasDOTvararg], hasDOTvararg]:
 
         def workhorse(node: hasDOTvararg) -> hasDOTvararg:
-            node.vararg = action(node.vararg)
+            node.vararg = action(node.vararg) # pyright: ignore[reportArgumentType, reportAttributeAccessIssue]
             return node
-        return workhorse
+        return workhorse

{asttoolkit-0.3.1 → asttoolkit-0.3.2}/astToolkit/_toolIfThis.py

@@ -42,11 +42,11 @@ class IfThis:
 	@staticmethod
 	def is_keywordIdentifier(identifier: str) -> Callable[[ast.AST], TypeGuard[ast.keyword] | bool]:
 		"""see also `isArgumentIdentifier`"""
-		return lambda node: Be.keyword(node) and IfThis.isIdentifier(identifier)(DOT.arg(node))
+		return lambda node: Be.keyword(node) and node.arg is not None and IfThis.isIdentifier(identifier)(node.arg)
 
 	@staticmethod
 	def isArgumentIdentifier(identifier: str) -> Callable[[ast.AST], TypeGuard[ast.arg | ast.keyword] | bool]:
-		return lambda node: (Be.arg(node) or Be.keyword(node)) and IfThis.isIdentifier(identifier)(DOT.arg(node))
+		return lambda node: (Be.arg(node) or Be.keyword(node)) and node.arg is not None and IfThis.isIdentifier(identifier)(node.arg)
 
 	@staticmethod
 	def isAssignAndTargets0Is(targets0Predicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], TypeGuard[ast.AnnAssign] | bool]:
@@ -101,7 +101,7 @@ class IfThis:
 		return lambda node: Be.FunctionDef(node) and IfThis.isIdentifier(identifier)(DOT.name(node))
 
 	@staticmethod
-	def isIdentifier(identifier: str) -> Callable[[str | None], TypeGuard[str] | bool]:
+	def isIdentifier(identifier: str) -> Callable[[str], TypeGuard[str] | bool]:
 		return lambda node: node == identifier
 
 	@staticmethod

{asttoolkit-0.3.1 → asttoolkit-0.3.2}/astToolkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astToolkit
-Version: 0.3.1
+Version: 0.3.2
 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.1 → asttoolkit-0.3.2}/pyproject.toml

@@ -36,7 +36,7 @@ optional-dependencies = { testing = [
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.12"
 urls = { Donate = "https://www.patreon.com/integrated", Homepage = "https://github.com/hunterhogan/astToolkit", Issues = "https://github.com/hunterhogan/astToolkit/issues", Repository = "https://github.com/hunterhogan/astToolkit.git" }
-version = "0.3.1"
+version = "0.3.2"
 
 [tool.coverage]
 report = { exclude_lines = [