mapFolding 0.11.2__py3-none-any.whl → 0.11.4__py3-none-any.whl

mapFolding/someAssemblyRequired/{Z0Z_makeSomeModules.py → Z0Z_makeAllModules.py}

@@ -1,30 +1,33 @@
-from collections.abc import Sequence
-from astToolkit import ClassIsAndAttribute, extractClassDef
-from mapFolding import raiseIfNoneGitHubIssueNumber3, The
-from mapFolding.someAssemblyRequired import (
-	ast_Identifier,
+from astToolkit import (
 	astModuleToIngredientsFunction,
 	Be,
+	ClassIsAndAttribute,
 	DOT,
+	extractClassDef,
 	extractFunctionDef,
 	Grab,
-	IfThis,
 	IngredientsFunction,
 	IngredientsModule,
-	inlineFunctionDef,
 	LedgerOfImports,
 	Make,
 	NodeChanger,
 	NodeTourist,
 	parseLogicalPath2astModule,
 	parsePathFilename2astModule,
-	removeUnusedParameters,
 	str_nameDOTname,
 	Then,
-	write_astModule,
+)
+from astToolkit.transformationTools import inlineFunctionDef, removeUnusedParameters, write_astModule
+from collections.abc import Sequence
+from mapFolding import packageSettings
+from mapFolding.someAssemblyRequired import (
 	DeReConstructField2ast,
+	IfThis,
+	raiseIfNoneGitHubIssueNumber3,
 	ShatteredDataclass,
+	sourceCallableDispatcherHARDCODED,
 )
+from mapFolding.someAssemblyRequired.infoBooth import algorithmSourceModuleHARDCODED, dataPackingModuleIdentifierHARDCODED, logicalPathInfixHARDCODED, sourceCallableIdentifierHARDCODED, theCountingIdentifierHARDCODED
 from mapFolding.someAssemblyRequired.toolkitNumba import decorateCallableWithNumba, parametersNumbaLight
 from mapFolding.someAssemblyRequired.transformationTools import (
 	removeDataclassFromFunction,
@@ -35,28 +38,25 @@ from pathlib import PurePath
 from Z0Z_tools import importLogicalPath2Callable
 import ast
 import dataclasses
+from os import PathLike
 
-algorithmSourceModuleHARDCODED = 'daoOfMapFolding'
-sourceCallableIdentifierHARDCODED = 'count'
-logicalPathInfixHARDCODED: ast_Identifier = 'syntheticModules'
-theCountingIdentifierHARDCODED: ast_Identifier = 'groupsOfFolds'
-dataPackingModuleIdentifierHARDCODED: ast_Identifier = 'dataPacking'
-
-def makeInitializeGroupsOfFolds() -> None:
-	callableIdentifierHARDCODED = 'initializeGroupsOfFolds'
-	moduleIdentifierHARDCODED: ast_Identifier = 'initializeCount'
+def _getPathFilename(pathRoot: PathLike[str] | PurePath | None = packageSettings.pathPackage
+					, logicalPathInfix: PathLike[str] | PurePath | str | None = None
+					, moduleIdentifier: str = '', fileExtension: str = packageSettings.fileExtension) -> PurePath:
+	pathFilename = PurePath(moduleIdentifier + fileExtension)
+	if logicalPathInfix:
+		pathFilename = PurePath(logicalPathInfix, pathFilename)
+	if pathRoot:
+		pathFilename = PurePath(pathRoot, pathFilename)
+	return pathFilename
 
+def makeInitializeGroupsOfFolds(moduleIdentifier: str, callableIdentifier: str, logicalPathInfix: PathLike[str] | PurePath | str | None = None) -> None:
 	algorithmSourceModule = algorithmSourceModuleHARDCODED
 	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
-	logicalPathSourceModule = '.'.join([The.packageName, algorithmSourceModule])
-
-	callableIdentifier = callableIdentifierHARDCODED
-	logicalPathInfix = logicalPathInfixHARDCODED
-	moduleIdentifier = moduleIdentifierHARDCODED
+	logicalPathSourceModule = '.'.join([packageSettings.packageName, algorithmSourceModule])
 
 	astModule = parseLogicalPath2astModule(logicalPathSourceModule)
-	countInitializeIngredients = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule)
-		, LedgerOfImports(astModule))
+	countInitializeIngredients = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
 
 	countInitializeIngredients.astFunctionDef.name = callableIdentifier
 
@@ -64,37 +64,35 @@ def makeInitializeGroupsOfFolds() -> None:
 	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
 	theCountingIdentifier = theCountingIdentifierHARDCODED
 
-	findThis = IfThis.isWhileAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	findThis = IfThis.isWhileAttributeNamespaceIdentifierGreaterThan0(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)
 
-	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
-
-	write_astModule(ingredientsModule, pathFilename, The.packageName)
+	pathFilename = _getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier + packageSettings.fileExtension)
 
-def makeDaoOfMapFolding() -> PurePath:
-	moduleIdentifierHARDCODED: ast_Identifier = 'daoOfMapFolding'
+	write_astModule(ingredientsModule, pathFilename, packageSettings.packageName)
 
+def makeDaoOfMapFolding(moduleIdentifier: str, callableIdentifier: str | None = None
+						, logicalPathInfix: PathLike[str] | PurePath | str | None = None
+						, sourceCallableDispatcher: str | None = None) -> PurePath:
 	algorithmSourceModule = algorithmSourceModuleHARDCODED
 	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
-	logicalPathSourceModule = '.'.join([The.packageName, algorithmSourceModule])
-
-	logicalPathInfix = logicalPathInfixHARDCODED
-	moduleIdentifier = moduleIdentifierHARDCODED
+	if callableIdentifier is None:
+		callableIdentifier = sourceCallableIdentifier
+	logicalPathSourceModule = '.'.join([packageSettings.packageName, algorithmSourceModule])
 
 	astModule = parseLogicalPath2astModule(logicalPathSourceModule)
-	daoOfMapFolding = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule)
-		, LedgerOfImports(astModule))
+	ingredientsFunction = 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(ingredientsFunction.astFunctionDef)
 	if dataclassName is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclass_Identifier: ast_Identifier | None = NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
+	dataclass_Identifier: str | None = NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
 	if dataclass_Identifier is None: raise raiseIfNoneGitHubIssueNumber3
 
 	dataclassLogicalPathModule = None
-	for moduleWithLogicalPath, listNameTuples in daoOfMapFolding.imports.dictionaryImportFrom.items():
+	for moduleWithLogicalPath, listNameTuples in ingredientsFunction.imports.dictionaryImportFrom.items():
 		for nameTuple in listNameTuples:
 			if nameTuple[0] == dataclass_Identifier:
 				dataclassLogicalPathModule = moduleWithLogicalPath
@@ -102,54 +100,50 @@ def makeDaoOfMapFolding() -> PurePath:
 		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(ingredientsFunction.astFunctionDef)
 	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
 	shatteredDataclass = shatter_dataclassesDOTdataclass(dataclassLogicalPathModule, dataclass_Identifier, dataclassInstanceIdentifier)
 
-	# theCountingIdentifier = theCountingIdentifierHARDCODED
-	# doubleTheCount = Make.AugAssign(Make.Attribute(ast.Name(dataclassInstanceIdentifier), theCountingIdentifier), ast.Mult(), Make.Constant(2))
-	# findThis = be.Return
-	# doThat = Then.insertThisAbove([doubleTheCount])
-	# NodeChanger(findThis, doThat).visit(daoOfMapFolding.astFunctionDef)
+	ingredientsFunction.imports.update(shatteredDataclass.imports)
+	ingredientsFunction = removeDataclassFromFunction(ingredientsFunction, shatteredDataclass)
 
-	daoOfMapFolding.imports.update(shatteredDataclass.imports)
-	daoOfMapFolding = removeDataclassFromFunction(daoOfMapFolding, shatteredDataclass)
+	ingredientsFunction = removeUnusedParameters(ingredientsFunction)
 
-	daoOfMapFolding = removeUnusedParameters(daoOfMapFolding)
+	ingredientsFunction = decorateCallableWithNumba(ingredientsFunction, parametersNumbaLight)
 
-	daoOfMapFolding = decorateCallableWithNumba(daoOfMapFolding, parametersNumbaLight)
+	ingredientsModule = IngredientsModule(ingredientsFunction)
 
-	sourceCallableIdentifier = The.sourceCallableDispatcher
+	if sourceCallableDispatcher is not None:
 
-	doTheNeedful: IngredientsFunction = astModuleToIngredientsFunction(astModule, sourceCallableIdentifier)
-	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) # type: ignore
-	if astTuple is None: raise raiseIfNoneGitHubIssueNumber3
-	astTuple.ctx = ast.Store()
-	ast.Return()
+		ingredientsFunctionDispatcher: IngredientsFunction = astModuleToIngredientsFunction(astModule, sourceCallableDispatcher)
+		ingredientsFunctionDispatcher.imports.update(shatteredDataclass.imports)
+		targetCallableIdentifier = ingredientsFunction.astFunctionDef.name
+		ingredientsFunctionDispatcher = unpackDataclassCallFunctionRepackDataclass(ingredientsFunctionDispatcher, targetCallableIdentifier, shatteredDataclass)
+		astTuple: ast.Tuple | None = NodeTourist(Be.Return, Then.extractIt(DOT.value)).captureLastMatch(ingredientsFunction.astFunctionDef) # type: ignore
+		if astTuple is None: raise raiseIfNoneGitHubIssueNumber3
+		astTuple.ctx = ast.Store()
 
-	findThis = ClassIsAndAttribute.valueIs(ast.Assign, 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)
+		findThis = ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCall_Identifier(targetCallableIdentifier))
+		doThat = Then.replaceWith(Make.Assign([astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts)))
+		changeAssignCallToTarget = NodeChanger(findThis, doThat)
+		changeAssignCallToTarget.visit(ingredientsFunctionDispatcher.astFunctionDef)
+
+		ingredientsModule.appendIngredientsFunction(ingredientsFunctionDispatcher)
 
-	ingredientsModule = IngredientsModule([daoOfMapFolding, doTheNeedful])
 	ingredientsModule.removeImportFromModule('numpy')
 
-	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
+	pathFilename = _getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier + packageSettings.fileExtension)
 
-	write_astModule(ingredientsModule, pathFilename, The.packageName)
+	write_astModule(ingredientsModule, pathFilename, packageSettings.packageName)
 
 	return pathFilename
 
 def makeDaoOfMapFoldingParallel() -> PurePath:
-	moduleIdentifierHARDCODED: ast_Identifier = 'countParallel'
+	moduleIdentifierHARDCODED: str = 'countParallel'
 
 	algorithmSourceModule = algorithmSourceModuleHARDCODED
 	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
-	logicalPathSourceModule = '.'.join([The.packageName, algorithmSourceModule])
+	logicalPathSourceModule = '.'.join([packageSettings.packageName, algorithmSourceModule])
 
 	logicalPathInfix = logicalPathInfixHARDCODED
 	moduleIdentifier = moduleIdentifierHARDCODED
@@ -159,7 +153,7 @@ def makeDaoOfMapFoldingParallel() -> PurePath:
 
 	dataclassName: ast.expr | None = NodeTourist(Be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(ingredientsFunction.astFunctionDef)
 	if dataclassName is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclass_Identifier: ast_Identifier | None = NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
+	dataclass_Identifier: str | None = NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
 	if dataclass_Identifier is None: raise raiseIfNoneGitHubIssueNumber3
 
 	dataclassLogicalPathModule = None
@@ -181,8 +175,8 @@ def makeDaoOfMapFoldingParallel() -> PurePath:
 	dataclassFieldsParallel = dataclasses.fields(importLogicalPath2Callable(dataclassLogicalPathModule, dataclass_IdentifierParallel))  # pyright: ignore [reportArgumentType]
 	onlyParallelFields = [field for field in dataclassFieldsParallel if field.name not in [fieldBase.name for fieldBase in dataclassBaseFields]]
 
-	Official_fieldOrder: list[ast_Identifier] = []
-	dictionaryDeReConstruction: dict[ast_Identifier, DeReConstructField2ast] = {}
+	Official_fieldOrder: list[str] = []
+	dictionaryDeReConstruction: dict[str, DeReConstructField2ast] = {}
 
 	dataclassClassDef = extractClassDef(parseLogicalPath2astModule(dataclassLogicalPathModule), dataclass_IdentifierParallel)
 	if not isinstance(dataclassClassDef, ast.ClassDef): raise ValueError(f"I could not find `{dataclass_IdentifierParallel = }` in `{dataclassLogicalPathModule = }`.")
@@ -242,7 +236,7 @@ def makeDaoOfMapFoldingParallel() -> PurePath:
 	ingredientsFunction = decorateCallableWithNumba(ingredientsFunction, parametersNumbaLight)
 
 	# Start unpack/repack the dataclass function ================================================
-	sourceCallableIdentifier = The.sourceCallableDispatcher
+	sourceCallableIdentifier = sourceCallableDispatcherHARDCODED
 
 	unRepackDataclass: IngredientsFunction = astModuleToIngredientsFunction(astModule, sourceCallableIdentifier)
 	unRepackDataclass.astFunctionDef.name = 'unRepack' + dataclass_IdentifierParallel
@@ -293,58 +287,59 @@ def makeDaoOfMapFoldingParallel() -> PurePath:
 	)
 	ingredientsModule.removeImportFromModule('numpy')
 
-	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
+	pathFilename = _getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier + packageSettings.fileExtension)
 
-	write_astModule(ingredientsModule, pathFilename, The.packageName)
+	write_astModule(ingredientsModule, pathFilename, packageSettings.packageName)
 	return pathFilename
 
-def makeTheorem2() -> PurePath:
-	moduleIdentifierHARDCODED: ast_Identifier = 'theorem2'
-
+def makeTheorem2(moduleIdentifier: str, callableIdentifier: str | None = None
+						, logicalPathInfix: PathLike[str] | PurePath | str | None = None
+						, sourceCallableDispatcher: str | None = None) -> PurePath:
 	algorithmSourceModule = algorithmSourceModuleHARDCODED
 	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
-	logicalPathSourceModule = '.'.join([The.packageName, algorithmSourceModule])
-
-	logicalPathInfix = logicalPathInfixHARDCODED
-	moduleIdentifier = moduleIdentifierHARDCODED
+	if callableIdentifier is None:
+		callableIdentifier = sourceCallableIdentifier
+	logicalPathSourceModule = '.'.join([packageSettings.packageName, algorithmSourceModule])
 
 	astModule = parseLogicalPath2astModule(logicalPathSourceModule)
-	countTheorem2 = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule)
-		, LedgerOfImports(astModule))
+	ingredientsFunction = 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(ingredientsFunction.astFunctionDef)
 	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
 
-	findThis = IfThis.isWhileAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	findThis = IfThis.isWhileAttributeNamespaceIdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
 	doThat = Grab.testAttribute(Grab.comparatorsAttribute(Then.replaceWith([Make.Constant(4)]))) # type: ignore
-	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
+	NodeChanger(findThis, doThat).visit(ingredientsFunction.astFunctionDef)
 
-	findThis = IfThis.isIfAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	findThis = IfThis.isIfAttributeNamespaceIdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
 	doThat = Then.extractIt(DOT.body)
-	insertLeaf = NodeTourist(findThis, doThat).captureLastMatch(countTheorem2.astFunctionDef)
-	findThis = IfThis.isIfAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	insertLeaf = NodeTourist(findThis, doThat).captureLastMatch(ingredientsFunction.astFunctionDef)
+	findThis = IfThis.isIfAttributeNamespaceIdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
 	doThat = Then.replaceWith(insertLeaf)
-	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
+	NodeChanger(findThis, doThat).visit(ingredientsFunction.astFunctionDef)
 
-	findThis = IfThis.isAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	findThis = IfThis.isAttributeNamespaceIdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
 	doThat = Then.removeIt
-	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
+	NodeChanger(findThis, doThat).visit(ingredientsFunction.astFunctionDef)
 
-	findThis = IfThis.isAttributeNamespace_IdentifierLessThanOrEqual0(dataclassInstanceIdentifier, 'leaf1ndex')
+	findThis = IfThis.isAttributeNamespaceIdentifierLessThanOrEqual0(dataclassInstanceIdentifier, 'leaf1ndex')
 	doThat = Then.removeIt
-	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
+	NodeChanger(findThis, doThat).visit(ingredientsFunction.astFunctionDef)
 
 	theCountingIdentifier = theCountingIdentifierHARDCODED
 	doubleTheCount = Make.AugAssign(Make.Attribute(ast.Name(dataclassInstanceIdentifier), theCountingIdentifier), ast.Mult(), Make.Constant(2))
 	findThis = Be.Return
 	doThat = Then.insertThisAbove([doubleTheCount])
-	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
+	NodeChanger(findThis, doThat).visit(ingredientsFunction.astFunctionDef)
+
+	ingredientsModule = IngredientsModule(ingredientsFunction)
 
-	ingredientsModule = IngredientsModule(countTheorem2)
+	if sourceCallableDispatcher is not None:
+		raise NotImplementedError('sourceCallableDispatcher is not implemented yet')
 
-	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
+	pathFilename = _getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier + packageSettings.fileExtension)
 
-	write_astModule(ingredientsModule, pathFilename, The.packageName)
+	write_astModule(ingredientsModule, pathFilename, packageSettings.packageName)
 
 	return pathFilename
 
@@ -365,11 +360,11 @@ def trimTheorem2(pathFilenameSource: PurePath) -> PurePath:
 
 	pathFilename = pathFilenameSource.with_stem(pathFilenameSource.stem + 'Trimmed')
 
-	write_astModule(ingredientsModule, pathFilename, The.packageName)
+	write_astModule(ingredientsModule, pathFilename, packageSettings.packageName)
 
 	logicalPath: list[str] = []
-	if The.packageName:
-		logicalPath.append(The.packageName)
+	if packageSettings.packageName:
+		logicalPath.append(packageSettings.packageName)
 	if logicalPathInfix:
 		logicalPath.append(logicalPathInfix)
 	logicalPath.append(pathFilename.stem)
@@ -385,7 +380,7 @@ def numbaOnTheorem2(pathFilenameSource: PurePath) -> ast.ImportFrom:
 	countNumbaTheorem2 = astModuleToIngredientsFunction(parsePathFilename2astModule(pathFilenameSource), sourceCallableIdentifier)
 	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: str | None = NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
 	if dataclass_Identifier is None: raise raiseIfNoneGitHubIssueNumber3
 
 	dataclassLogicalPathModule = None
@@ -413,11 +408,11 @@ def numbaOnTheorem2(pathFilenameSource: PurePath) -> ast.ImportFrom:
 
 	pathFilename = pathFilenameSource.with_stem(pathFilenameSource.stem.replace('Trimmed', '') + 'Numba')
 
-	write_astModule(ingredientsModule, pathFilename, The.packageName)
+	write_astModule(ingredientsModule, pathFilename, packageSettings.packageName)
 
 	logicalPath: list[str] = []
-	if The.packageName:
-		logicalPath.append(The.packageName)
+	if packageSettings.packageName:
+		logicalPath.append(packageSettings.packageName)
 	if logicalPathInfix:
 		logicalPath.append(logicalPathInfix)
 	logicalPath.append(pathFilename.stem)
@@ -428,11 +423,11 @@ def numbaOnTheorem2(pathFilenameSource: PurePath) -> ast.ImportFrom:
 	return astImportFrom
 
 def makeUnRePackDataclass(astImportFrom: ast.ImportFrom) -> None:
-	callableIdentifierHARDCODED: ast_Identifier = 'sequential'
+	callableIdentifierHARDCODED: str = 'sequential'
 
 	algorithmSourceModule = algorithmSourceModuleHARDCODED
-	sourceCallableIdentifier = The.sourceCallableDispatcher
-	logicalPathSourceModule = '.'.join([The.packageName, algorithmSourceModule])
+	sourceCallableIdentifier = sourceCallableDispatcherHARDCODED
+	logicalPathSourceModule = '.'.join([packageSettings.packageName, algorithmSourceModule])
 
 	logicalPathInfix = logicalPathInfixHARDCODED
 	moduleIdentifier = dataPackingModuleIdentifierHARDCODED
@@ -442,7 +437,7 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom) -> None:
 	ingredientsFunction.astFunctionDef.name = callableIdentifier
 	dataclassName: ast.expr | None = NodeTourist(Be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(ingredientsFunction.astFunctionDef)
 	if dataclassName is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclass_Identifier: ast_Identifier | None = NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
+	dataclass_Identifier: str | None = NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
 	if dataclass_Identifier is None: raise raiseIfNoneGitHubIssueNumber3
 
 	dataclassLogicalPathModule = None
@@ -476,15 +471,15 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom) -> None:
 	ingredientsModule = IngredientsModule(ingredientsFunction)
 	ingredientsModule.removeImportFromModule('numpy')
 
-	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
+	pathFilename = _getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier + packageSettings.fileExtension)
 
-	write_astModule(ingredientsModule, pathFilename, The.packageName)
+	write_astModule(ingredientsModule, pathFilename, packageSettings.packageName)
 
 if __name__ == '__main__':
-	makeInitializeGroupsOfFolds()
-	pathFilename = makeTheorem2()
+	makeInitializeGroupsOfFolds('initializeCount', 'initializeGroupsOfFolds', logicalPathInfixHARDCODED)
+	pathFilename = makeTheorem2('theorem2', None, logicalPathInfixHARDCODED)
 	pathFilename = trimTheorem2(pathFilename)
 	astImportFrom = numbaOnTheorem2(pathFilename)
 	makeUnRePackDataclass(astImportFrom)
-	pathFilename = makeDaoOfMapFolding()
+	pathFilename = makeDaoOfMapFolding('daoOfMapFolding', None, logicalPathInfixHARDCODED, sourceCallableDispatcherHARDCODED)
 	makeDaoOfMapFoldingParallel()

mapFolding/someAssemblyRequired/__init__.py

@@ -44,41 +44,15 @@ optimizations - while maintaining the ability to verify correctness at each tran
 test suite.
 """
 
-from astToolkit import (
-	ast_expr_Slice as ast_expr_Slice,
-	ast_Identifier as ast_Identifier,
-	astModuleToIngredientsFunction as astModuleToIngredientsFunction,
-	Be as Be,
-	DOT as DOT,
-	extractClassDef as extractClassDef,
-	extractFunctionDef as extractFunctionDef,
-	Grab as Grab,
-	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,
-)
-
-from Z0Z_tools import importLogicalPath2Callable as importLogicalPath2Callable, importPathFilename2Callable as importPathFilename2Callable
-
-from astToolkit.transformationTools import (
-	inlineFunctionDef as inlineFunctionDef,
-	removeUnusedParameters as removeUnusedParameters,
-	unparseFindReplace as unparseFindReplace,
-	write_astModule as write_astModule,
+from mapFolding.someAssemblyRequired.infoBooth import (
+	dataclassInstanceIdentifierHardcoded as dataclassInstanceIdentifierHardcoded,
+	raiseIfNoneGitHubIssueNumber3 as raiseIfNoneGitHubIssueNumber3,
+	sourceCallableDispatcherHARDCODED as sourceCallableDispatcherHARDCODED,
 )
 
 from mapFolding.someAssemblyRequired._toolIfThis import IfThis as IfThis
 
 from mapFolding.someAssemblyRequired._toolkitContainers import (
 	DeReConstructField2ast as DeReConstructField2ast,
-	RecipeSynthesizeFlow as RecipeSynthesizeFlow,
 	ShatteredDataclass as ShatteredDataclass,
 )

mapFolding/someAssemblyRequired/_toolIfThis.py

@@ -19,9 +19,8 @@ they implement a declarative approach to AST manipulation that separates node id
 (be), and data access (DOT).
 """
 
-from astToolkit import IfThis as astToolkit_IfThis
+from astToolkit import Be, DOT, IfThis as astToolkit_IfThis
 from collections.abc import Callable
-from mapFolding.someAssemblyRequired import ast_Identifier, Be, DOT
 from typing import TypeGuard
 import ast
 
@@ -37,23 +36,23 @@ class IfThis(astToolkit_IfThis):
 	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]:
+	def isAttributeNamespaceIdentifierGreaterThan0(namespace: str, identifier: str) -> Callable[[ast.AST], TypeGuard[ast.Compare] | bool]:
 		return lambda node: (Be.Compare(node)
 					and IfThis.isAttributeNamespace_Identifier(namespace, identifier)(DOT.left(node))
 					and 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]:
+	def isIfAttributeNamespaceIdentifierGreaterThan0(namespace: str, identifier: str) -> Callable[[ast.AST], TypeGuard[ast.If] | bool]:
 		return lambda node: (Be.If(node)
-					and IfThis.isAttributeNamespace_IdentifierGreaterThan0(namespace, identifier)(DOT.test(node)))
+					and IfThis.isAttributeNamespaceIdentifierGreaterThan0(namespace, identifier)(DOT.test(node)))
 
 	@staticmethod
-	def isWhileAttributeNamespace_IdentifierGreaterThan0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.While] | bool]:
+	def isWhileAttributeNamespaceIdentifierGreaterThan0(namespace: str, identifier: str) -> Callable[[ast.AST], TypeGuard[ast.While] | bool]:
 		return lambda node: (Be.While(node)
-					and IfThis.isAttributeNamespace_IdentifierGreaterThan0(namespace, identifier)(DOT.test(node)))
+					and IfThis.isAttributeNamespaceIdentifierGreaterThan0(namespace, identifier)(DOT.test(node)))
 
 	@staticmethod
-	def isAttributeNamespace_IdentifierLessThanOrEqual0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Compare] | bool]:
+	def isAttributeNamespaceIdentifierLessThanOrEqual0(namespace: str, identifier: str) -> Callable[[ast.AST], TypeGuard[ast.Compare] | bool]:
 		return lambda node: (Be.Compare(node)
 					and IfThis.isAttributeNamespace_Identifier(namespace, identifier)(DOT.left(node))
 					and Be.LtE(node.ops[0]))