astToolkit 0.2.2__tar.gz → 0.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astToolkit
-Version: 0.2.2
+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.2 → 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.2 → 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 个,
@@ -22,8 +15,8 @@ from astToolkit._toolkitNodeVisitor import (
 )
 
 from astToolkit._toolBe import Be as Be
-from astToolkit._toolDOT import DOT as DOT
 from astToolkit._toolClassIsAndAttribute import ClassIsAndAttribute as ClassIsAndAttribute
+from astToolkit._toolDOT import DOT as DOT
 from astToolkit._toolGrab import Grab as Grab
 from astToolkit._toolMake import Make as Make
 

asttoolkit-0.3.0/astToolkit/_astTypes.py

@@ -0,0 +1,117 @@
+"""This file is generated automatically, so changes to this file will be lost."""
+from typing import Any, TypeAlias as typing_TypeAlias
+import ast
+import sys
+intORstr: typing_TypeAlias = Any
+intORstrORtype_params: typing_TypeAlias = Any
+intORtype_params: typing_TypeAlias = Any
+hasDOTannotation_expr: typing_TypeAlias = ast.AnnAssign
+hasDOTannotation_exprOrNone: typing_TypeAlias = ast.arg
+hasDOTannotation: typing_TypeAlias = hasDOTannotation_expr | hasDOTannotation_exprOrNone
+hasDOTarg_str: typing_TypeAlias = ast.arg
+hasDOTarg_strOrNone: typing_TypeAlias = ast.keyword
+hasDOTarg: typing_TypeAlias = hasDOTarg_str | hasDOTarg_strOrNone
+hasDOTargs_arguments: typing_TypeAlias = ast.AsyncFunctionDef | ast.FunctionDef | ast.Lambda
+hasDOTargs_list_arg: typing_TypeAlias = ast.arguments
+hasDOTargs_list_expr: typing_TypeAlias = ast.Call
+hasDOTargs: typing_TypeAlias = hasDOTargs_arguments | hasDOTargs_list_arg | hasDOTargs_list_expr
+hasDOTargtypes: typing_TypeAlias = ast.FunctionType
+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
+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
+hasDOTbound: typing_TypeAlias = ast.TypeVar
+hasDOTcases: typing_TypeAlias = ast.Match
+hasDOTcause: typing_TypeAlias = ast.Raise
+hasDOTcls: typing_TypeAlias = ast.MatchClass
+hasDOTcomparators: typing_TypeAlias = ast.Compare
+hasDOTcontext_expr: typing_TypeAlias = ast.withitem
+hasDOTconversion: typing_TypeAlias = ast.FormattedValue
+hasDOTctx: typing_TypeAlias = ast.Attribute | ast.List | ast.Name | ast.Starred | ast.Subscript | ast.Tuple
+hasDOTdecorator_list: typing_TypeAlias = ast.AsyncFunctionDef | ast.ClassDef | ast.FunctionDef
+if sys.version_info >= (3, 13):
+    hasDOTdefault_value: typing_TypeAlias = ast.ParamSpec | ast.TypeVar | ast.TypeVarTuple
+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
+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
+hasDOThandlers: typing_TypeAlias = ast.Try | ast.TryStar
+hasDOTid: typing_TypeAlias = ast.Name
+hasDOTifs: typing_TypeAlias = ast.comprehension
+hasDOTis_async: typing_TypeAlias = ast.comprehension
+hasDOTitems: typing_TypeAlias = ast.AsyncWith | ast.With
+hasDOTiter: typing_TypeAlias = ast.AsyncFor | ast.comprehension | ast.For
+hasDOTkey: typing_TypeAlias = ast.DictComp
+hasDOTkeys_list_expr: typing_TypeAlias = ast.MatchMapping
+hasDOTkeys_list_exprOrNone: typing_TypeAlias = ast.Dict
+hasDOTkeys: typing_TypeAlias = hasDOTkeys_list_expr | hasDOTkeys_list_exprOrNone
+hasDOTkeywords: typing_TypeAlias = ast.Call | ast.ClassDef
+hasDOTkind: typing_TypeAlias = ast.Constant
+hasDOTkw_defaults: typing_TypeAlias = ast.arguments
+hasDOTkwarg: typing_TypeAlias = ast.arguments
+hasDOTkwd_attrs: typing_TypeAlias = ast.MatchClass
+hasDOTkwd_patterns: typing_TypeAlias = ast.MatchClass
+hasDOTkwonlyargs: typing_TypeAlias = ast.arguments
+hasDOTleft: typing_TypeAlias = ast.BinOp | ast.Compare
+hasDOTlevel: typing_TypeAlias = ast.ImportFrom
+hasDOTlineno: typing_TypeAlias = ast.TypeIgnore
+hasDOTlower: typing_TypeAlias = ast.Slice
+hasDOTmodule: typing_TypeAlias = ast.ImportFrom
+hasDOTmsg: typing_TypeAlias = ast.Assert
+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
+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
+hasDOTop_boolop: typing_TypeAlias = ast.BoolOp
+hasDOTop_operator: typing_TypeAlias = ast.AugAssign | ast.BinOp
+hasDOTop_unaryop: typing_TypeAlias = ast.UnaryOp
+hasDOTop: typing_TypeAlias = hasDOTop_boolop | hasDOTop_operator | hasDOTop_unaryop
+hasDOToperand: typing_TypeAlias = ast.UnaryOp
+hasDOTops: typing_TypeAlias = ast.Compare
+hasDOToptional_vars: typing_TypeAlias = ast.withitem
+hasDOTorelse_expr: typing_TypeAlias = ast.IfExp
+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
+hasDOTpattern: typing_TypeAlias = hasDOTpattern_pattern | hasDOTpattern_patternOrNone
+hasDOTpatterns: typing_TypeAlias = ast.MatchClass | ast.MatchMapping | ast.MatchOr | ast.MatchSequence
+hasDOTposonlyargs: typing_TypeAlias = ast.arguments
+hasDOTrest: typing_TypeAlias = ast.MatchMapping
+hasDOTreturns_expr: typing_TypeAlias = ast.FunctionType
+hasDOTreturns_exprOrNone: typing_TypeAlias = ast.AsyncFunctionDef | ast.FunctionDef
+hasDOTreturns: typing_TypeAlias = hasDOTreturns_expr | hasDOTreturns_exprOrNone
+hasDOTright: typing_TypeAlias = ast.BinOp
+hasDOTsimple: typing_TypeAlias = ast.AnnAssign
+hasDOTslice: typing_TypeAlias = ast.Subscript
+hasDOTstep: typing_TypeAlias = ast.Slice
+hasDOTsubject: typing_TypeAlias = ast.Match
+hasDOTtag: typing_TypeAlias = ast.TypeIgnore
+hasDOTtarget_Name: typing_TypeAlias = ast.NamedExpr
+hasDOTtarget_NameOrAttributeOrSubscript: typing_TypeAlias = ast.AnnAssign | ast.AugAssign
+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
+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
+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
+hasDOTvararg: typing_TypeAlias = ast.arguments

{asttoolkit-0.2.2 → 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)