astToolkit 0.2.0__tar.gz → 0.2.1__tar.gz

{asttoolkit-0.2.0 → asttoolkit-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astToolkit
-Version: 0.2.0
+Version: 0.2.1
 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.2.0 → asttoolkit-0.2.1}/astToolkit/_toolBe.py

@@ -1,7 +1,7 @@
 """This file is generated automatically, so changes to this file will be lost."""
-from astToolkit import astDOTTryStar, astDOTParamSpec, astDOTtype_param, astDOTTypeAlias, astDOTTypeVar, astDOTTypeVarTuple
 from typing import TypeGuard
 import ast
+import sys
 
 class Be:
     """
@@ -159,14 +159,14 @@ 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 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)
@@ -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,10 +382,11 @@ 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[astDOTParamSpec]:
-        return isinstance(node, astDOTParamSpec)
+        @staticmethod
+        def ParamSpec(node: ast.AST) -> TypeGuard[ast.ParamSpec]:
+            return isinstance(node, ast.ParamSpec)
 
     @staticmethod
     def Pass(node: ast.AST) -> TypeGuard[ast.Pass]:
@@ -446,10 +447,11 @@ 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[astDOTTryStar]:
-        return isinstance(node, astDOTTryStar)
+        @staticmethod
+        def TryStar(node: ast.AST) -> TypeGuard[ast.TryStar]:
+            return isinstance(node, ast.TryStar)
 
     @staticmethod
     def Tuple(node: ast.AST) -> TypeGuard[ast.Tuple]:
@@ -458,26 +460,30 @@ 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[astDOTtype_param]:
-        return isinstance(node, astDOTtype_param)
+        @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 TypeAlias(node: ast.AST) -> TypeGuard[astDOTTypeAlias]:
-        return isinstance(node, astDOTTypeAlias)
+        @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[astDOTTypeVar]:
-        return isinstance(node, astDOTTypeVar)
+        @staticmethod
+        def TypeVar(node: ast.AST) -> TypeGuard[ast.TypeVar]:
+            return isinstance(node, ast.TypeVar)
+    if sys.version_info >= (3, 12):
 
-    @staticmethod
-    def TypeVarTuple(node: ast.AST) -> TypeGuard[astDOTTypeVarTuple]:
-        return isinstance(node, astDOTTypeVarTuple)
+        @staticmethod
+        def TypeVarTuple(node: ast.AST) -> TypeGuard[ast.TypeVarTuple]:
+            return isinstance(node, ast.TypeVarTuple)
 
     @staticmethod
     def UAdd(node: ast.AST) -> TypeGuard[ast.UAdd]:

{asttoolkit-0.2.0 → asttoolkit-0.2.1}/astToolkit/_types.py

@@ -4,12 +4,6 @@ import ast
 
 # TODO understand typing.
 
-# NOTE Prototype of an idea to subclass composable methods so that typing information
-# can extend beyond the top level of the ast node.
-# To cover all cases, quantity of necessary classes = sum of (for each class: for each attribute: attribute * number of valid types). If an attribute has type ast.expr, for example, then there are 27 valid types just for that attribute. There would be thousands of subclasses like ImaCallToName.
-# class ImaCallToName(ast.Call):
-# 	func: ast.Name 	# pyright: ignore[reportIncompatibleVariableOverride]
-
 # Type hints through TypeAlias or type "hints" through the identifier name.
 ast_expr_Slice: typing_TypeAlias = ast.expr
 ast_Identifier: typing_TypeAlias = str
@@ -35,3 +29,9 @@ Ima_ast_type_param: typing_TypeAlias = astDOTtype_param | astDOTParamSpec | astD
 Ima_ast_unaryop: typing_TypeAlias = ast.unaryop | ast.Invert | ast.Not | ast.UAdd | ast.USub
 
 Ima_ast_orphan = ast.alias | ast.arg | ast.arguments | ast.comprehension | ast.keyword | ast.match_case | ast.withitem
+
+# NOTE Prototype of an old idea to subclass composable methods so that typing information
+# can extend beyond the top level of the ast node.
+# To cover all cases, quantity of necessary classes = sum of (for each class: for each attribute: attribute * number of valid types). If an attribute has type ast.expr, for example, then there are 27 valid types just for that attribute. There would be thousands of subclasses like ImaCallToName.
+# class ImaCallToName(ast.Call):
+# 	func: ast.Name 	# pyright: ignore[reportIncompatibleVariableOverride]

{asttoolkit-0.2.0 → asttoolkit-0.2.1}/astToolkit/transformationTools.py

@@ -19,7 +19,7 @@ from collections.abc import Callable, Mapping
 from copy import deepcopy
 from os import PathLike
 from pathlib import PurePath
-from typing import Any, cast
+from typing import Any, cast, overload
 from Z0Z_tools import writeStringToHere
 import ast
 
@@ -191,6 +191,10 @@ def unparseFindReplace(astTree: 个, mappingFindReplaceNodes: Mapping[ast.AST, a
 			astTree = deepcopy(newTree)
 	return newTree
 
+# @overload
+# def write_astModule(astModule: ast.AST, pathFilename: PathLike[Any] | PurePath, packageName: ast_Identifier | None = None) -> None:...
+# @overload
+# def write_astModule(ingredients: IngredientsModule, pathFilename: PathLike[Any] | PurePath, packageName: ast_Identifier | None = None) -> None:...
 def write_astModule(ingredients: IngredientsModule, pathFilename: PathLike[Any] | PurePath, packageName: ast_Identifier | None = None) -> None:
 	"""
 	Convert an IngredientsModule to Python source code and write it to a file.
@@ -217,6 +221,8 @@ def write_astModule(ingredients: IngredientsModule, pathFilename: PathLike[Any]
 	Raises:
 		FREAKOUT: If the generated source code is empty.
 	"""
+	# if ingredients:
+	# 	astModule = Make.Module(ingredients.body, ingredients.type_ignores)
 	astModule = Make.Module(ingredients.body, ingredients.type_ignores)
 	ast.fix_missing_locations(astModule)
 	pythonSource: str = ast.unparse(astModule)

{asttoolkit-0.2.0 → asttoolkit-0.2.1}/astToolkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astToolkit
-Version: 0.2.0
+Version: 0.2.1
 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.2.0 → asttoolkit-0.2.1}/astToolkit.egg-info/SOURCES.txt

@@ -27,8 +27,11 @@ tests/test_basic.py
 toolFactory/Z0Z_hardcoded.py
 toolFactory/Z0Z_makeAstTools.py
 toolFactory/__init__.py
+toolFactory/_snippets.py
 toolFactory/astFactory.py
-toolFactory/astFactory_annex.py
+toolFactory/databaseASTCreation.py
+toolFactory/datacenter.py
 toolFactory/docstrings.py
-toolFactory/py.typed
-toolFactory/startHere.py
+toolFactory/factory3.py
+toolFactory/factory_annex.py
+toolFactory/py.typed

{asttoolkit-0.2.0 → asttoolkit-0.2.1}/pyproject.toml

@@ -36,7 +36,7 @@ optional-dependencies = { testing = [
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"
 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.2.0"
+version = "0.2.1"
 
 [tool.coverage]
 report = { exclude_lines = [

{asttoolkit-0.2.0 → asttoolkit-0.2.1}/toolFactory/Z0Z_hardcoded.py

@@ -1,17 +1,26 @@
 from pathlib import Path
 from typing import TypeAlias as typing_TypeAlias
+import ast
 
 ast_Identifier: typing_TypeAlias = str
-fileExtension: str = '.py'
+str_nameDOTname: typing_TypeAlias = str
+
+pythonVersionMinorMinimum: int = 10
+sys_version_infoMinimum: tuple[int, int] = (3, 10)
+sys_version_infoTarget: tuple[int, int] = (3, 13)
+
+class FREAKOUT(Exception): pass
+
+# filesystem and namespace ===============================================
 packageName: ast_Identifier = 'astToolkit'
+moduleIdentifierPrefix: str = '_tool'
+keywordArgumentsIdentifier: ast_Identifier = 'keywordArguments'
+
 pathRoot = Path('/apps') / packageName
 pathPackage = pathRoot / packageName
+pathToolFactory = pathRoot / 'toolFactory'
 pathTypeshed = pathRoot / 'typeshed' / 'stdlib'
-str_nameDOTname: typing_TypeAlias = str
-sys_version_infoMinimum: tuple[int, int] = (3, 10)
-sys_version_infoTarget: tuple[int, int] = (3, 13)
 
-listASTSubclasses: list[str] = ['_Slice', 'AST', 'binaryop', 'boolop', 'cmpop', 'excepthandler', 'expr_context', 'expr', 'mod', 'operator', 'pattern', 'stmt', 'type_ignore', 'type_param', 'unaryop',]
+pathFilenameDatabaseAST = pathToolFactory / 'databaseAST.csv'
 
-class FREAKOUT(Exception):
-	pass
+fileExtension: str = '.py'

{asttoolkit-0.2.0 → asttoolkit-0.2.1}/toolFactory/Z0Z_makeAstTools.py

@@ -1,6 +1,6 @@
 from collections.abc import Callable, Sequence
 import typeshed_client.finder
-from toolFactory import FREAKOUT, pathTypeshed, Z0Z_typesSpecial, makeTools
+from toolFactory import FREAKOUT, pathTypeshed, makeTools
 from pathlib import Path
 from typing import Any, TypeAlias as typing_TypeAlias, TypeVar as typing_TypeVar
 import ast

asttoolkit-0.2.1/toolFactory/__init__.py

@@ -0,0 +1,27 @@
+from toolFactory.Z0Z_hardcoded import (
+	ast_Identifier as ast_Identifier,
+	fileExtension as fileExtension,
+	FREAKOUT as FREAKOUT,
+	keywordArgumentsIdentifier as keywordArgumentsIdentifier,
+	moduleIdentifierPrefix as moduleIdentifierPrefix,
+	packageName as packageName,
+	pathFilenameDatabaseAST as pathFilenameDatabaseAST,
+	pathPackage as pathPackage,
+	pathTypeshed as pathTypeshed,
+	pythonVersionMinorMinimum as pythonVersionMinorMinimum,
+	str_nameDOTname as str_nameDOTname,
+	sys_version_infoMinimum as sys_version_infoMinimum,
+	sys_version_infoTarget as sys_version_infoTarget,
+)
+
+from toolFactory._snippets import (
+	astName_overload as astName_overload,
+	astName_staticmethod as astName_staticmethod,
+	astName_typing_TypeAlias as	astName_typing_TypeAlias,
+)
+
+from toolFactory.datacenter import (
+	getElementsBe as getElementsBe,
+	)
+
+from toolFactory.astFactory import makeTools as makeTools

asttoolkit-0.2.1/toolFactory/_snippets.py

@@ -0,0 +1,6 @@
+from typing import cast
+import ast
+
+astName_overload = ast.Name('overload')
+astName_staticmethod = ast.Name('staticmethod')
+astName_typing_TypeAlias: ast.expr = cast(ast.expr, ast.Name('typing_TypeAlias'))

{asttoolkit-0.2.0 → asttoolkit-0.2.1}/toolFactory/astFactory.py

@@ -1,7 +1,9 @@
 from pathlib import PurePosixPath
 from string import ascii_letters
-from toolFactory import ast_Identifier, fileExtension, list_astDOTnew, listASTSubclasses, pathPackage, str_nameDOTname, sys_version_infoTarget
-from toolFactory.astFactory_annex import (
+from toolFactory import ast_Identifier, fileExtension, pathPackage, str_nameDOTname, sys_version_infoTarget
+from toolFactory.Z0Z_hardcoded import keywordArgumentsIdentifier, moduleIdentifierPrefix
+from toolFactory._snippets import astName_overload, astName_staticmethod, astName_typing_TypeAlias
+from toolFactory.factory_annex import (
 	astImportFromClassNewInPythonVersion,
 	FunctionDefMake_Attribute,
 	handmadeMethodsGrab,
@@ -14,16 +16,20 @@ from typing import cast, TypedDict
 from Z0Z_tools import writeStringToHere
 import ast
 
+"""
+class Name(expr):
+...
+    ctx: expr_context  # Not present in Python < 3.13 if not passed to `__init__`
+
+TODO protect against AttributeError (I guess) in DOT, Grab, and ClassIsAndAttribute
+	add docstrings to warn of problem, including in Make
+
+"""
+
 class AnnotationsAndDefs(TypedDict):
 	astAnnotation: ast.expr
 	listClassDefIdentifier: list[ast_Identifier | str_nameDOTname]
 
-keywordArgumentsIdentifier: ast_Identifier = 'keywordArguments'
-moduleIdentifierPrefix: str = '_tool'
-overloadName = ast.Name('overload')
-staticmethodName = ast.Name('staticmethod')
-typing_TypeAliasName: ast.expr = cast(ast.expr, ast.Name('typing_TypeAlias'))
-
 class MakeDictionaryOf_astClassAnnotations(ast.NodeVisitor):
 	def __init__(self, astAST: ast.AST) -> None:
 		super().__init__()
@@ -36,10 +42,7 @@ class MakeDictionaryOf_astClassAnnotations(ast.NodeVisitor):
 		}
 
 	def visit_ClassDef(self, node: ast.ClassDef) -> None:
-		if 'astDOT' + node.name in list_astDOTnew:
-			NameOrAttribute: ast.Attribute | ast.Name = ast.Name('astDOT' + node.name)
-		else:
-			NameOrAttribute = ast.Attribute(value=ast.Name('ast'), attr=node.name)
+		NameOrAttribute = ast.Attribute(value=ast.Name('ast'), attr=node.name)
 		self.dictionarySubstitutions[node.name] = NameOrAttribute
 
 	def getDictionary(self) -> dict[ast_Identifier, ast.Attribute | ast.Name]:
@@ -110,7 +113,7 @@ def makeTools(astStubFile: ast.AST) -> None:
 
 	# Create each ClassDef and add directly to it instead of creating unnecessary intermediate structures, which requires more identifiers.
 	# fewer identifiers == fewer bugs
-	ClassDefBe = ast.ClassDef(name='Be', bases=[], keywords=[], body=[], decorator_list=[])
+	# ClassDefBe = ast.ClassDef(name='Be', bases=[], keywords=[], body=[], decorator_list=[])
 	ClassDefClassIsAndAttribute = ast.ClassDef(name='ClassIsAndAttribute', bases=[], keywords=[], body=[], decorator_list=[])
 	ClassDefDOT = ast.ClassDef(name='DOT', bases=[], keywords=[], body=[], decorator_list=[])
 	ClassDefMake = ast.ClassDef(name='Make', bases=[], keywords=[], body=[], decorator_list=[])
@@ -129,8 +132,6 @@ def makeTools(astStubFile: ast.AST) -> None:
 			continue
 		if node.name.startswith('_'):
 			continue
-		if not (node.name == 'AST' or (node.bases and isinstance(node.bases[0], ast.Name) and node.bases[0].id in listASTSubclasses)):
-			continue
 
 		# Change the identifier solely for the benefit of clarity as you read this code.
 		astDOTClassDef = node
@@ -143,11 +144,11 @@ def makeTools(astStubFile: ast.AST) -> None:
 		keywordArguments_ast_arg: ast.arg | None = ast.arg(keywordArgumentsIdentifier, ast.Name('int'))
 		keywordArguments_ast_keyword: ast.keyword | None = ast.keyword(None, ast.Name(keywordArgumentsIdentifier))
 
-		ClassDefBe.body.append(ast.FunctionDef(name=ClassDefIdentifier
-			, args=ast.arguments(posonlyargs=[], args=[ast.arg(arg='node', annotation=ast.Name('ast.AST'))], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[])
-			, body=[ast.Return(value=ast.Call(func=ast.Name('isinstance'), args=[ast.Name('node'), ClassDef_astNameOrAttribute], keywords=[]))]
-			, decorator_list=[staticmethodName]
-			, returns=ast.Subscript(value=ast.Name('TypeGuard'), slice=ClassDef_astNameOrAttribute)))
+		# ClassDefBe.body.append(ast.FunctionDef(name=ClassDefIdentifier
+		# 	, args=ast.arguments(posonlyargs=[], args=[ast.arg(arg='node', annotation=ast.Name('ast.AST'))], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[])
+		# 	, body=[ast.Return(value=ast.Call(func=ast.Name('isinstance'), args=[ast.Name('node'), ClassDef_astNameOrAttribute], keywords=[]))]
+		# 	, decorator_list=[astName_staticmethod]
+		# 	, returns=ast.Subscript(value=ast.Name('TypeGuard'), slice=ClassDef_astNameOrAttribute)))
 
 		# Start: cope with different arguments for Python versions. ==============================================================
 		# NOTE: I would love suggestions to improve this section.
@@ -164,7 +165,7 @@ def makeTools(astStubFile: ast.AST) -> None:
 				sys_version_info: tuple[int, int] = ast.literal_eval(subnode.test.comparators[0])
 				if sys_version_info > sys_version_infoTarget:
 					continue
-				if any(sys_version_info < key for key in dictAttributes.keys()): # pyright: ignore[reportOperatorIssue]
+				if any(sys_version_info < key for key in dictAttributes.keys()):
 					continue
 				dictAttributes[sys_version_info] = []
 				for astAST in subnode.body[0].value.elts:
@@ -204,7 +205,7 @@ def makeTools(astStubFile: ast.AST) -> None:
 		ClassDefMake.body.append(ast.FunctionDef(name=ClassDefIdentifier
 			, args=ast.arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=keywordArguments_ast_arg, defaults=[])
 			, body=[ast.Return(value=ast.Call(ClassDef_astNameOrAttribute, args=[], keywords=[keywordArguments_ast_keyword] if keywordArguments_ast_keyword else []))]
-			, decorator_list=[staticmethodName]
+			, decorator_list=[astName_staticmethod]
 			, returns=ClassDef_astNameOrAttribute))
 
 		for attributeIdentifier in list_astDOTClassDefAttributeIdentifier:
@@ -354,7 +355,7 @@ def makeTools(astStubFile: ast.AST) -> None:
 					cast(ast.FunctionDef, ClassDefMake.body[-1]).args.args.append(ast.arg(arg=attributeIdentifier, annotation=attributeAnnotation_ast_expr))
 					cast(ast.Call, cast(ast.Return, cast(ast.FunctionDef, ClassDefMake.body[-1]).body[0]).value).args.append(append2args)
 
-	ClassDefBe.body.sort(key=lambda astFunctionDef: cast(ast.FunctionDef, astFunctionDef).name.lower())
+	# ClassDefBe.body.sort(key=lambda astFunctionDef: cast(ast.FunctionDef, astFunctionDef).name.lower())
 	ClassDefMake.body.sort(key=lambda astFunctionDef: cast(ast.FunctionDef, astFunctionDef).name.lower())
 
 	astTypesModule = ast.Module(
@@ -395,10 +396,10 @@ def makeTools(astStubFile: ast.AST) -> None:
 				for ClassDefIdentifier in listClassDefIdentifier[1:]:
 					astAnnAssignValue = ast.BinOp(left=astAnnAssignValue, op=ast.BitOr(), right=dictionaryOf_astDOTclass[ClassDefIdentifier])
 			if len(attributeIdentifier2Str4TypeAlias2astAnnotationAndListClassDefIdentifier[attributeIdentifier]) == 1:
-				astTypesModule.body.append(ast.AnnAssign(hasDOTName_Store, typing_TypeAliasName, astAnnAssignValue, 1))
+				astTypesModule.body.append(ast.AnnAssign(hasDOTName_Store, astName_typing_TypeAlias, astAnnAssignValue, 1))
 			else:
 				list_hasDOTNameTypeAliasAnnotations.append(ast.Name(hasDOTIdentifier + '_' + attributeAnnotationAsStr4TypeAliasIdentifier.replace('list', 'list_'), ast.Store()))
-				astTypesModule.body.append(ast.AnnAssign(list_hasDOTNameTypeAliasAnnotations[-1], typing_TypeAliasName, astAnnAssignValue, 1))
+				astTypesModule.body.append(ast.AnnAssign(list_hasDOTNameTypeAliasAnnotations[-1], astName_typing_TypeAlias, astAnnAssignValue, 1))
 				# overload definitions for `ClassIsAndAttribute` class
 				potentiallySuperComplicatedAnnotationORbool = ast.Name('bool')
 				buffaloBuffalo_workhorse_returnsAnnotation = ast.BinOp(ast.Subscript(ast.Name('TypeGuard'), list_hasDOTNameTypeAliasAnnotations[-1]), ast.BitOr(), ast.Name('bool'))
@@ -408,14 +409,14 @@ def makeTools(astStubFile: ast.AST) -> None:
 							, ast.arg('attributeCondition', annotation=ast.Subscript(ast.Name('Callable'), ast.Tuple([ast.List([attributeAnnotationAsAST]), potentiallySuperComplicatedAnnotationORbool])))
 						], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[])
 					, body=[ast.Expr(value=ast.Constant(value=Ellipsis))]
-					, decorator_list=[staticmethodName, overloadName]
+					, decorator_list=[astName_staticmethod, astName_overload]
 					, returns=ast.Subscript(ast.Name('Callable'), ast.Tuple([ast.List([ast.Attribute(ast.Name('ast'), attr='AST')]), buffaloBuffalo_workhorse_returnsAnnotation]))
 				))
 				# overload definitions for `DOT` class
 				ClassDefDOT.body.append(ast.FunctionDef(name=attributeIdentifier
 					, args=ast.arguments(posonlyargs=[], args=[ast.arg(arg='node', annotation=ast.Name(list_hasDOTNameTypeAliasAnnotations[-1].id))], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[])
 					, body=[ast.Expr(value=ast.Constant(value=Ellipsis))]
-					, decorator_list=[staticmethodName, overloadName]
+					, decorator_list=[astName_staticmethod, astName_overload]
 					, returns=attributeAnnotationAsAST
 				))
 
@@ -449,14 +450,14 @@ def makeTools(astStubFile: ast.AST) -> None:
 							, body=[ast.Return(workhorseReturnValue)]
 							, returns=buffaloBuffalo_workhorse_returnsAnnotation)
 						, ast.Return(ast.Name('workhorse'))]
-				, decorator_list=[staticmethodName]
+				, decorator_list=[astName_staticmethod]
 				, returns=ast.Subscript(ast.Name('Callable'), ast.Tuple([ast.List([ast.Attribute(ast.Name('ast'), attr='AST')]), buffaloBuffalo_workhorse_returnsAnnotation]))
 			))
 
 		ClassDefDOT.body.append(ast.FunctionDef(name=attributeIdentifier
 				, args=ast.arguments(posonlyargs=[], args=[ast.arg(arg='node', annotation=hasDOTName_Load)], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[])
 				, body=[ast.Return(value=ast.Attribute(value=ast.Name('node'), attr=attributeIdentifier))]
-				, decorator_list=[staticmethodName]
+				, decorator_list=[astName_staticmethod]
 				, returns=attributeAnnotationUnifiedAsAST
 			))
 
@@ -465,7 +466,7 @@ def makeTools(astStubFile: ast.AST) -> None:
 			astAnnAssignValue = list_hasDOTNameTypeAliasAnnotations[0]
 			for index in range(1, len(list_hasDOTNameTypeAliasAnnotations)):
 				astAnnAssignValue = ast.BinOp(left=astAnnAssignValue, op=ast.BitOr(), right=list_hasDOTNameTypeAliasAnnotations[index])
-			astTypesModule.body.append(ast.AnnAssign(hasDOTName_Store, typing_TypeAliasName, astAnnAssignValue, 1))
+			astTypesModule.body.append(ast.AnnAssign(hasDOTName_Store, astName_typing_TypeAlias, astAnnAssignValue, 1))
 		astAssignValue = ast.Call(ast.Name('action'), args=[ast.Attribute(ast.Name('node'), attr=attributeIdentifier)])
 		if (isinstance(attributeAnnotationUnifiedAsAST, ast.Subscript) and isinstance(attributeAnnotationUnifiedAsAST.value, ast.Name) and attributeAnnotationUnifiedAsAST.value.id == 'Sequence'
 		or isinstance(attributeAnnotationUnifiedAsAST, ast.BinOp) and isinstance(attributeAnnotationUnifiedAsAST.right, ast.Subscript) and isinstance(attributeAnnotationUnifiedAsAST.right.value, ast.Name) and attributeAnnotationUnifiedAsAST.right.value.id == 'Sequence'):
@@ -486,32 +487,32 @@ def makeTools(astStubFile: ast.AST) -> None:
 						, ast.Return(ast.Name('node'))],
 						returns=hasDOTName_Load),
 			ast.Return(ast.Name('workhorse'))]
-			, decorator_list=[staticmethodName], type_comment=None
+			, decorator_list=[astName_staticmethod], type_comment=None
 			, returns=ast.Subscript(ast.Name('Callable'), ast.Tuple([ast.List([hasDOTName_Load]), hasDOTName_Load]))))
 
 		del attributeAnnotationUnifiedAsAST
 
 	writeModule(astTypesModule, '_astTypes')
 
-	ClassDefBe.body.insert(0, ast.Expr(value=ast.Constant(value=ClassDefDocstringBe)))
+	# ClassDefBe.body.insert(0, ast.Expr(value=ast.Constant(value=ClassDefDocstringBe)))
 	ClassDefDOT.body.insert(0, ast.Expr(value=ast.Constant(value=ClassDefDocstringDOT)))
 	ClassDefGrab.body.insert(0, ast.Expr(value=ast.Constant(value=ClassDefDocstringGrab)))
 	ClassDefMake.body.insert(0, ast.Expr(value=ast.Constant(value=ClassDefDocstringMake)))
 
 	ClassDefGrab.body.extend(handmadeMethodsGrab)
 
-	ClassDef = ClassDefBe
-	writeModule(ast.Module(
-		body=[ast.Expr(ast.Constant(docstringWarning))
-			, astImportFromClassNewInPythonVersion
-			, ast.ImportFrom('typing', [ast.alias('TypeGuard')], 0)
-			, ast.Import([ast.alias('ast')])
-			, ClassDef
-			],
-		type_ignores=[]
-		)
-		, moduleIdentifierPrefix + ClassDef.name)
-	del ClassDef
+	# ClassDef = ClassDefBe
+	# writeModule(ast.Module(
+	# 	body=[ast.Expr(ast.Constant(docstringWarning))
+	# 		, astImportFromClassNewInPythonVersion
+	# 		, ast.ImportFrom('typing', [ast.alias('TypeGuard')], 0)
+	# 		, ast.Import([ast.alias('ast')])
+	# 		, ClassDef
+	# 		],
+	# 	type_ignores=[]
+	# 	)
+	# 	, moduleIdentifierPrefix + ClassDef.name)
+	# del ClassDef
 
 	ClassDef = ClassDefClassIsAndAttribute
 	writeModule(ast.Module(