astToolkit 0.2.3__tar.gz → 0.3.0__tar.gz

{asttoolkit-0.2.3 → asttoolkit-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astToolkit
-Version: 0.2.3
+Version: 0.3.0
 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
@@ -25,7 +25,7 @@ Classifier: Typing :: Typed
 Classifier: Topic :: Software Development :: Code Generators
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
-Requires-Python: >=3.10
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: autoflake
@@ -183,32 +183,32 @@ print(ast.unparse(tree))
 This example shows a more complex transformation inspired by the mapFolding package:
 
 ```python
-from astToolkit import ast_Identifier, Be, DOT, Grab, IfThis as astToolkit_IfThis, Make, NodeChanger, Then
+from astToolkit import str, Be, DOT, Grab, IfThis as astToolkit_IfThis, Make, NodeChanger, Then
 import ast
 
 # Define custom predicates by extending IfThis
 class IfThis(astToolkit_IfThis):
   @staticmethod
-  def isAttributeNamespace_IdentifierGreaterThan0(
-      namespace: ast_Identifier,
-      identifier: ast_Identifier
+  def isAttributeNamespaceIdentifierGreaterThan0(
+      namespace: str,
+      identifier: str
       ) -> Callable[[ast.AST], TypeGuard[ast.Compare] | bool]:
 
     return lambda node: (
         Be.Compare(node)
-        and IfThis.isAttributeNamespace_Identifier(namespace, identifier)(DOT.left(node))
+        and IfThis.isAttributeNamespaceIdentifier(namespace, identifier)(DOT.left(node))
         and Be.Gt(node.ops[0])
         and IfThis.isConstant_value(0)(node.comparators[0]))
 
   @staticmethod
-  def isWhileAttributeNamespace_IdentifierGreaterThan0(
-      namespace: ast_Identifier,
-      identifier: ast_Identifier
+  def isWhileAttributeNamespaceIdentifierGreaterThan0(
+      namespace: str,
+      identifier: str
       ) -> Callable[[ast.AST], TypeGuard[ast.While] | bool]:
 
     return lambda node: (
         Be.While(node)
-        and IfThis.isAttributeNamespace_IdentifierGreaterThan0(namespace, identifier)(DOT.test(node)))
+        and IfThis.isAttributeNamespaceIdentifierGreaterThan0(namespace, identifier)(DOT.test(node)))
 
 # Parse some code
 code = """
@@ -219,7 +219,7 @@ while claude.counter > 0:
 tree = ast.parse(code)
 
 # Find the while loop with our custom predicate
-find_while_loop = IfThis.isWhileAttributeNamespace_IdentifierGreaterThan0("claude", "counter")
+find_while_loop = IfThis.isWhileAttributeNamespaceIdentifierGreaterThan0("claude", "counter")
 
 # Replace counter > 0 with counter > 1
 change_condition = Grab.testAttribute(
@@ -255,7 +255,7 @@ module_ast = parseLogicalPath2astModule("my_package.source_module")
 # Extract a function and track its imports
 function_name = "target_function"
 function_def = NodeTourist(
-    IfThis.isFunctionDef_Identifier(function_name),
+    IfThis.isFunctionDefIdentifier(function_name),
     Then.extractIt
 ).captureLastMatch(module_ast)
 
@@ -290,34 +290,34 @@ if function_def:
 To create specialized patterns for your codebase, extend the core classes:
 
 ```python
-from astToolkit import ast_Identifier, Be, IfThis as astToolkit_IfThis
+from astToolkit import str, Be, IfThis as astToolkit_IfThis
 from collections.abc import Callable
 from typing import TypeGuard
 import ast
 
 class IfThis(astToolkit_IfThis):
     @staticmethod
-    def isAttributeNamespace_IdentifierGreaterThan0(
-        namespace: ast_Identifier,
-        identifier: ast_Identifier
+    def isAttributeNamespaceIdentifierGreaterThan0(
+        namespace: str,
+        identifier: str
     ) -> Callable[[ast.AST], TypeGuard[ast.Compare] | bool]:
         """Find comparisons like 'state.counter > 0'"""
         return lambda node: (
             Be.Compare(node)
-            and IfThis.isAttributeNamespace_Identifier(namespace, identifier)(node.left)
+            and IfThis.isAttributeNamespaceIdentifier(namespace, identifier)(node.left)
             and Be.Gt(node.ops[0])
             and IfThis.isConstant_value(0)(node.comparators[0])
         )
 
     @staticmethod
-    def isWhileAttributeNamespace_IdentifierGreaterThan0(
-        namespace: ast_Identifier,
-        identifier: ast_Identifier
+    def isWhileAttributeNamespaceIdentifierGreaterThan0(
+        namespace: str,
+        identifier: str
     ) -> Callable[[ast.AST], TypeGuard[ast.While] | bool]:
         """Find while loops like 'while state.counter > 0:'"""
         return lambda node: (
             Be.While(node)
-            and IfThis.isAttributeNamespace_IdentifierGreaterThan0(namespace, identifier)(node.test)
+            and IfThis.isAttributeNamespaceIdentifierGreaterThan0(namespace, identifier)(node.test)
         )
 ```
 

{asttoolkit-0.2.3 → asttoolkit-0.3.0}/README.md

@@ -140,32 +140,32 @@ print(ast.unparse(tree))
 This example shows a more complex transformation inspired by the mapFolding package:
 
 ```python
-from astToolkit import ast_Identifier, Be, DOT, Grab, IfThis as astToolkit_IfThis, Make, NodeChanger, Then
+from astToolkit import str, Be, DOT, Grab, IfThis as astToolkit_IfThis, Make, NodeChanger, Then
 import ast
 
 # Define custom predicates by extending IfThis
 class IfThis(astToolkit_IfThis):
   @staticmethod
-  def isAttributeNamespace_IdentifierGreaterThan0(
-      namespace: ast_Identifier,
-      identifier: ast_Identifier
+  def isAttributeNamespaceIdentifierGreaterThan0(
+      namespace: str,
+      identifier: str
       ) -> Callable[[ast.AST], TypeGuard[ast.Compare] | bool]:
 
     return lambda node: (
         Be.Compare(node)
-        and IfThis.isAttributeNamespace_Identifier(namespace, identifier)(DOT.left(node))
+        and IfThis.isAttributeNamespaceIdentifier(namespace, identifier)(DOT.left(node))
         and Be.Gt(node.ops[0])
         and IfThis.isConstant_value(0)(node.comparators[0]))
 
   @staticmethod
-  def isWhileAttributeNamespace_IdentifierGreaterThan0(
-      namespace: ast_Identifier,
-      identifier: ast_Identifier
+  def isWhileAttributeNamespaceIdentifierGreaterThan0(
+      namespace: str,
+      identifier: str
       ) -> Callable[[ast.AST], TypeGuard[ast.While] | bool]:
 
     return lambda node: (
         Be.While(node)
-        and IfThis.isAttributeNamespace_IdentifierGreaterThan0(namespace, identifier)(DOT.test(node)))
+        and IfThis.isAttributeNamespaceIdentifierGreaterThan0(namespace, identifier)(DOT.test(node)))
 
 # Parse some code
 code = """
@@ -176,7 +176,7 @@ while claude.counter > 0:
 tree = ast.parse(code)
 
 # Find the while loop with our custom predicate
-find_while_loop = IfThis.isWhileAttributeNamespace_IdentifierGreaterThan0("claude", "counter")
+find_while_loop = IfThis.isWhileAttributeNamespaceIdentifierGreaterThan0("claude", "counter")
 
 # Replace counter > 0 with counter > 1
 change_condition = Grab.testAttribute(
@@ -212,7 +212,7 @@ module_ast = parseLogicalPath2astModule("my_package.source_module")
 # Extract a function and track its imports
 function_name = "target_function"
 function_def = NodeTourist(
-    IfThis.isFunctionDef_Identifier(function_name),
+    IfThis.isFunctionDefIdentifier(function_name),
     Then.extractIt
 ).captureLastMatch(module_ast)
 
@@ -247,34 +247,34 @@ if function_def:
 To create specialized patterns for your codebase, extend the core classes:
 
 ```python
-from astToolkit import ast_Identifier, Be, IfThis as astToolkit_IfThis
+from astToolkit import str, Be, IfThis as astToolkit_IfThis
 from collections.abc import Callable
 from typing import TypeGuard
 import ast
 
 class IfThis(astToolkit_IfThis):
     @staticmethod
-    def isAttributeNamespace_IdentifierGreaterThan0(
-        namespace: ast_Identifier,
-        identifier: ast_Identifier
+    def isAttributeNamespaceIdentifierGreaterThan0(
+        namespace: str,
+        identifier: str
     ) -> Callable[[ast.AST], TypeGuard[ast.Compare] | bool]:
         """Find comparisons like 'state.counter > 0'"""
         return lambda node: (
             Be.Compare(node)
-            and IfThis.isAttributeNamespace_Identifier(namespace, identifier)(node.left)
+            and IfThis.isAttributeNamespaceIdentifier(namespace, identifier)(node.left)
             and Be.Gt(node.ops[0])
             and IfThis.isConstant_value(0)(node.comparators[0])
         )
 
     @staticmethod
-    def isWhileAttributeNamespace_IdentifierGreaterThan0(
-        namespace: ast_Identifier,
-        identifier: ast_Identifier
+    def isWhileAttributeNamespaceIdentifierGreaterThan0(
+        namespace: str,
+        identifier: str
     ) -> Callable[[ast.AST], TypeGuard[ast.While] | bool]:
         """Find while loops like 'while state.counter > 0:'"""
         return lambda node: (
             Be.While(node)
-            and IfThis.isAttributeNamespace_IdentifierGreaterThan0(namespace, identifier)(node.test)
+            and IfThis.isAttributeNamespaceIdentifierGreaterThan0(namespace, identifier)(node.test)
         )
 ```
 

{asttoolkit-0.2.3 → asttoolkit-0.3.0}/astToolkit/__init__.py

@@ -1,15 +1,8 @@
-from astToolkit._typesSpecial import (
-	NotRequired as NotRequired,
-	TypedDict as TypedDict,
-)
-
 from astToolkit._astTypes import *  # noqa: F403
 
 from astToolkit.theSSOT import FREAKOUT as FREAKOUT, The as The
 
 from astToolkit._types import (
-	ast_expr_Slice as ast_expr_Slice,
-	ast_Identifier as ast_Identifier,
 	NodeORattribute as NodeORattribute,
 	str_nameDOTname as str_nameDOTname,
 	个 as 个,

{asttoolkit-0.2.3 → asttoolkit-0.3.0}/astToolkit/_astTypes.py

@@ -20,13 +20,9 @@ hasDOTasname: typing_TypeAlias = ast.alias
 hasDOTattr: typing_TypeAlias = ast.Attribute
 hasDOTbases: typing_TypeAlias = ast.ClassDef
 hasDOTbody_expr: typing_TypeAlias = ast.Expression | ast.IfExp | ast.Lambda
-if sys.version_info >= (3, 11):
-    hasDOTbody_list_stmt: typing_TypeAlias = ast.AsyncFor | ast.AsyncFunctionDef | ast.AsyncWith | ast.ClassDef | ast.ExceptHandler | ast.For | ast.FunctionDef | ast.If | ast.Interactive | ast.match_case | ast.Module | ast.Try | ast.TryStar | ast.While | ast.With
-else:
-    hasDOTbody_list_stmt: typing_TypeAlias = ast.AsyncFor | ast.AsyncFunctionDef | ast.AsyncWith | ast.ClassDef | ast.ExceptHandler | ast.For | ast.FunctionDef | ast.If | ast.Interactive | ast.match_case | ast.Module | ast.Try | ast.While | ast.With
+hasDOTbody_list_stmt: typing_TypeAlias = ast.AsyncFor | ast.AsyncFunctionDef | ast.AsyncWith | ast.ClassDef | ast.ExceptHandler | ast.For | ast.FunctionDef | ast.If | ast.Interactive | ast.match_case | ast.Module | ast.Try | ast.TryStar | ast.While | ast.With
 hasDOTbody: typing_TypeAlias = hasDOTbody_expr | hasDOTbody_list_stmt
-if sys.version_info >= (3, 12):
-    hasDOTbound: typing_TypeAlias = ast.TypeVar
+hasDOTbound: typing_TypeAlias = ast.TypeVar
 hasDOTcases: typing_TypeAlias = ast.Match
 hasDOTcause: typing_TypeAlias = ast.Raise
 hasDOTcls: typing_TypeAlias = ast.MatchClass
@@ -41,18 +37,12 @@ hasDOTdefaults: typing_TypeAlias = ast.arguments
 hasDOTelt: typing_TypeAlias = ast.GeneratorExp | ast.ListComp | ast.SetComp
 hasDOTelts: typing_TypeAlias = ast.List | ast.Set | ast.Tuple
 hasDOTexc: typing_TypeAlias = ast.Raise
-if sys.version_info >= (3, 11):
-    hasDOTfinalbody: typing_TypeAlias = ast.Try | ast.TryStar
-else:
-    hasDOTfinalbody: typing_TypeAlias = ast.Try
+hasDOTfinalbody: typing_TypeAlias = ast.Try | ast.TryStar
 hasDOTformat_spec: typing_TypeAlias = ast.FormattedValue
 hasDOTfunc: typing_TypeAlias = ast.Call
 hasDOTgenerators: typing_TypeAlias = ast.DictComp | ast.GeneratorExp | ast.ListComp | ast.SetComp
 hasDOTguard: typing_TypeAlias = ast.match_case
-if sys.version_info >= (3, 11):
-    hasDOThandlers: typing_TypeAlias = ast.Try | ast.TryStar
-else:
-    hasDOThandlers: typing_TypeAlias = ast.Try
+hasDOThandlers: typing_TypeAlias = ast.Try | ast.TryStar
 hasDOTid: typing_TypeAlias = ast.Name
 hasDOTifs: typing_TypeAlias = ast.comprehension
 hasDOTis_async: typing_TypeAlias = ast.comprehension
@@ -75,17 +65,10 @@ hasDOTlineno: typing_TypeAlias = ast.TypeIgnore
 hasDOTlower: typing_TypeAlias = ast.Slice
 hasDOTmodule: typing_TypeAlias = ast.ImportFrom
 hasDOTmsg: typing_TypeAlias = ast.Assert
-if sys.version_info >= (3, 12):
-    hasDOTname_Name: typing_TypeAlias = ast.TypeAlias
-if sys.version_info >= (3, 12):
-    hasDOTname_str: typing_TypeAlias = ast.alias | ast.AsyncFunctionDef | ast.ClassDef | ast.FunctionDef | ast.ParamSpec | ast.TypeVar | ast.TypeVarTuple
-else:
-    hasDOTname_str: typing_TypeAlias = ast.alias | ast.AsyncFunctionDef | ast.ClassDef | ast.FunctionDef
+hasDOTname_Name: typing_TypeAlias = ast.TypeAlias
+hasDOTname_str: typing_TypeAlias = ast.alias | ast.AsyncFunctionDef | ast.ClassDef | ast.FunctionDef | ast.ParamSpec | ast.TypeVar | ast.TypeVarTuple
 hasDOTname_strOrNone: typing_TypeAlias = ast.ExceptHandler | ast.MatchAs | ast.MatchStar
-if sys.version_info >= (3, 12):
-    hasDOTname: typing_TypeAlias = hasDOTname_Name | hasDOTname_str | hasDOTname_strOrNone
-else:
-    hasDOTname: typing_TypeAlias = hasDOTname_str | hasDOTname_strOrNone
+hasDOTname: typing_TypeAlias = hasDOTname_Name | hasDOTname_str | hasDOTname_strOrNone
 hasDOTnames_list_alias: typing_TypeAlias = ast.Import | ast.ImportFrom
 hasDOTnames_list_str: typing_TypeAlias = ast.Global | ast.Nonlocal
 hasDOTnames: typing_TypeAlias = hasDOTnames_list_alias | hasDOTnames_list_str
@@ -97,10 +80,7 @@ hasDOToperand: typing_TypeAlias = ast.UnaryOp
 hasDOTops: typing_TypeAlias = ast.Compare
 hasDOToptional_vars: typing_TypeAlias = ast.withitem
 hasDOTorelse_expr: typing_TypeAlias = ast.IfExp
-if sys.version_info >= (3, 11):
-    hasDOTorelse_list_stmt: typing_TypeAlias = ast.AsyncFor | ast.For | ast.If | ast.Try | ast.TryStar | ast.While
-else:
-    hasDOTorelse_list_stmt: typing_TypeAlias = ast.AsyncFor | ast.For | ast.If | ast.Try | ast.While
+hasDOTorelse_list_stmt: typing_TypeAlias = ast.AsyncFor | ast.For | ast.If | ast.Try | ast.TryStar | ast.While
 hasDOTorelse: typing_TypeAlias = hasDOTorelse_expr | hasDOTorelse_list_stmt
 hasDOTpattern_pattern: typing_TypeAlias = ast.match_case
 hasDOTpattern_patternOrNone: typing_TypeAlias = ast.MatchAs
@@ -117,24 +97,20 @@ hasDOTslice: typing_TypeAlias = ast.Subscript
 hasDOTstep: typing_TypeAlias = ast.Slice
 hasDOTsubject: typing_TypeAlias = ast.Match
 hasDOTtag: typing_TypeAlias = ast.TypeIgnore
-hasDOTtarget_expr: typing_TypeAlias = ast.AsyncFor | ast.comprehension | ast.For
 hasDOTtarget_Name: typing_TypeAlias = ast.NamedExpr
 hasDOTtarget_NameOrAttributeOrSubscript: typing_TypeAlias = ast.AnnAssign | ast.AugAssign
-hasDOTtarget: typing_TypeAlias = hasDOTtarget_expr | hasDOTtarget_Name | hasDOTtarget_NameOrAttributeOrSubscript
+hasDOTtarget_expr: typing_TypeAlias = ast.AsyncFor | ast.comprehension | ast.For
+hasDOTtarget: typing_TypeAlias = hasDOTtarget_Name | hasDOTtarget_NameOrAttributeOrSubscript | hasDOTtarget_expr
 hasDOTtargets: typing_TypeAlias = ast.Assign | ast.Delete
 hasDOTtest: typing_TypeAlias = ast.Assert | ast.If | ast.IfExp | ast.While
 hasDOTtype: typing_TypeAlias = ast.ExceptHandler
 hasDOTtype_comment: typing_TypeAlias = ast.arg | ast.Assign | ast.AsyncFor | ast.AsyncFunctionDef | ast.AsyncWith | ast.For | ast.FunctionDef | ast.With
 hasDOTtype_ignores: typing_TypeAlias = ast.Module
-if sys.version_info >= (3, 12):
-    hasDOTtype_params: typing_TypeAlias = ast.AsyncFunctionDef | ast.ClassDef | ast.FunctionDef | ast.TypeAlias
+hasDOTtype_params: typing_TypeAlias = ast.AsyncFunctionDef | ast.ClassDef | ast.FunctionDef | ast.TypeAlias
 hasDOTupper: typing_TypeAlias = ast.Slice
 hasDOTvalue_Any: typing_TypeAlias = ast.Constant
 hasDOTvalue_boolOrNone: typing_TypeAlias = ast.MatchSingleton
-if sys.version_info >= (3, 12):
-    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
-else:
-    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.YieldFrom
+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_Any | hasDOTvalue_boolOrNone | hasDOTvalue_expr | hasDOTvalue_exprOrNone
 hasDOTvalues: typing_TypeAlias = ast.BoolOp | ast.Dict | ast.JoinedStr

{asttoolkit-0.2.3 → asttoolkit-0.3.0}/astToolkit/_toolBe.py

@@ -95,14 +95,14 @@ class Be:
     def BitXor(node: ast.AST) -> TypeGuard[ast.BitXor]:
         return isinstance(node, ast.BitXor)
 
-    @staticmethod
-    def BoolOp(node: ast.AST) -> TypeGuard[ast.BoolOp]:
-        return isinstance(node, ast.BoolOp)
-
     @staticmethod
     def boolop(node: ast.AST) -> TypeGuard[ast.boolop]:
         return isinstance(node, ast.boolop)
 
+    @staticmethod
+    def BoolOp(node: ast.AST) -> TypeGuard[ast.BoolOp]:
+        return isinstance(node, ast.BoolOp)
+
     @staticmethod
     def Break(node: ast.AST) -> TypeGuard[ast.Break]:
         return isinstance(node, ast.Break)
@@ -159,22 +159,22 @@ class Be:
     def Eq(node: ast.AST) -> TypeGuard[ast.Eq]:
         return isinstance(node, ast.Eq)
 
-    @staticmethod
-    def ExceptHandler(node: ast.AST) -> TypeGuard[ast.ExceptHandler]:
-        return isinstance(node, ast.ExceptHandler)
-
     @staticmethod
     def excepthandler(node: ast.AST) -> TypeGuard[ast.excepthandler]:
         return isinstance(node, ast.excepthandler)
 
     @staticmethod
-    def Expr(node: ast.AST) -> TypeGuard[ast.Expr]:
-        return isinstance(node, ast.Expr)
+    def ExceptHandler(node: ast.AST) -> TypeGuard[ast.ExceptHandler]:
+        return isinstance(node, ast.ExceptHandler)
 
     @staticmethod
     def expr(node: ast.AST) -> TypeGuard[ast.expr]:
         return isinstance(node, ast.expr)
 
+    @staticmethod
+    def Expr(node: ast.AST) -> TypeGuard[ast.Expr]:
+        return isinstance(node, ast.Expr)
+
     @staticmethod
     def expr_context(node: ast.AST) -> TypeGuard[ast.expr_context]:
         return isinstance(node, ast.expr_context)
@@ -335,14 +335,14 @@ class Be:
     def MatMult(node: ast.AST) -> TypeGuard[ast.MatMult]:
         return isinstance(node, ast.MatMult)
 
-    @staticmethod
-    def Mod(node: ast.AST) -> TypeGuard[ast.Mod]:
-        return isinstance(node, ast.Mod)
-
     @staticmethod
     def mod(node: ast.AST) -> TypeGuard[ast.mod]:
         return isinstance(node, ast.mod)
 
+    @staticmethod
+    def Mod(node: ast.AST) -> TypeGuard[ast.Mod]:
+        return isinstance(node, ast.Mod)
+
     @staticmethod
     def Module(node: ast.AST) -> TypeGuard[ast.Module]:
         return isinstance(node, ast.Module)
@@ -382,11 +382,10 @@ class Be:
     @staticmethod
     def Or(node: ast.AST) -> TypeGuard[ast.Or]:
         return isinstance(node, ast.Or)
-    if sys.version_info >= (3, 12):
 
-        @staticmethod
-        def ParamSpec(node: ast.AST) -> TypeGuard[ast.ParamSpec]:
-            return isinstance(node, ast.ParamSpec)
+    @staticmethod
+    def ParamSpec(node: ast.AST) -> TypeGuard[ast.ParamSpec]:
+        return isinstance(node, ast.ParamSpec)
 
     @staticmethod
     def Pass(node: ast.AST) -> TypeGuard[ast.Pass]:
@@ -447,11 +446,10 @@ class Be:
     @staticmethod
     def Try(node: ast.AST) -> TypeGuard[ast.Try]:
         return isinstance(node, ast.Try)
-    if sys.version_info >= (3, 11):
 
-        @staticmethod
-        def TryStar(node: ast.AST) -> TypeGuard[ast.TryStar]:
-            return isinstance(node, ast.TryStar)
+    @staticmethod
+    def TryStar(node: ast.AST) -> TypeGuard[ast.TryStar]:
+        return isinstance(node, ast.TryStar)
 
     @staticmethod
     def Tuple(node: ast.AST) -> TypeGuard[ast.Tuple]:
@@ -460,43 +458,39 @@ class Be:
     @staticmethod
     def type_ignore(node: ast.AST) -> TypeGuard[ast.type_ignore]:
         return isinstance(node, ast.type_ignore)
-    if sys.version_info >= (3, 12):
 
-        @staticmethod
-        def type_param(node: ast.AST) -> TypeGuard[ast.type_param]:
-            return isinstance(node, ast.type_param)
-    if sys.version_info >= (3, 12):
+    @staticmethod
+    def type_param(node: ast.AST) -> TypeGuard[ast.type_param]:
+        return isinstance(node, ast.type_param)
 
-        @staticmethod
-        def TypeAlias(node: ast.AST) -> TypeGuard[ast.TypeAlias]:
-            return isinstance(node, ast.TypeAlias)
+    @staticmethod
+    def TypeAlias(node: ast.AST) -> TypeGuard[ast.TypeAlias]:
+        return isinstance(node, ast.TypeAlias)
 
     @staticmethod
     def TypeIgnore(node: ast.AST) -> TypeGuard[ast.TypeIgnore]:
         return isinstance(node, ast.TypeIgnore)
-    if sys.version_info >= (3, 12):
 
-        @staticmethod
-        def TypeVar(node: ast.AST) -> TypeGuard[ast.TypeVar]:
-            return isinstance(node, ast.TypeVar)
-    if sys.version_info >= (3, 12):
+    @staticmethod
+    def TypeVar(node: ast.AST) -> TypeGuard[ast.TypeVar]:
+        return isinstance(node, ast.TypeVar)
 
-        @staticmethod
-        def TypeVarTuple(node: ast.AST) -> TypeGuard[ast.TypeVarTuple]:
-            return isinstance(node, ast.TypeVarTuple)
+    @staticmethod
+    def TypeVarTuple(node: ast.AST) -> TypeGuard[ast.TypeVarTuple]:
+        return isinstance(node, ast.TypeVarTuple)
 
     @staticmethod
     def UAdd(node: ast.AST) -> TypeGuard[ast.UAdd]:
         return isinstance(node, ast.UAdd)
 
-    @staticmethod
-    def UnaryOp(node: ast.AST) -> TypeGuard[ast.UnaryOp]:
-        return isinstance(node, ast.UnaryOp)
-
     @staticmethod
     def unaryop(node: ast.AST) -> TypeGuard[ast.unaryop]:
         return isinstance(node, ast.unaryop)
 
+    @staticmethod
+    def UnaryOp(node: ast.AST) -> TypeGuard[ast.UnaryOp]:
+        return isinstance(node, ast.UnaryOp)
+
     @staticmethod
     def USub(node: ast.AST) -> TypeGuard[ast.USub]:
         return isinstance(node, ast.USub)

{asttoolkit-0.2.3 → asttoolkit-0.3.0}/astToolkit/_toolClassIsAndAttribute.py

@@ -9,15 +9,15 @@ import ast
 class ClassIsAndAttribute:
     """
 	Create functions that verify AST nodes by type and attribute conditions.
-	
-	The ClassIsAndAttribute class provides static methods that generate conditional functions for determining if an AST 
-	node is of a specific type AND its attribute meets a specified condition. These functions return TypeGuard-enabled 
+
+	The ClassIsAndAttribute class provides static methods that generate conditional functions for determining if an AST
+	node is of a specific type AND its attribute meets a specified condition. These functions return TypeGuard-enabled
 	callables that can be used in conditional statements to narrow node types during code traversal and transformation.
-	
+
 	Each generated function performs two checks:
 	1. Verifies that the node is of the specified AST type
 	2. Tests if the specified attribute of the node meets a custom condition
-	
+
 	This enables complex filtering and targeting of AST nodes based on both their type and attribute contents.
 	"""
 
@@ -121,14 +121,13 @@ class ClassIsAndAttribute:
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTbody] | bool:
             return isinstance(node, astClass) and attributeCondition(node.body)
         return workhorse
-    if sys.version_info >= (3, 12):
 
-        @staticmethod
-        def boundIs(astClass: type[hasDOTbound], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTbound] | bool]:
+    @staticmethod
+    def boundIs(astClass: type[hasDOTbound], attributeCondition: Callable[[ast.expr | None], 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)
-            return workhorse
+        def workhorse(node: ast.AST) -> TypeGuard[hasDOTbound] | bool:
+            return isinstance(node, astClass) and node.bound is not None and attributeCondition(node.bound)
+        return workhorse
 
     @staticmethod
     def casesIs(astClass: type[hasDOTcases], attributeCondition: Callable[[list[ast.match_case]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTcases] | bool]:
@@ -413,12 +412,11 @@ class ClassIsAndAttribute:
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTmsg] | bool:
             return isinstance(node, astClass) and node.msg is not None and attributeCondition(node.msg)
         return workhorse
-    if sys.version_info >= (3, 12):
 
-        @staticmethod
-        @overload
-        def nameIs(astClass: type[hasDOTname_Name], attributeCondition: Callable[[ast.Name], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTname_Name] | bool]:
-            ...
+    @staticmethod
+    @overload
+    def nameIs(astClass: type[hasDOTname_Name], attributeCondition: Callable[[ast.Name], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTname_Name] | bool]:
+        ...
 
     @staticmethod
     @overload
@@ -429,22 +427,13 @@ class ClassIsAndAttribute:
     @overload
     def nameIs(astClass: type[hasDOTname_strOrNone], attributeCondition: Callable[[str | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTname_strOrNone] | bool]:
         ...
-    if sys.version_info >= (3, 12):
 
-        @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 workhorse(node: ast.AST) -> TypeGuard[hasDOTname] | bool:
-                return isinstance(node, astClass) and node.name is not None and attributeCondition(node.name)
-            return workhorse
-    else:
-
-        @staticmethod
-        def nameIs(astClass: type[hasDOTname], attributeCondition: Callable[[str], bool] | Callable[[str | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTname] | 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 workhorse(node: ast.AST) -> TypeGuard[hasDOTname] | bool:
-                return isinstance(node, astClass) and node.name is not None and attributeCondition(node.name)
-            return workhorse
+        def workhorse(node: ast.AST) -> TypeGuard[hasDOTname] | bool:
+            return isinstance(node, astClass) and node.name is not None and attributeCondition(node.name)
+        return workhorse
 
     @staticmethod
     @overload
@@ -676,14 +665,13 @@ class ClassIsAndAttribute:
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTtype_ignores] | bool:
             return isinstance(node, astClass) and attributeCondition(node.type_ignores)
         return workhorse
-    if sys.version_info >= (3, 12):
 
-        @staticmethod
-        def type_paramsIs(astClass: type[hasDOTtype_params], attributeCondition: Callable[[list[ast.type_param]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTtype_params] | bool]:
+    @staticmethod
+    def type_paramsIs(astClass: type[hasDOTtype_params], attributeCondition: Callable[[list[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)
-            return workhorse
+        def workhorse(node: ast.AST) -> TypeGuard[hasDOTtype_params] | bool:
+            return isinstance(node, astClass) and attributeCondition(node.type_params)
+        return workhorse
 
     @staticmethod
     def upperIs(astClass: type[hasDOTupper], attributeCondition: Callable[[ast.expr | None], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTupper] | bool]: