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

mapFolding/__init__.py

@@ -47,38 +47,39 @@ foundation for exploring advanced code transformation techniques.
 from typing import Any, TypeAlias
 import sys
 
-stuPyd: TypeAlias = Any
-
-if sys.version_info >= (3, 12):
-	from ast import (
-		ParamSpec as astDOTParamSpec,
-		type_param as astDOTtype_param,
-		TypeAlias as astDOTTypeAlias,
-		TypeVar as astDOTTypeVar,
-		TypeVarTuple as astDOTTypeVarTuple,
-	)
-else:
-	astDOTParamSpec: TypeAlias = stuPyd
-	astDOTtype_param: TypeAlias = stuPyd
-	astDOTTypeAlias: TypeAlias = stuPyd
-	astDOTTypeVar: TypeAlias = stuPyd
-	astDOTTypeVarTuple: TypeAlias = stuPyd
+yourPythonIsOld: TypeAlias = Any
+# ruff: noqa: E402
+
+# if sys.version_info >= (3, 12):
+# 	from ast import (
+# 		ParamSpec as astDOTParamSpec,
+# 		type_param as astDOTtype_param,
+# 		TypeAlias as astDOTTypeAlias,
+# 		TypeVar as astDOTTypeVar,
+# 		TypeVarTuple as astDOTTypeVarTuple,
+# 	)
+# else:
+# 	astDOTParamSpec: TypeAlias = yourPythonIsOld
+# 	astDOTtype_param: TypeAlias = yourPythonIsOld
+# 	astDOTTypeAlias: TypeAlias = yourPythonIsOld
+# 	astDOTTypeVar: TypeAlias = yourPythonIsOld
+# 	astDOTTypeVarTuple: TypeAlias = yourPythonIsOld
 
 if sys.version_info >= (3, 11):
-	from ast import TryStar as astDOTTryStar
+	# from ast import TryStar as astDOTTryStar
 	from typing import TypedDict as TypedDict
 	from typing import NotRequired as NotRequired
 else:
-	astDOTTryStar: TypeAlias = stuPyd
+	astDOTTryStar: TypeAlias = yourPythonIsOld
 	try:
 		from typing_extensions import TypedDict as TypedDict
 		from typing_extensions import NotRequired as NotRequired
 	except Exception:
-		TypedDict = dict[stuPyd, stuPyd]
+		TypedDict = dict[yourPythonIsOld, yourPythonIsOld]
 		from collections.abc import Iterable
 		NotRequired: TypeAlias = Iterable
 
-from mapFolding.datatypes import (  # noqa: E402
+from mapFolding.datatypes import (
 	Array1DElephino as Array1DElephino,
 	Array1DFoldsTotal as Array1DFoldsTotal,
 	Array1DLeavesTotal as Array1DLeavesTotal,
@@ -92,18 +93,18 @@ from mapFolding.datatypes import (  # noqa: E402
 	NumPyLeavesTotal as NumPyLeavesTotal,
 )
 
-from mapFolding.theSSOT import (  # noqa: E402
+from mapFolding.theSSOT import (
 	ComputationState as ComputationState,
 	raiseIfNoneGitHubIssueNumber3 as raiseIfNoneGitHubIssueNumber3,
 	The as The,
 )
 
-from mapFolding.theDao import (  # noqa: E402
+from mapFolding.theDao import (
 	countInitialize as countInitialize,
 	doTheNeedful as doTheNeedful,
 )
 
-from mapFolding.beDRY import (  # noqa: E402
+from mapFolding.beDRY import (
 	getLeavesTotal as getLeavesTotal,
 	getTaskDivisions as getTaskDivisions,
 	outfitCountFolds as outfitCountFolds,
@@ -111,17 +112,18 @@ from mapFolding.beDRY import (  # noqa: E402
 	validateListDimensions as validateListDimensions,
 )
 
-from mapFolding.toolboxFilesystem import (  # noqa: E402
+from mapFolding.toolboxFilesystem import (
 	getPathFilenameFoldsTotal as getPathFilenameFoldsTotal,
 	getPathRootJobDEFAULT as getPathRootJobDEFAULT,
 	saveFoldsTotal as saveFoldsTotal,
 	saveFoldsTotalFAILearly as saveFoldsTotalFAILearly,
-	writeStringToHere as writeStringToHere,
 )
 
-from mapFolding.basecamp import countFolds as countFolds  # noqa: E402
+from Z0Z_tools import writeStringToHere as writeStringToHere
+
+from mapFolding.basecamp import countFolds as countFolds
 
-from mapFolding.oeis import (  # noqa: E402
+from mapFolding.oeis import (
 	clearOEIScache as clearOEIScache,
 	getFoldsTotalKnown as getFoldsTotalKnown,
 	getOEISids as getOEISids,

mapFolding/someAssemblyRequired/Z0Z_makeSomeModules.py

@@ -2,11 +2,11 @@ from mapFolding import raiseIfNoneGitHubIssueNumber3, The
 from mapFolding.someAssemblyRequired import (
 	ast_Identifier,
 	astModuleToIngredientsFunction,
-	be,
+	Be,
 	DOT,
 	extractFunctionDef,
-	grab,
-	ifThis,
+	Grab,
+	IfThis,
 	IngredientsFunction,
 	IngredientsModule,
 	LedgerOfImports,
@@ -26,7 +26,7 @@ from mapFolding.someAssemblyRequired.transformationTools import (
 	shatter_dataclassesDOTdataclass,
 	unpackDataclassCallFunctionRepackDataclass,
 	write_astModule,
-	)
+)
 from pathlib import PurePath
 import ast
 
@@ -35,7 +35,7 @@ sourceCallableIdentifierHARDCODED = 'count'
 logicalPathInfixHARDCODED: ast_Identifier = 'syntheticModules'
 theCountingIdentifierHARDCODED: ast_Identifier = 'groupsOfFolds'
 
-def makeInitializeGroupsOfFolds():
+def makeInitializeGroupsOfFolds() -> None:
 	callableIdentifierHARDCODED = 'initializeGroupsOfFolds'
 	moduleIdentifierHARDCODED: ast_Identifier = 'initializeCount'
 
@@ -53,15 +53,12 @@ def makeInitializeGroupsOfFolds():
 
 	countInitializeIngredients.astFunctionDef.name = callableIdentifier
 
-	dataclassInstanceIdentifier = NodeTourist(be.arg, Then.extractIt(DOT.arg)).captureLastMatch(countInitializeIngredients.astFunctionDef)
+	dataclassInstanceIdentifier = NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(countInitializeIngredients.astFunctionDef)
 	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
 	theCountingIdentifier = theCountingIdentifierHARDCODED
 
-	findThis = ifThis.isWhileAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
-	doThat = grab.testAttribute(grab.andDoAllOf([
-		grab.opsAttribute(Then.replaceWith([ast.Eq()])), # type: ignore
-		grab.leftAttribute(grab.attrAttribute(Then.replaceWith(theCountingIdentifier))) # type: ignore
-	]))
+	findThis = IfThis.isWhileAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	doThat = Grab.testAttribute(Grab.andDoAllOf([ Grab.opsAttribute(Then.replaceWith([ast.Eq()])), Grab.leftAttribute(Grab.attrAttribute(Then.replaceWith(theCountingIdentifier))) ])) # type: ignore
 	NodeChanger(findThis, doThat).visit(countInitializeIngredients.astFunctionDef.body[0])
 
 	ingredientsModule = IngredientsModule(countInitializeIngredients)
@@ -70,7 +67,7 @@ def makeInitializeGroupsOfFolds():
 
 	write_astModule(ingredientsModule, pathFilename, The.packageName)
 
-def makeDaoOfMapFolding():
+def makeDaoOfMapFolding() -> PurePath:
 	moduleIdentifierHARDCODED: ast_Identifier = 'daoOfMapFolding'
 
 	algorithmSourceModule = algorithmSourceModuleHARDCODED
@@ -84,9 +81,9 @@ def makeDaoOfMapFolding():
 	daoOfMapFolding = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule)
 		, LedgerOfImports(astModule))
 
-	dataclassName: ast.expr | None = NodeTourist(be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(daoOfMapFolding.astFunctionDef)
+	dataclassName: ast.expr | None = NodeTourist(Be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(daoOfMapFolding.astFunctionDef)
 	if dataclassName is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclass_Identifier: ast_Identifier | None = NodeTourist(be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
+	dataclass_Identifier: ast_Identifier | None = NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
 	if dataclass_Identifier is None: raise raiseIfNoneGitHubIssueNumber3
 
 	dataclassLogicalPathModule = None
@@ -98,7 +95,7 @@ def makeDaoOfMapFolding():
 		if dataclassLogicalPathModule:
 			break
 	if dataclassLogicalPathModule is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclassInstanceIdentifier = NodeTourist(be.arg, Then.extractIt(DOT.arg)).captureLastMatch(daoOfMapFolding.astFunctionDef)
+	dataclassInstanceIdentifier = NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(daoOfMapFolding.astFunctionDef)
 	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
 	shatteredDataclass = shatter_dataclassesDOTdataclass(dataclassLogicalPathModule, dataclass_Identifier, dataclassInstanceIdentifier)
 
@@ -121,13 +118,14 @@ def makeDaoOfMapFolding():
 	doTheNeedful.imports.update(shatteredDataclass.imports)
 	targetCallableIdentifier = daoOfMapFolding.astFunctionDef.name
 	doTheNeedful = unpackDataclassCallFunctionRepackDataclass(doTheNeedful, targetCallableIdentifier, shatteredDataclass)
-	astTuple: ast.Tuple | None = NodeTourist(be.Return, Then.extractIt(DOT.value)).captureLastMatch(daoOfMapFolding.astFunctionDef)
+	astTuple: ast.Tuple | None = NodeTourist(Be.Return, Then.extractIt(DOT.value)).captureLastMatch(daoOfMapFolding.astFunctionDef)
 	if astTuple is None: raise raiseIfNoneGitHubIssueNumber3
 	astTuple.ctx = ast.Store()
 
-	findThis = ifThis.isAssignAndValueIs(ifThis.isCall_Identifier(targetCallableIdentifier))
-	doThat = Then.replaceWith(Make.Assign(listTargets=[astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts)))
-	NodeChanger(findThis, doThat).visit(doTheNeedful.astFunctionDef)
+	findThis = IfThis.isAssignAndValueIs(IfThis.isCall_Identifier(targetCallableIdentifier))
+	doThat = Then.replaceWith(Make.Assign([astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts)))
+	changeAssignCallToTarget = NodeChanger(findThis, doThat)
+	changeAssignCallToTarget.visit(doTheNeedful.astFunctionDef)
 
 	ingredientsModule = IngredientsModule([daoOfMapFolding, doTheNeedful])
 	ingredientsModule.removeImportFromModule('numpy')
@@ -138,7 +136,7 @@ def makeDaoOfMapFolding():
 
 	return pathFilename
 
-def makeTheorem2():
+def makeTheorem2() -> PurePath:
 	moduleIdentifierHARDCODED: ast_Identifier = 'theorem2'
 
 	algorithmSourceModule = algorithmSourceModuleHARDCODED
@@ -152,31 +150,31 @@ def makeTheorem2():
 	countTheorem2 = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule)
 		, LedgerOfImports(astModule))
 
-	dataclassInstanceIdentifier = NodeTourist(be.arg, Then.extractIt(DOT.arg)).captureLastMatch(countTheorem2.astFunctionDef)
+	dataclassInstanceIdentifier = NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(countTheorem2.astFunctionDef)
 	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
 
-	findThis = ifThis.isWhileAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
-	doThat = grab.testAttribute(grab.comparatorsAttribute(Then.replaceWith([Make.Constant(4)]))) # type: ignore
+	findThis = IfThis.isWhileAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	doThat = Grab.testAttribute(Grab.comparatorsAttribute(Then.replaceWith([Make.Constant(4)]))) # type: ignore
 	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
 
-	findThis = ifThis.isIfAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	findThis = IfThis.isIfAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
 	doThat = Then.extractIt(DOT.body)
 	insertLeaf = NodeTourist(findThis, doThat).captureLastMatch(countTheorem2.astFunctionDef)
-	findThis = ifThis.isIfAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	findThis = IfThis.isIfAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
 	doThat = Then.replaceWith(insertLeaf)
 	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
 
-	findThis = ifThis.isAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	findThis = IfThis.isAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
 	doThat = Then.removeIt
 	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
 
-	findThis = ifThis.isAttributeNamespace_IdentifierLessThanOrEqual(dataclassInstanceIdentifier, 'leaf1ndex')
+	findThis = IfThis.isAttributeNamespace_IdentifierLessThanOrEqual(dataclassInstanceIdentifier, 'leaf1ndex')
 	doThat = Then.removeIt
 	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
 
 	theCountingIdentifier = theCountingIdentifierHARDCODED
 	doubleTheCount = Make.AugAssign(Make.Attribute(ast.Name(dataclassInstanceIdentifier), theCountingIdentifier), ast.Mult(), Make.Constant(2))
-	findThis = be.Return
+	findThis = Be.Return
 	doThat = Then.insertThisAbove([doubleTheCount])
 	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
 
@@ -188,15 +186,15 @@ def makeTheorem2():
 
 	return pathFilename
 
-def trimTheorem2(pathFilenameSource: PurePath):
+def trimTheorem2(pathFilenameSource: PurePath) -> PurePath:
 	logicalPathInfix = logicalPathInfixHARDCODED
 	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
 	ingredientsFunction = astModuleToIngredientsFunction(parsePathFilename2astModule(pathFilenameSource), sourceCallableIdentifier)
 
-	dataclassInstanceIdentifier = NodeTourist(be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef)
+	dataclassInstanceIdentifier = NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef)
 	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
 
-	findThis = ifThis.isIfUnaryNotAttributeNamespace_Identifier(dataclassInstanceIdentifier, 'dimensionsUnconstrained')
+	findThis = IfThis.isIfUnaryNotAttributeNamespace_Identifier(dataclassInstanceIdentifier, 'dimensionsUnconstrained')
 	doThat = Then.removeIt
 	NodeChanger(findThis, doThat).visit(ingredientsFunction.astFunctionDef)
 
@@ -215,17 +213,17 @@ def trimTheorem2(pathFilenameSource: PurePath):
 	logicalPath.append(pathFilename.stem)
 	moduleWithLogicalPath: str_nameDOTname = '.'.join(logicalPath)
 
-	astImportFrom: ast.ImportFrom = Make.ImportFrom(moduleWithLogicalPath, list_astAlias=[Make.alias(ingredientsFunction.astFunctionDef.name)])
+	astImportFrom: ast.ImportFrom = Make.ImportFrom(moduleWithLogicalPath, list_alias=[Make.alias(ingredientsFunction.astFunctionDef.name)])
 
 	return pathFilename
 
-def numbaOnTheorem2(pathFilenameSource: PurePath):
+def numbaOnTheorem2(pathFilenameSource: PurePath) -> ast.ImportFrom:
 	logicalPathInfix = logicalPathInfixHARDCODED
 	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
 	countNumbaTheorem2 = astModuleToIngredientsFunction(parsePathFilename2astModule(pathFilenameSource), sourceCallableIdentifier)
-	dataclassName: ast.expr | None = NodeTourist(be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(countNumbaTheorem2.astFunctionDef)
+	dataclassName: ast.expr | None = NodeTourist(Be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(countNumbaTheorem2.astFunctionDef)
 	if dataclassName is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclass_Identifier: ast_Identifier | None = NodeTourist(be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
+	dataclass_Identifier: ast_Identifier | None = NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
 	if dataclass_Identifier is None: raise raiseIfNoneGitHubIssueNumber3
 
 	dataclassLogicalPathModule = None
@@ -237,7 +235,7 @@ def numbaOnTheorem2(pathFilenameSource: PurePath):
 		if dataclassLogicalPathModule:
 			break
 	if dataclassLogicalPathModule is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclassInstanceIdentifier = NodeTourist(be.arg, Then.extractIt(DOT.arg)).captureLastMatch(countNumbaTheorem2.astFunctionDef)
+	dataclassInstanceIdentifier = NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(countNumbaTheorem2.astFunctionDef)
 	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
 	shatteredDataclass = shatter_dataclassesDOTdataclass(dataclassLogicalPathModule, dataclass_Identifier, dataclassInstanceIdentifier)
 
@@ -263,11 +261,11 @@ def numbaOnTheorem2(pathFilenameSource: PurePath):
 	logicalPath.append(pathFilename.stem)
 	moduleWithLogicalPath: str_nameDOTname = '.'.join(logicalPath)
 
-	astImportFrom: ast.ImportFrom = Make.ImportFrom(moduleWithLogicalPath, list_astAlias=[Make.alias(countNumbaTheorem2.astFunctionDef.name)])
+	astImportFrom: ast.ImportFrom = Make.ImportFrom(moduleWithLogicalPath, list_alias=[Make.alias(countNumbaTheorem2.astFunctionDef.name)])
 
 	return astImportFrom
 
-def makeUnRePackDataclass(astImportFrom: ast.ImportFrom):
+def makeUnRePackDataclass(astImportFrom: ast.ImportFrom) -> None:
 	moduleIdentifierHARDCODED: ast_Identifier = 'dataPacking'
 
 	algorithmSourceModule = algorithmSourceModuleHARDCODED
@@ -278,9 +276,9 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom):
 	moduleIdentifier = moduleIdentifierHARDCODED
 
 	doTheNeedful: IngredientsFunction = astModuleToIngredientsFunction(parseLogicalPath2astModule(logicalPathSourceModule), sourceCallableIdentifier)
-	dataclassName: ast.expr | None = NodeTourist(be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(doTheNeedful.astFunctionDef)
+	dataclassName: ast.expr | None = NodeTourist(Be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(doTheNeedful.astFunctionDef)
 	if dataclassName is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclass_Identifier: ast_Identifier | None = NodeTourist(be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
+	dataclass_Identifier: ast_Identifier | None = NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
 	if dataclass_Identifier is None: raise raiseIfNoneGitHubIssueNumber3
 
 	dataclassLogicalPathModule = None
@@ -292,7 +290,7 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom):
 		if dataclassLogicalPathModule:
 			break
 	if dataclassLogicalPathModule is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclassInstanceIdentifier = NodeTourist(be.arg, Then.extractIt(DOT.arg)).captureLastMatch(doTheNeedful.astFunctionDef)
+	dataclassInstanceIdentifier = NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(doTheNeedful.astFunctionDef)
 	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
 	shatteredDataclass = shatter_dataclassesDOTdataclass(dataclassLogicalPathModule, dataclass_Identifier, dataclassInstanceIdentifier)
 
@@ -300,14 +298,15 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom):
 	doTheNeedful.imports.addAst(astImportFrom)
 	targetCallableIdentifier = astImportFrom.names[0].name
 	doTheNeedful = unpackDataclassCallFunctionRepackDataclass(doTheNeedful, targetCallableIdentifier, shatteredDataclass)
-	targetFunctionDef = extractFunctionDef(parseLogicalPath2astModule(astImportFrom.module), targetCallableIdentifier) # type: ignore
+	if astImportFrom.module is None: raise raiseIfNoneGitHubIssueNumber3
+	targetFunctionDef = extractFunctionDef(parseLogicalPath2astModule(astImportFrom.module), targetCallableIdentifier)
 	if targetFunctionDef is None: raise raiseIfNoneGitHubIssueNumber3
-	astTuple: ast.Tuple | None = NodeTourist(be.Return, Then.extractIt(DOT.value)).captureLastMatch(targetFunctionDef)
+	astTuple: ast.Tuple | None = NodeTourist(Be.Return, Then.extractIt(DOT.value)).captureLastMatch(targetFunctionDef)
 	if astTuple is None: raise raiseIfNoneGitHubIssueNumber3
 	astTuple.ctx = ast.Store()
 
-	findThis = ifThis.isAssignAndValueIs(ifThis.isCall_Identifier(targetCallableIdentifier))
-	doThat = Then.replaceWith(Make.Assign(listTargets=[astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts)))
+	findThis = IfThis.isAssignAndValueIs(IfThis.isCall_Identifier(targetCallableIdentifier))
+	doThat = Then.replaceWith(Make.Assign([astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts)))
 	NodeChanger(findThis, doThat).visit(doTheNeedful.astFunctionDef)
 
 	ingredientsModule = IngredientsModule(doTheNeedful)

mapFolding/someAssemblyRequired/__init__.py

@@ -44,54 +44,36 @@ optimizations - while maintaining the ability to verify correctness at each tran
 test suite.
 """
 
-from mapFolding.someAssemblyRequired._theTypes import (
+from astToolkit import (
 	ast_expr_Slice as ast_expr_Slice,
 	ast_Identifier as ast_Identifier,
-	astClassHasDOTbody as astClassHasDOTbody,
-	astClassHasDOTbody_expr as astClassHasDOTbody_expr,
-	astClassHasDOTbodyList_stmt as astClassHasDOTbodyList_stmt,
-	astClassHasDOTnameNotName as astClassHasDOTnameNotName,
-	astClassHasDOTnameNotNameAlways as astClassHasDOTnameNotNameAlways,
-	astClassHasDOTnameNotNameOptionally as astClassHasDOTnameNotNameOptionally,
-	astClassHasDOTtarget as astClassHasDOTtarget,
-	astClassHasDOTtarget_expr as astClassHasDOTtarget_expr,
-	astClassHasDOTtargetAttributeNameSubscript as astClassHasDOTtargetAttributeNameSubscript,
-	astClassHasDOTvalue as astClassHasDOTvalue,
-	astClassHasDOTvalue_expr as astClassHasDOTvalue_expr,
-	astClassHasDOTvalue_exprNone as astClassHasDOTvalue_exprNone,
+	astModuleToIngredientsFunction as astModuleToIngredientsFunction,
+	Be as Be,
+	DOT as DOT,
+	extractClassDef as extractClassDef,
+	extractFunctionDef as extractFunctionDef,
+	Grab as Grab,
 	ImaCallToName as ImaCallToName,
-	intORlist_ast_type_paramORstr_orNone as intORlist_ast_type_paramORstr_orNone,
-	intORstr_orNone as intORstr_orNone,
-	list_ast_type_paramORstr_orNone as list_ast_type_paramORstr_orNone,
-	NodeORattribute as NodeORattribute,
-	str_nameDOTname as str_nameDOTname,
-	个 as 个,
-	)
-
-from mapFolding.someAssemblyRequired._toolboxPython import (
 	importLogicalPath2Callable as importLogicalPath2Callable,
 	importPathFilename2Callable as importPathFilename2Callable,
+	IngredientsFunction as IngredientsFunction,
+	IngredientsModule as IngredientsModule,
+	LedgerOfImports as LedgerOfImports,
+	Make as Make,
 	NodeChanger as NodeChanger,
+	NodeORattribute as NodeORattribute,
 	NodeTourist as NodeTourist,
 	parseLogicalPath2astModule as parseLogicalPath2astModule,
 	parsePathFilename2astModule as parsePathFilename2astModule,
-	)
+	str_nameDOTname as str_nameDOTname,
+	Then as Then,
+	个 as 个,
+)
 
-from mapFolding.someAssemblyRequired._toolboxAntecedents import be as be, DOT as DOT, ifThis as ifThis
-from mapFolding.someAssemblyRequired._tool_Make import Make as Make
-from mapFolding.someAssemblyRequired._tool_Then import grab as grab, Then as Then
+from mapFolding.someAssemblyRequired._toolIfThis import IfThis as IfThis
 
 from mapFolding.someAssemblyRequired._toolboxContainers import (
 	DeReConstructField2ast as DeReConstructField2ast,
-	IngredientsFunction as IngredientsFunction,
-	IngredientsModule as IngredientsModule,
-	LedgerOfImports as LedgerOfImports,
 	RecipeSynthesizeFlow as RecipeSynthesizeFlow,
 	ShatteredDataclass as ShatteredDataclass,
 )
-
-from mapFolding.someAssemblyRequired._toolboxAST import (
-	astModuleToIngredientsFunction as astModuleToIngredientsFunction,
-	extractClassDef as extractClassDef,
-	extractFunctionDef as extractFunctionDef,
-	)

mapFolding/someAssemblyRequired/_toolIfThis.py

@@ -0,0 +1,53 @@
+"""
+AST Node Predicate and Access Utilities for Pattern Matching and Traversal
+
+This module provides utilities for accessing and matching AST nodes in a consistent way. It contains three primary
+classes:
+
+1. DOT: Provides consistent accessor methods for AST node attributes across different node types, simplifying the access
+	to node properties.
+
+2. be: Offers type-guard functions that verify AST node types, enabling safe type narrowing for static type checking and
+	improving code safety.
+
+3. ifThis: Contains predicate functions for matching AST nodes based on various criteria, enabling precise targeting of
+	nodes for analysis or transformation.
+
+These utilities form the foundation of the pattern-matching component in the AST manipulation framework, working in
+conjunction with the NodeChanger and NodeTourist classes to enable precise and targeted code transformations. Together,
+they implement a declarative approach to AST manipulation that separates node identification (ifThis), type verification
+(be), and data access (DOT).
+"""
+
+from astToolkit import IfThis as astToolkit_IfThis
+from collections.abc import Callable
+from mapFolding.someAssemblyRequired import ast_Identifier, Be
+from typing import TypeGuard
+import ast
+
+class IfThis(astToolkit_IfThis):
+	"""
+	Provide predicate functions for matching and filtering AST nodes based on various criteria.
+
+	The ifThis class contains static methods that generate predicate functions used to test whether AST nodes match
+	specific criteria. These predicates can be used with NodeChanger and NodeTourist to identify and process specific
+	patterns in the AST.
+
+	The class provides predicates for matching various node types, attributes, identifiers, and structural patterns,
+	enabling precise targeting of AST elements for analysis or transformation.
+	"""
+	@staticmethod
+	def isAttributeNamespace_IdentifierGreaterThan0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Compare] | bool]:
+		return lambda node: (Be.Compare(node)
+					and IfThis.isAttributeNamespace_Identifier(namespace, identifier)(node.left)
+					and Be.Gt(node.ops[0])
+					and IfThis.isConstant_value(0)(node.comparators[0]))
+	@staticmethod
+	def isIfAttributeNamespace_IdentifierGreaterThan0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.If] | bool]:
+		return lambda node: (Be.If(node)
+					and IfThis.isAttributeNamespace_IdentifierGreaterThan0(namespace, identifier)(node.test))
+
+	@staticmethod
+	def isWhileAttributeNamespace_IdentifierGreaterThan0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.While] | bool]:
+		return lambda node: (Be.While(node)
+					and IfThis.isAttributeNamespace_IdentifierGreaterThan0(namespace, identifier)(node.test))