mapFolding 0.9.5__py3-none-any.whl → 0.11.0__py3-none-any.whl

mapFolding/someAssemblyRequired/transformationTools.py

@@ -18,19 +18,18 @@ readable, maintainable implementations to highly optimized versions while preser
 logical structure and correctness.
 """
 
-from autoflake import fix_code as autoflake_fix_code
+from astToolkit.transformationTools import ( inlineFunctionDef as inlineFunctionDef, removeUnusedParameters as removeUnusedParameters, write_astModule as write_astModule, )
 from collections.abc import Callable, Mapping
 from copy import deepcopy
 from mapFolding.beDRY import outfitCountFolds
 from mapFolding.someAssemblyRequired import (
 	ast_Identifier,
 	astModuleToIngredientsFunction,
-	be,
+	Be,
 	DeReConstructField2ast,
-	DOT,
 	extractClassDef,
-	grab,
-	ifThis,
+	Grab,
+	IfThis,
 	importLogicalPath2Callable,
 	IngredientsFunction,
 	IngredientsModule,
@@ -45,99 +44,14 @@ from mapFolding.someAssemblyRequired import (
 	Then,
 	个,
 )
-from mapFolding.theSSOT import ComputationState, raiseIfNoneGitHubIssueNumber3, The
-from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal, writeStringToHere
+from mapFolding.theSSOT import ComputationState, The
+from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal
 from os import PathLike
 from pathlib import Path, PurePath
 from typing import Any, Literal, overload
 import ast
 import dataclasses
 import pickle
-import python_minifier
-
-def makeDictionaryFunctionDef(module: ast.Module) -> dict[ast_Identifier, ast.FunctionDef]:
-	"""
-	Create a dictionary mapping function names to their AST definitions.
-
-	This function creates a dictionary that maps function names to their AST function
-	definition nodes for all functions defined in the given module.
-
-	Parameters:
-		module: The AST module to extract function definitions from.
-
-	Returns:
-		A dictionary mapping function identifiers to their AST function definition nodes.
-	"""
-	dictionaryIdentifier2FunctionDef: dict[ast_Identifier, ast.FunctionDef] = {}
-	NodeTourist(be.FunctionDef, Then.updateKeyValueIn(DOT.name, Then.extractIt, dictionaryIdentifier2FunctionDef)).visit(module)
-	return dictionaryIdentifier2FunctionDef
-
-def inlineFunctionDef(identifierToInline: ast_Identifier, module: ast.Module) -> ast.FunctionDef:
-	"""
-	Inline function calls within a function definition to create a self-contained function.
-
-	This function takes a function identifier and a module, finds the function definition,
-	and then recursively inlines all function calls within that function with their
-	implementation bodies. This produces a fully inlined function that doesn't depend
-	on other function definitions from the module.
-
-	Parameters:
-		identifierToInline: The name of the function to inline.
-		module: The AST module containing the function and its dependencies.
-
-	Returns:
-		A modified function definition with all function calls inlined.
-
-	Raises:
-		ValueError: If the function to inline is not found in the module.
-	"""
-	dictionaryFunctionDef: dict[ast_Identifier, ast.FunctionDef] = makeDictionaryFunctionDef(module)
-	try:
-		FunctionDefToInline = dictionaryFunctionDef[identifierToInline]
-	except KeyError as ERRORmessage:
-		raise ValueError(f"FunctionDefToInline not found in dictionaryIdentifier2FunctionDef: {identifierToInline = }") from ERRORmessage
-
-	listIdentifiersCalledFunctions: list[ast_Identifier] = []
-	findIdentifiersToInline = NodeTourist(findThis = ifThis.isCallToName, doThat = grab.funcDOTidAttribute(Then.appendTo(listIdentifiersCalledFunctions)))
-	findIdentifiersToInline.visit(FunctionDefToInline)
-
-	dictionary4Inlining: dict[ast_Identifier, ast.FunctionDef] = {}
-	for identifier in sorted(set(listIdentifiersCalledFunctions).intersection(dictionaryFunctionDef.keys())):
-		if NodeTourist(ifThis.matchesMeButNotAnyDescendant(ifThis.isCall_Identifier(identifier)), Then.extractIt).captureLastMatch(module) is not None:
-			dictionary4Inlining[identifier] = dictionaryFunctionDef[identifier]
-
-	keepGoing = True
-	while keepGoing:
-		keepGoing = False
-		listIdentifiersCalledFunctions.clear()
-		findIdentifiersToInline.visit(Make.Module(list(dictionary4Inlining.values())))
-
-		listIdentifiersCalledFunctions = sorted((set(listIdentifiersCalledFunctions).difference(dictionary4Inlining.keys())).intersection(dictionaryFunctionDef.keys()))
-		if len(listIdentifiersCalledFunctions) > 0:
-			keepGoing = True
-			for identifier in listIdentifiersCalledFunctions:
-				if NodeTourist(ifThis.matchesMeButNotAnyDescendant(ifThis.isCall_Identifier(identifier)), Then.extractIt).captureLastMatch(module) is not None:
-					FunctionDefTarget = dictionaryFunctionDef[identifier]
-					if len(FunctionDefTarget.body) == 1:
-						replacement = NodeTourist(be.Return, Then.extractIt(DOT.value)).captureLastMatch(FunctionDefTarget)
-						inliner = NodeChanger(ifThis.isCall_Identifier(identifier), Then.replaceWith(replacement))
-						for astFunctionDef in dictionary4Inlining.values():
-							inliner.visit(astFunctionDef)
-					else:
-						inliner = NodeChanger(ifThis.isAssignAndValueIs(ifThis.isCall_Identifier(identifier)),Then.replaceWith(FunctionDefTarget.body[0:-1]))
-						for astFunctionDef in dictionary4Inlining.values():
-							inliner.visit(astFunctionDef)
-
-	for identifier, FunctionDefTarget in dictionary4Inlining.items():
-		if len(FunctionDefTarget.body) == 1:
-			replacement = NodeTourist(be.Return, Then.extractIt(DOT.value)).captureLastMatch(FunctionDefTarget)
-			inliner = NodeChanger(ifThis.isCall_Identifier(identifier), Then.replaceWith(replacement))
-			inliner.visit(FunctionDefToInline)
-		else:
-			inliner = NodeChanger(ifThis.isAssignAndValueIs(ifThis.isCall_Identifier(identifier)),Then.replaceWith(FunctionDefTarget.body[0:-1]))
-			inliner.visit(FunctionDefToInline)
-	ast.fix_missing_locations(FunctionDefToInline)
-	return FunctionDefToInline
 
 @overload
 def makeInitializedComputationState(mapShape: tuple[int, ...], writeJob: Literal[True], *,  pathFilename: PathLike[str] | PurePath | None = None, **keywordArguments: Any) -> Path: ...
@@ -237,7 +151,7 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, dataclas
 		map_stateDOTfield2Name={dictionaryDeReConstruction[field].ast_nameDOTname: dictionaryDeReConstruction[field].astName for field in Official_fieldOrder},
 		)
 	shatteredDataclass.fragments4AssignmentOrParameters = Make.Tuple(shatteredDataclass.listName4Parameters, ast.Store())
-	shatteredDataclass.repack = Make.Assign(listTargets=[Make.Name(instance_Identifier)], value=Make.Call(Make.Name(dataclass_Identifier), list_astKeywords=shatteredDataclass.list_keyword_field__field4init))
+	shatteredDataclass.repack = Make.Assign([Make.Name(instance_Identifier)], value=Make.Call(Make.Name(dataclass_Identifier), list_keyword=shatteredDataclass.list_keyword_field__field4init))
 	shatteredDataclass.signatureReturnAnnotation = Make.Subscript(Make.Name('tuple'), Make.Tuple(shatteredDataclass.listAnnotations))
 
 	shatteredDataclass.imports.update(*(dictionaryDeReConstruction[field].ledger for field in Official_fieldOrder))
@@ -245,91 +159,7 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, dataclas
 
 	return shatteredDataclass
 
-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.
-
-	This function renders an IngredientsModule into executable Python code,
-	applies code quality improvements like import organization via autoflake,
-	and writes the result to the specified file path.
-
-	The function performs several key steps:
-	1. Converts the AST module structure to a valid Python AST
-	2. Fixes location attributes in the AST for proper formatting
-	3. Converts the AST to Python source code
-	4. Optimizes imports using autoflake
-	5. Writes the final source code to the specified file location
-
-	This is typically the final step in the code generation assembly line,
-	producing optimized Python modules ready for execution.
-
-	Parameters:
-		ingredients: The IngredientsModule containing the module definition.
-		pathFilename: The file path where the module should be written.
-		packageName: Optional package name to preserve in import optimization.
-
-	Raises:
-		raiseIfNoneGitHubIssueNumber3: If the generated source code is empty.
-	"""
-	astModule = Make.Module(ingredients.body, ingredients.type_ignores)
-	ast.fix_missing_locations(astModule)
-	pythonSource: str = ast.unparse(astModule)
-	if not pythonSource: raise raiseIfNoneGitHubIssueNumber3
-	autoflake_additional_imports: list[str] = ingredients.imports.exportListModuleIdentifiers()
-	if packageName:
-		autoflake_additional_imports.append(packageName)
-	pythonSource = autoflake_fix_code(pythonSource, autoflake_additional_imports, expand_star_imports=False, remove_all_unused_imports=True, remove_duplicate_keys = False, remove_unused_variables = False)
-	# pythonSource = python_minifier.minify(pythonSource, remove_annotations=False, hoist_literals=False)
-	writeStringToHere(pythonSource, pathFilename)
-
 # END of acceptable classes and functions ======================================================
-def removeUnusedParameters(ingredientsFunction: IngredientsFunction) -> IngredientsFunction:
-	"""
-	Removes unused parameters from a function's AST definition, return statement, and annotation.
-
-	This function analyzes the Abstract Syntax Tree (AST) of a given function and removes
-	any parameters that are not referenced within the function body. It updates the
-	function signature, the return statement (if it's a tuple containing unused variables),
-	and the return type annotation accordingly.
-
-	Parameters
-	----------
-	ingredientsFunction : IngredientsFunction
-		An object containing the AST representation of a function to be processed.
-
-	Returns
-	-------
-	IngredientsFunction
-		The modified IngredientsFunction object with unused parameters and corresponding
-		return elements/annotations removed from its AST.
-
-	The modification is done in-place on the original AST nodes within the IngredientsFunction object.
-	"""
-	list_argCuzMyBrainRefusesToThink = ingredientsFunction.astFunctionDef.args.args + ingredientsFunction.astFunctionDef.args.posonlyargs + ingredientsFunction.astFunctionDef.args.kwonlyargs
-	list_arg_arg: list[ast_Identifier] = [ast_arg.arg for ast_arg in list_argCuzMyBrainRefusesToThink]
-	listName: list[ast.Name] = []
-	fauxFunctionDef = deepcopy(ingredientsFunction.astFunctionDef)
-	NodeChanger(be.Return, Then.removeIt).visit(fauxFunctionDef)
-	NodeTourist(be.Name, Then.appendTo(listName)).visit(fauxFunctionDef)
-	list_Identifiers: list[ast_Identifier] = [astName.id for astName in listName]
-	list_IdentifiersNotUsed: list[ast_Identifier] = list(set(list_arg_arg) - set(list_Identifiers))
-	for arg_Identifier in list_IdentifiersNotUsed:
-		remove_arg = NodeChanger(ifThis.is_arg_Identifier(arg_Identifier), Then.removeIt)
-		remove_arg.visit(ingredientsFunction.astFunctionDef)
-
-	list_argCuzMyBrainRefusesToThink = ingredientsFunction.astFunctionDef.args.args + ingredientsFunction.astFunctionDef.args.posonlyargs + ingredientsFunction.astFunctionDef.args.kwonlyargs
-
-	listName: list[ast.Name] = [Make.Name(ast_arg.arg) for ast_arg in list_argCuzMyBrainRefusesToThink]
-	replaceReturn = NodeChanger(be.Return, Then.replaceWith(Make.Return(Make.Tuple(listName))))
-	replaceReturn.visit(ingredientsFunction.astFunctionDef)
-
-	list_annotation: list[ast.expr] = [ast_arg.annotation for ast_arg in list_argCuzMyBrainRefusesToThink if ast_arg.annotation is not None]
-	ingredientsFunction.astFunctionDef.returns = Make.Subscript(Make.Name('tuple'), Make.Tuple(list_annotation))
-
-	ast.fix_missing_locations(ingredientsFunction.astFunctionDef)
-
-	return ingredientsFunction
-
 def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
 	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
 	listAllIngredientsFunctions = [
@@ -356,7 +186,7 @@ def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
 						(recipeFlow.sourceCallableSequential, recipeFlow.callableSequential),]
 	for ingredients in listAllIngredientsFunctions:
 		for source_Identifier, recipe_Identifier in listFindReplace:
-			updateCallName = NodeChanger(ifThis.isCall_Identifier(source_Identifier), grab.funcAttribute(Then.replaceWith(Make.Name(recipe_Identifier))))
+			updateCallName = NodeChanger(IfThis.isCall_Identifier(source_Identifier), Grab.funcAttribute(Then.replaceWith(Make.Name(recipe_Identifier))))
 			updateCallName.visit(ingredients.astFunctionDef)
 
 	ingredientsDispatcher.astFunctionDef.name = recipeFlow.callableDispatcher
@@ -370,13 +200,13 @@ def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
 		(recipeFlow.sourceConcurrencyManagerNamespace, recipeFlow.concurrencyManagerNamespace),]
 	for ingredients in listAllIngredientsFunctions:
 		for source_Identifier, recipe_Identifier in listFindReplace:
-			updateName = NodeChanger(ifThis.isName_Identifier(source_Identifier) , grab.idAttribute(Then.replaceWith(recipe_Identifier)))
-			update_arg = NodeChanger(ifThis.isArgument_Identifier(source_Identifier), grab.argAttribute(Then.replaceWith(recipe_Identifier))) # type: ignore
+			updateName = NodeChanger(IfThis.isName_Identifier(source_Identifier) , Grab.idAttribute(Then.replaceWith(recipe_Identifier)))
+			update_arg = NodeChanger(IfThis.isArgument_Identifier(source_Identifier), Grab.argAttribute(Then.replaceWith(recipe_Identifier)))
 			updateName.visit(ingredients.astFunctionDef)
 			update_arg.visit(ingredients.astFunctionDef)
 
-	updateConcurrencyManager = NodeChanger(ifThis.isCallAttributeNamespace_Identifier(recipeFlow.sourceConcurrencyManagerNamespace, recipeFlow.sourceConcurrencyManagerIdentifier)
-										, grab.funcAttribute(Then.replaceWith(Make.Attribute(Make.Name(recipeFlow.concurrencyManagerNamespace), recipeFlow.concurrencyManagerIdentifier))))
+	updateConcurrencyManager = NodeChanger(IfThis.isCallAttributeNamespace_Identifier(recipeFlow.sourceConcurrencyManagerNamespace, recipeFlow.sourceConcurrencyManagerIdentifier)
+										, Grab.funcAttribute(Then.replaceWith(Make.Attribute(Make.Name(recipeFlow.concurrencyManagerNamespace), recipeFlow.concurrencyManagerIdentifier))))
 	updateConcurrencyManager.visit(ingredientsDispatcher.astFunctionDef)
 
 	# shatter Dataclass =======================================================
@@ -398,7 +228,7 @@ def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
 
 	# parallelCallable =========================================================
 	if recipeFlow.removeDataclassParallel:
-		ingredientsParallel.astFunctionDef.args = Make.argumentsSpecification(args=shatteredDataclass.list_argAnnotated4ArgumentsSpecification)
+		ingredientsParallel.astFunctionDef.args = Make.arguments(args=shatteredDataclass.list_argAnnotated4ArgumentsSpecification)
 
 		ingredientsParallel.astFunctionDef = Z0Z_lameFindReplace(ingredientsParallel.astFunctionDef, shatteredDataclass.map_stateDOTfield2Name)
 
@@ -409,25 +239,25 @@ def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
 
 		listParameters = [parameter for parameter in shatteredDataclass.listName4Parameters if parameter.id in list_arg_arg]
 
-		replaceCall2concurrencyManager = NodeChanger(ifThis.isCallAttributeNamespace_Identifier(recipeFlow.concurrencyManagerNamespace, recipeFlow.concurrencyManagerIdentifier), Then.replaceWith(Make.Call(Make.Attribute(Make.Name(recipeFlow.concurrencyManagerNamespace), recipeFlow.concurrencyManagerIdentifier), listArguments=[Make.Name(recipeFlow.callableParallel)] + listParameters)))
+		replaceCall2concurrencyManager = NodeChanger(IfThis.isCallAttributeNamespace_Identifier(recipeFlow.concurrencyManagerNamespace, recipeFlow.concurrencyManagerIdentifier), Then.replaceWith(Make.Call(Make.Attribute(Make.Name(recipeFlow.concurrencyManagerNamespace), recipeFlow.concurrencyManagerIdentifier), [Make.Name(recipeFlow.callableParallel)] + listParameters)))
 
 		def getIt(astCallConcurrencyResult: list[ast.Call]) -> Callable[[ast.AST], ast.AST]:
 			# TODO I cannot remember why I made this function. It doesn't fit with how I normally do things.
 			def workhorse(node: ast.AST) -> ast.AST:
-				NodeTourist(be.Call, Then.appendTo(astCallConcurrencyResult)).visit(node)
+				NodeTourist(Be.Call, Then.appendTo(astCallConcurrencyResult)).visit(node)
 				return node
 			return workhorse
 
 		# NOTE I am dissatisfied with this logic for many reasons, including that it requires separate NodeCollector and NodeReplacer instances.
 		astCallConcurrencyResult: list[ast.Call] = []
-		get_astCallConcurrencyResult = NodeTourist(ifThis.isAssignAndTargets0Is(ifThis.isSubscript_Identifier(getTheOtherRecord_damn)), getIt(astCallConcurrencyResult))
+		get_astCallConcurrencyResult = NodeTourist(IfThis.isAssignAndTargets0Is(IfThis.isSubscript_Identifier(getTheOtherRecord_damn)), getIt(astCallConcurrencyResult))
 		get_astCallConcurrencyResult.visit(ingredientsDispatcher.astFunctionDef)
-		replaceAssignParallelCallable = NodeChanger(ifThis.isAssignAndTargets0Is(ifThis.isSubscript_Identifier(getTheOtherRecord_damn)), grab.valueAttribute(Then.replaceWith(astCallConcurrencyResult[0])))
+		replaceAssignParallelCallable = NodeChanger(IfThis.isAssignAndTargets0Is(IfThis.isSubscript_Identifier(getTheOtherRecord_damn)), Grab.valueAttribute(Then.replaceWith(astCallConcurrencyResult[0])))
 		replaceAssignParallelCallable.visit(ingredientsDispatcher.astFunctionDef)
-		changeReturnParallelCallable = NodeChanger(be.Return, Then.replaceWith(Make.Return(shatteredDataclass.countingVariableName)))
+		changeReturnParallelCallable = NodeChanger(Be.Return, Then.replaceWith(Make.Return(shatteredDataclass.countingVariableName)))
 		ingredientsParallel.astFunctionDef.returns = shatteredDataclass.countingVariableAnnotation
 
-		unpack4parallelCallable = NodeChanger(ifThis.isAssignAndValueIs(ifThis.isCallAttributeNamespace_Identifier(recipeFlow.concurrencyManagerNamespace, recipeFlow.concurrencyManagerIdentifier)), Then.insertThisAbove(shatteredDataclass.listUnpack))
+		unpack4parallelCallable = NodeChanger(IfThis.isAssignAndValueIs(IfThis.isCallAttributeNamespace_Identifier(recipeFlow.concurrencyManagerNamespace, recipeFlow.concurrencyManagerIdentifier)), Then.insertThisAbove(shatteredDataclass.listUnpack))
 
 		unpack4parallelCallable.visit(ingredientsDispatcher.astFunctionDef)
 		replaceCall2concurrencyManager.visit(ingredientsDispatcher.astFunctionDef)
@@ -440,18 +270,18 @@ def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
 	return ingredientsModuleNumbaUnified
 
 def removeDataclassFromFunction(ingredientsTarget: IngredientsFunction, shatteredDataclass: ShatteredDataclass) -> IngredientsFunction:
-	ingredientsTarget.astFunctionDef.args = Make.argumentsSpecification(args=shatteredDataclass.list_argAnnotated4ArgumentsSpecification)
+	ingredientsTarget.astFunctionDef.args = Make.arguments(args=shatteredDataclass.list_argAnnotated4ArgumentsSpecification)
 	ingredientsTarget.astFunctionDef.returns = shatteredDataclass.signatureReturnAnnotation
-	changeReturnCallable = NodeChanger(be.Return, Then.replaceWith(Make.Return(shatteredDataclass.fragments4AssignmentOrParameters)))
+	changeReturnCallable = NodeChanger(Be.Return, Then.replaceWith(Make.Return(shatteredDataclass.fragments4AssignmentOrParameters)))
 	changeReturnCallable.visit(ingredientsTarget.astFunctionDef)
 	ingredientsTarget.astFunctionDef = Z0Z_lameFindReplace(ingredientsTarget.astFunctionDef, shatteredDataclass.map_stateDOTfield2Name)
 	return ingredientsTarget
 
 def unpackDataclassCallFunctionRepackDataclass(ingredientsCaller: IngredientsFunction, targetCallableIdentifier: ast_Identifier, shatteredDataclass: ShatteredDataclass) -> IngredientsFunction:
 	astCallTargetCallable = Make.Call(Make.Name(targetCallableIdentifier), shatteredDataclass.listName4Parameters)
-	replaceAssignTargetCallable = NodeChanger(ifThis.isAssignAndValueIs(ifThis.isCall_Identifier(targetCallableIdentifier)), Then.replaceWith(Make.Assign(listTargets=[shatteredDataclass.fragments4AssignmentOrParameters], value=astCallTargetCallable)))
-	unpack4targetCallable = NodeChanger(ifThis.isAssignAndValueIs(ifThis.isCall_Identifier(targetCallableIdentifier)), Then.insertThisAbove(shatteredDataclass.listUnpack))
-	repack4targetCallable = NodeChanger(ifThis.isAssignAndValueIs(ifThis.isCall_Identifier(targetCallableIdentifier)), Then.insertThisBelow([shatteredDataclass.repack]))
+	replaceAssignTargetCallable = NodeChanger(IfThis.isAssignAndValueIs(IfThis.isCall_Identifier(targetCallableIdentifier)), Then.replaceWith(Make.Assign([shatteredDataclass.fragments4AssignmentOrParameters], value=astCallTargetCallable)))
+	unpack4targetCallable = NodeChanger(IfThis.isAssignAndValueIs(IfThis.isCall_Identifier(targetCallableIdentifier)), Then.insertThisAbove(shatteredDataclass.listUnpack))
+	repack4targetCallable = NodeChanger(IfThis.isAssignAndValueIs(IfThis.isCall_Identifier(targetCallableIdentifier)), Then.insertThisBelow([shatteredDataclass.repack]))
 	replaceAssignTargetCallable.visit(ingredientsCaller.astFunctionDef)
 	unpack4targetCallable.visit(ingredientsCaller.astFunctionDef)
 	repack4targetCallable.visit(ingredientsCaller.astFunctionDef)
@@ -491,7 +321,7 @@ def Z0Z_lameFindReplace(astTree: 个, mappingFindReplaceNodes: Mapping[ast.AST,
 
 	while keepGoing:
 		for nodeFind, nodeReplace in mappingFindReplaceNodes.items():
-			NodeChanger(ifThis.Z0Z_unparseIs(nodeFind), Then.replaceWith(nodeReplace)).visit(newTree)
+			NodeChanger(IfThis.unparseIs(nodeFind), Then.replaceWith(nodeReplace)).visit(newTree)
 
 		if ast.unparse(newTree) == ast.unparse(astTree):
 			keepGoing = False

{mapfolding-0.9.5.dist-info → mapfolding-0.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.9.5
+Version: 0.11.0
 Summary: Map folding algorithm with code transformation framework for optimizing numerical computations
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -31,6 +31,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: astToolkit
 Requires-Dist: autoflake
 Requires-Dist: cytoolz
 Requires-Dist: more_itertools
@@ -41,6 +42,7 @@ Requires-Dist: platformdirs
 Requires-Dist: python_minifier
 Requires-Dist: sympy
 Requires-Dist: tomli
+Requires-Dist: typeshed_client
 Requires-Dist: Z0Z_tools
 Provides-Extra: testing
 Requires-Dist: mypy; extra == "testing"

{mapfolding-0.9.5.dist-info → mapfolding-0.11.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-mapFolding/__init__.py,sha256=vIUZ4w4Hr12xPhSXIrnoG7-jg59VeEl5KbaOfmMRjTA,5403
+mapFolding/__init__.py,sha256=B_Z9mhM5c_ro4rDOkIGADeg7tec8dkuY5UDp0JjjR4M,5456
 mapFolding/basecamp.py,sha256=hs7hlTmbX7KTjI_eIRVU4xn7HR4l448SIpHk1cKDwRk,8071
 mapFolding/beDRY.py,sha256=JQ7T9v4aKzweGjvpzyghyq4N9l3Wf9HZco_K_DWoiW0,15368
 mapFolding/daoOfMapFolding.py,sha256=ncTIiBfTsM8SNVx9qefZ0bBcBtviWLSk4iPv3Z9nGiE,5442
@@ -22,20 +22,15 @@ mapFolding/reference/jobsCompleted/__init__.py,sha256=TU93ZGUW1xEkT6d9mQFn_rp5Dv
 mapFolding/reference/jobsCompleted/[2x19]/p2x19.py,sha256=_tvYtfzMWVo2VtUbIAieoscb4N8FFflgTdW4-ljBUuA,19626
 mapFolding/reference/jobsCompleted/p2x19/p2x19.py,sha256=eZEw4Me4ocTt6VXoK2-Sbd5SowZtxRIbN9dZmc7OCVg,6395
 mapFolding/someAssemblyRequired/RecipeJob.py,sha256=6RD4F4Yde7K-Rz0F4IokQ62BVzRSx4vCCYY4H-Dfug4,10190
-mapFolding/someAssemblyRequired/Z0Z_makeSomeModules.py,sha256=ctR-0wwGpDSHfa7pF4dhJwbWzptADWb4m6AQeN9KabA,15677
-mapFolding/someAssemblyRequired/__init__.py,sha256=fIdXu8UVLp2ccGdaQO41qmlfa87tWRgevGJH2xSdUkY,4570
-mapFolding/someAssemblyRequired/_theTypes.py,sha256=CUw-8_6tyOU6q3r_Fe5PQsvRdw04LQ2bDuTg1X1XRtk,5002
-mapFolding/someAssemblyRequired/_tool_Make.py,sha256=Ou2EGtMe1SCv_v_s0tEMVz_VlXgGhyk9nZxipQ5Ez_0,7651
-mapFolding/someAssemblyRequired/_tool_Then.py,sha256=8gdAQ7NPHzS6Q_NERbjzA3JtyO2N62jOmiDOx9Tq1l8,6168
-mapFolding/someAssemblyRequired/_toolboxAST.py,sha256=Wm0XUqqxKbwu1kIQ1F6iXEP2z25qmr1JsZ2CeWMBtLg,2376
-mapFolding/someAssemblyRequired/_toolboxAntecedents.py,sha256=i1jOdK1nJlA0blbVlCWJf-CeHyPgUf7QMQSFm1BrhQ8,16682
-mapFolding/someAssemblyRequired/_toolboxContainers.py,sha256=Qtf1vGPIYQ9g2bOiupkm_-T4Qsr7p14SSI9eXcmT54M,30125
-mapFolding/someAssemblyRequired/_toolboxPython.py,sha256=1K7IzqzmHNTaPA6qTo73GZYHCIQRYI2Rn8aYJ3VelqY,7873
+mapFolding/someAssemblyRequired/Z0Z_makeSomeModules.py,sha256=Zx79EU4FTvnquAJMHr_rY1mzsyBsHEaeuu0LHRIFFSc,15804
+mapFolding/someAssemblyRequired/__init__.py,sha256=GpYUilSfkAfITY-yJ2najnIlDGY4w0m706wrrOlhDmE,3397
+mapFolding/someAssemblyRequired/_toolIfThis.py,sha256=IoCmO4vs4ElMPW7_ToPhWWnywCCzy0WZTSjcGD4kxZQ,2809
+mapFolding/someAssemblyRequired/_toolboxContainers.py,sha256=83unP2rX8kJ_xSnPcZ3bJ8eanNQHwy0jLb9OP3cz5Gw,15872
 mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=9RPU6vK_eUg64GtVFI_nZnvUryXw8gfHJs9NyDYHIvg,2745
-mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py,sha256=rVsBWkRr9biR_kMRwkn8z4gGHu3hKwigZ-WoSC1nkEA,13830
-mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=bhCCEBEPco2gwaaieH3SADZnFyQBrvBYOzZs9-cyXAs,15597
-mapFolding/someAssemblyRequired/toolboxNumba.py,sha256=MkVmX844CDnEpodY5sasAYjK4gBbO9icoRhvX241Ipc,8965
-mapFolding/someAssemblyRequired/transformationTools.py,sha256=UikTtBxW2LfGpMiOirDUB928V-OcHPTXsO1KTxAL1O0,29326
+mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py,sha256=7lF-5XLWrxbIukSClkkzjeSl8xBaot9Hg_4QrQ3UNe4,13846
+mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=nnTBe9XBFCNYKw-m_ZLAqfjHI9YEgAYx0rcUbihmG1Q,15667
+mapFolding/someAssemblyRequired/toolboxNumba.py,sha256=QIpYCf1IFfgrQ5GVA0ON0ymn324iBfkyHVSfBW5CqOY,8961
+mapFolding/someAssemblyRequired/transformationTools.py,sha256=snv0RB2Lfp50hIDL6BL7RVg3_gPkpQ2PPZF7-ldS7fI,20414
 mapFolding/syntheticModules/__init__.py,sha256=evVFqhCGa-WZKDiLcnQWjs-Bj34eRnfSLqz_d7dFYZY,83
 mapFolding/syntheticModules/daoOfMapFolding.py,sha256=cfWPABtXyCxJ0BwPI7rhfLh_2UYV_XKAL8lJ4GLNXaQ,5896
 mapFolding/syntheticModules/dataPacking.py,sha256=J4WLJzQTOAm2d8itzWWSixTUcCGQl4KuEfqrzkb2tJQ,2294
@@ -44,7 +39,7 @@ mapFolding/syntheticModules/numbaCount.py,sha256=zM-bp07c9tEDdvidwzZ_bJTd0JC0VUk
 mapFolding/syntheticModules/theorem2.py,sha256=9jrbZNNX4BWYZW1S0JjvRY2k7RU7I1RNUMV7JdCt1ZY,3017
 mapFolding/syntheticModules/theorem2Numba.py,sha256=-cKjNyxgUMFhEyFVs0VJ7hw4LfrV0WSNK5tPYbQ1oNU,3369
 mapFolding/syntheticModules/theorem2Trimmed.py,sha256=DHW3NxBdtABQYBKm2WRvfQ5kzc2_UwGI2h4ePuYEJoM,2685
-mapfolding-0.9.5.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+mapfolding-0.11.0.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
 tests/__init__.py,sha256=5VhHf0JJ2_DSh58zJ0rR5UkpoCon-0IkdljspTCzZ04,1950
 tests/conftest.py,sha256=x8zMZQyTss3sn0GwHm_TSRwD9_LVlR8l_qF8r43Vxl4,14178
 tests/test_computations.py,sha256=5sg1PpSp6aeOrXZeO5NwWK5ipPAe49wVKC2J7yT5MFg,6524
@@ -52,8 +47,8 @@ tests/test_filesystem.py,sha256=T2DkjBoI3lW6tCxd5BilPmUFrVukNKLjOOZVZxLM560,3004
 tests/test_oeis.py,sha256=uxvwmgbnylSDdsVJfuAT0LuYLbIVFwSgdLxHm-xUGBM,5043
 tests/test_other.py,sha256=UMlK4JPInalpOZuPvTnUrgXWCJOxAw-OsPs6CxMR254,3753
 tests/test_tasks.py,sha256=tOQc4uomKXGwWnENfbcThaVa1XofwXNCkGZbg4yS6VI,2833
-mapfolding-0.9.5.dist-info/METADATA,sha256=Wxvk-PufaaR_0jvSlJjgBYKoEzZi15KtZipJdP7XOAE,7502
-mapfolding-0.9.5.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-mapfolding-0.9.5.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapfolding-0.9.5.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapfolding-0.9.5.dist-info/RECORD,,
+mapfolding-0.11.0.dist-info/METADATA,sha256=8Blxgr_WJnTxgtvXDTLjxM-hh5c6GRhpig0B9za32Dg,7560
+mapfolding-0.11.0.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
+mapfolding-0.11.0.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapfolding-0.11.0.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapfolding-0.11.0.dist-info/RECORD,,

{mapfolding-0.9.5.dist-info → mapfolding-0.11.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.0)
+Generator: setuptools (80.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

mapFolding/someAssemblyRequired/_theTypes.py

@@ -1,57 +0,0 @@
-from mapFolding import astDOTParamSpec, astDOTTryStar, astDOTtype_param, astDOTTypeAlias, astDOTTypeVar, astDOTTypeVarTuple
-from typing import Any, TypeAlias as typing_TypeAlias, TypeVar as typing_TypeVar
-import ast
-
-# TODO understand typing.
-
-stuPyd: typing_TypeAlias = str
-
-# NOTE An idea to subclass antecedents to effectively TypeGuard more than just the top level of the antecedent.
-class ImaCallToName(ast.Call):
-	func: ast.Name # pyright: ignore[reportIncompatibleVariableOverride]
-	# assert isinstance(ast.Call.func, ast.Name), "brinkmanship"
-	# func: ast.Name
-
-# Some common attributes of ast classes.
-astClassHasDOTbody_expr: typing_TypeAlias = ast.Expression | ast.IfExp | ast.Lambda
-astClassHasDOTbodyList_stmt: typing_TypeAlias = ast.AsyncFor | ast.AsyncWith | ast.ClassDef | ast.ExceptHandler | ast.For | ast.FunctionDef | ast.If | ast.Interactive | ast.match_case | ast.Module | ast.Try | astDOTTryStar | ast.While | ast.With
-astClassHasDOTbody: typing_TypeAlias = astClassHasDOTbody_expr | astClassHasDOTbodyList_stmt
-
-astClassHasDOTnameNotNameAlways: typing_TypeAlias = ast.alias | ast.AsyncFunctionDef | ast.ClassDef | ast.FunctionDef | astDOTParamSpec | astDOTTypeVar | astDOTTypeVarTuple
-astClassHasDOTnameNotNameOptionally: typing_TypeAlias = ast.ExceptHandler | ast.MatchAs | ast.MatchStar
-astClassHasDOTnameNotName: typing_TypeAlias = astClassHasDOTnameNotNameAlways | astClassHasDOTnameNotNameOptionally
-
-astClassHasDOTtargetAttributeNameSubscript: typing_TypeAlias = ast.AnnAssign | ast.AugAssign
-astClassHasDOTtarget_expr: typing_TypeAlias = ast.AsyncFor | ast.comprehension | ast.For
-astClassHasDOTtarget: typing_TypeAlias = ast.NamedExpr | astClassHasDOTtarget_expr | astClassHasDOTtargetAttributeNameSubscript
-
-astClassHasDOTvalue_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 | astDOTTypeAlias | ast.YieldFrom
-astClassHasDOTvalue_exprNone: typing_TypeAlias = ast.AnnAssign | ast.Return | ast.Yield
-astClassHasDOTvalue: typing_TypeAlias = ast.Constant | ast.MatchSingleton | astClassHasDOTvalue_expr | astClassHasDOTvalue_exprNone
-
-# Type hints through TypeAlias or type "hints" through the identifier name.
-ast_expr_Slice: typing_TypeAlias = ast.expr
-ast_Identifier: typing_TypeAlias = str
-intORlist_ast_type_paramORstr_orNone: typing_TypeAlias = Any
-intORstr_orNone: typing_TypeAlias = Any
-list_ast_type_paramORstr_orNone: typing_TypeAlias = Any
-str_nameDOTname: typing_TypeAlias = stuPyd
-
-# Limited success with TypeVar.
-个 = typing_TypeVar('个', bound = ast.AST, covariant = True)
-NodeORattribute = typing_TypeVar('NodeORattribute', bound = ast.AST | ast_expr_Slice | ast_Identifier | str_nameDOTname | bool | Any | None, covariant = True)
-
-# For my reference, all ast classes by subgroup:
-Ima_ast_boolop: typing_TypeAlias = ast.boolop | ast.And | ast.Or
-Ima_ast_cmpop: typing_TypeAlias = ast.cmpop | ast.Eq | ast.NotEq | ast.Lt | ast.LtE | ast.Gt | ast.GtE | ast.Is | ast.IsNot | ast.In | ast.NotIn
-Ima_ast_excepthandler: typing_TypeAlias = ast.excepthandler | ast.ExceptHandler
-Ima_ast_expr_context: typing_TypeAlias = ast.expr_context | ast.Load | ast.Store | ast.Del
-Ima_ast_expr: typing_TypeAlias = ast.expr | ast.Attribute | ast.Await | ast.BinOp | ast.BoolOp | ast.Call | ast.Compare | ast.Constant | ast.Dict | ast.DictComp | ast.FormattedValue | ast.GeneratorExp | ast.IfExp | ast.JoinedStr | ast.Lambda | ast.List | ast.ListComp | ast.Name | ast.NamedExpr | ast.Set | ast.SetComp | ast.Slice | ast.Starred | ast.Subscript | ast.Tuple | ast.UnaryOp | ast.Yield | ast.YieldFrom
-Ima_ast_mod: typing_TypeAlias = ast.mod | ast.Expression | ast.FunctionType | ast.Interactive | ast.Module
-Ima_ast_operator: typing_TypeAlias = ast.operator | ast.Add | ast.Sub | ast.Mult | ast.MatMult | ast.Div | ast.Mod | ast.Pow | ast.LShift | ast.RShift | ast.BitOr | ast.BitXor | ast.BitAnd | ast.FloorDiv
-Ima_ast_orphan = ast.alias | ast.arg | ast.arguments | ast.comprehension | ast.keyword | ast.match_case | ast.withitem
-iMa_ast_pattern: typing_TypeAlias = ast.pattern | ast.MatchAs | ast.MatchClass | ast.MatchMapping | ast.MatchOr | ast.MatchSequence | ast.MatchSingleton | ast.MatchStar | ast.MatchValue
-Ima_ast_stmt: typing_TypeAlias = ast.stmt | ast.AnnAssign | ast.Assert | ast.Assign | ast.AsyncFor | ast.AsyncFunctionDef | ast.AsyncWith | ast.AugAssign | ast.Break | ast.ClassDef | ast.Continue | ast.Delete | ast.Expr | ast.For | ast.FunctionDef | ast.Global | ast.If | ast.Import | ast.ImportFrom | ast.Match | ast.Nonlocal | ast.Pass | ast.Raise | ast.Return | ast.Try | astDOTTryStar | astDOTTypeAlias | ast.While | ast.With
-Ima_ast_type_ignore: typing_TypeAlias = ast.type_ignore | ast.TypeIgnore
-Ima_ast_type_param: typing_TypeAlias = astDOTtype_param | astDOTParamSpec | astDOTTypeVar | astDOTTypeVarTuple
-Ima_ast_unaryop: typing_TypeAlias = ast.unaryop | ast.Invert | ast.Not | ast.UAdd | ast.USub

mapFolding/someAssemblyRequired/_tool_Make.py

@@ -1,132 +0,0 @@
-"""
-AST Node Construction Utilities for Python Code Generation
-
-This module provides the Make class with static methods for creating AST nodes with sane defaults. It abstracts away the
-complexity of constructing AST nodes directly, making programmatic code generation more intuitive and less error-prone.
-
-The Make class serves as a factory for creating various types of AST nodes needed in code generation, transformation,
-and analysis workflows. Each method follows a consistent pattern that maps cleanly to Python's syntax while handling the
-details of AST node construction.
-"""
-
-from collections.abc import Sequence
-from mapFolding.someAssemblyRequired import (
-	ast_expr_Slice,
-	ast_Identifier,
-	intORlist_ast_type_paramORstr_orNone,
-	intORstr_orNone,
-	list_ast_type_paramORstr_orNone,
-	str_nameDOTname,
-)
-from typing import Any
-import ast
-
-class Make:
-	"""Almost all parameters described here are only accessible through a method's `**keywordArguments` parameter.
-
-	Parameters:
-		context (ast.Load()): Are you loading from, storing to, or deleting the identifier? The `context` (also, `ctx`) value is `ast.Load()`, `ast.Store()`, or `ast.Del()`.
-		col_offset (0): int Position information specifying the column where an AST node begins.
-		end_col_offset (None): int|None Position information specifying the column where an AST node ends.
-		end_lineno (None): int|None Position information specifying the line number where an AST node ends.
-		level (0): int Module import depth level that controls relative vs absolute imports. Default 0 indicates absolute import.
-		lineno: int Position information manually specifying the line number where an AST node begins.
-		kind (None): str|None Used for type annotations in limited cases.
-		type_comment (None): str|None "type_comment is an optional string with the type annotation as a comment." or `# type: ignore`.
-		type_params: list[ast.type_param] Type parameters for generic type definitions.
-
-	The `ast._Attributes`, lineno, col_offset, end_lineno, and end_col_offset, hold position information; however, they are, importantly, _not_ `ast._fields`.
-	"""
-	@staticmethod
-	def alias(name: ast_Identifier, asname: ast_Identifier | None = None) -> ast.alias:
-		return ast.alias(name, asname)
-
-	@staticmethod
-	def AnnAssign(target: ast.Attribute | ast.Name | ast.Subscript, annotation: ast.expr, value: ast.expr | None = None, **keywordArguments: int) -> ast.AnnAssign: # `simple: int`: uses a clever int-from-boolean to assign the correct value to the `simple` attribute. So, don't make it a method parameter.
-		return ast.AnnAssign(target, annotation, value, simple=int(isinstance(target, ast.Name)), **keywordArguments)
-
-	@staticmethod
-	def arg(identifier: ast_Identifier, annotation: ast.expr | None = None, **keywordArguments: intORstr_orNone) -> ast.arg:
-		return ast.arg(identifier, annotation, **keywordArguments)
-
-	@staticmethod
-	def argumentsSpecification(posonlyargs:list[ast.arg]=[], args:list[ast.arg]=[], vararg:ast.arg|None=None, kwonlyargs:list[ast.arg]=[], kw_defaults:list[ast.expr|None]=[None], kwarg:ast.arg|None=None, defaults:list[ast.expr]=[]) -> ast.arguments:
-		return ast.arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults, kwarg, defaults)
-
-	@staticmethod
-	def Assign(listTargets: list[ast.expr], value: ast.expr, **keywordArguments: intORstr_orNone) -> ast.Assign:
-		return ast.Assign(listTargets, value, **keywordArguments)
-
-	@staticmethod
-	def Attribute(value: ast.expr, *attribute: ast_Identifier, context: ast.expr_context = ast.Load(), **keywordArguments: int) -> ast.Attribute:
-		""" If two `ast_Identifier` are joined by a dot `.`, they are _usually_ an `ast.Attribute`, but see `ast.ImportFrom`.
-		Parameters:
-			value: the part before the dot (e.g., `ast.Name`.)
-			attribute: an `ast_Identifier` after a dot `.`; you can pass multiple `attribute` and they will be chained together.
-		"""
-		def addDOTattribute(chain: ast.expr, identifier: ast_Identifier, context: ast.expr_context, **keywordArguments: int) -> ast.Attribute:
-			return ast.Attribute(value=chain, attr=identifier, ctx=context, **keywordArguments)
-		buffaloBuffalo = addDOTattribute(value, attribute[0], context, **keywordArguments)
-		for identifier in attribute[1:None]:
-			buffaloBuffalo = addDOTattribute(buffaloBuffalo, identifier, context, **keywordArguments)
-		return buffaloBuffalo
-
-	@staticmethod
-	def AugAssign(target: ast.Attribute | ast.Name | ast.Subscript, operator: ast.operator, value: ast.expr, **keywordArguments: int) -> ast.AugAssign:
-		return ast.AugAssign(target, operator, value, **keywordArguments)
-
-	@staticmethod
-	def Call(callee: ast.expr, listArguments: Sequence[ast.expr] | None = None, list_astKeywords: Sequence[ast.keyword] | None = None) -> ast.Call:
-		return ast.Call(func=callee, args=list(listArguments) if listArguments else [], keywords=list(list_astKeywords) if list_astKeywords else [])
-
-	@staticmethod
-	def ClassDef(name: ast_Identifier, listBases: list[ast.expr]=[], list_keyword: list[ast.keyword]=[], body: list[ast.stmt]=[], decorator_list: list[ast.expr]=[], **keywordArguments: list_ast_type_paramORstr_orNone) -> ast.ClassDef:
-		return ast.ClassDef(name, listBases, list_keyword, body, decorator_list, **keywordArguments)
-
-	@staticmethod
-	def Constant(value: Any, **keywordArguments: intORstr_orNone) -> ast.Constant:
-		return ast.Constant(value, **keywordArguments)
-
-	@staticmethod
-	def Expr(value: ast.expr, **keywordArguments: int) -> ast.Expr:
-		return ast.Expr(value, **keywordArguments)
-
-	@staticmethod
-	def FunctionDef(name: ast_Identifier, argumentsSpecification:ast.arguments=ast.arguments(), body:list[ast.stmt]=[], decorator_list:list[ast.expr]=[], returns:ast.expr|None=None, **keywordArguments: intORlist_ast_type_paramORstr_orNone) -> ast.FunctionDef:
-		return ast.FunctionDef(name, argumentsSpecification, body, decorator_list, returns, **keywordArguments)
-
-	@staticmethod
-	def Import(moduleWithLogicalPath: str_nameDOTname, asname: ast_Identifier | None = None, **keywordArguments: int) -> ast.Import:
-		return ast.Import(names=[Make.alias(moduleWithLogicalPath, asname)], **keywordArguments)
-
-	@staticmethod
-	def ImportFrom(moduleWithLogicalPath: str_nameDOTname, list_astAlias: list[ast.alias], **keywordArguments: int) -> ast.ImportFrom:
-		return ast.ImportFrom(moduleWithLogicalPath, list_astAlias, **keywordArguments)
-
-	@staticmethod
-	def keyword(keywordArgument: ast_Identifier, value: ast.expr, **keywordArguments: int) -> ast.keyword:
-		return ast.keyword(arg=keywordArgument, value=value, **keywordArguments)
-
-	@staticmethod
-	def Module(body: list[ast.stmt] = [], type_ignores: list[ast.TypeIgnore] = []) -> ast.Module:
-		return ast.Module(body, type_ignores)
-
-	@staticmethod
-	def Name(identifier: ast_Identifier, context: ast.expr_context = ast.Load(), **keywordArguments: int) -> ast.Name:
-		return ast.Name(identifier, context, **keywordArguments)
-
-	@staticmethod
-	def Return(value: ast.expr | None = None, **keywordArguments: int) -> ast.Return:
-		return ast.Return(value, **keywordArguments)
-
-	@staticmethod
-	def Subscript(value: ast.expr, slice: ast_expr_Slice, context: ast.expr_context = ast.Load(), **keywordArguments: int) -> ast.Subscript:
-		return ast.Subscript(value, slice, context, **keywordArguments)
-
-	@staticmethod
-	def Tuple(elements: Sequence[ast.expr] = [], context: ast.expr_context = ast.Load(), **keywordArguments: int) -> ast.Tuple:
-		return ast.Tuple(list(elements), context, **keywordArguments)
-
-	@staticmethod
-	def While(test: ast.expr, doThis: list[ast.stmt], orElse: list[ast.stmt] = [], **keywordArguments: int) -> ast.While:
-		return ast.While(test, doThis, orElse, **keywordArguments)