mapFolding 0.16.2__py3-none-any.whl → 0.16.4__py3-none-any.whl

mapFolding/someAssemblyRequired/makeJobTheorem2codon.py

@@ -4,59 +4,31 @@ https://docs.exaloop.io/start/install/
 """
 
 from astToolkit import (
-	Be, DOT, extractFunctionDef, Grab, identifierDotAttribute, IngredientsFunction, IngredientsModule, Make, NodeChanger,
-	NodeTourist, parseLogicalPath2astModule, Then)
+	Be, extractFunctionDef, Grab, identifierDotAttribute, IngredientsFunction, IngredientsModule, Make, NodeChanger,
+	parseLogicalPath2astModule, Then)
 from astToolkit.transformationTools import removeUnusedParameters, write_astModule
-from hunterMakesPy import autoDecodingRLE, raiseIfNone
-from mapFolding import DatatypeLeavesTotal, getPathFilenameFoldsTotal
+from hunterMakesPy import raiseIfNone
+from mapFolding import DatatypeLeavesTotal, getPathFilenameFoldsTotal, packageSettings
 from mapFolding.dataBaskets import MapFoldingState
-from mapFolding.someAssemblyRequired import IfThis
-from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2
-from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
+from mapFolding.someAssemblyRequired import DatatypeConfiguration, default, IfThis
+from mapFolding.someAssemblyRequired.RecipeJob import (
+	customizeDatatypeViaImport, moveShatteredDataclass_arg2body, RecipeJobTheorem2)
+from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
 from pathlib import Path, PurePosixPath
-from typing import cast, NamedTuple, TYPE_CHECKING
-import ast
+from typing import cast, TYPE_CHECKING
 import subprocess
 import sys
 
 if TYPE_CHECKING:
 	from io import TextIOBase
+	import ast
 
-class DatatypeConfiguration(NamedTuple):
-	"""Configuration for mapping framework datatypes to compiled datatypes.
+# TODO Converge with `makeJobTheorem2Numba`.
 
-	This configuration class defines how abstract datatypes used in the map folding framework should be replaced with compiled
-	datatypes during code generation. Each configuration specifies the source module, target type name, and optional import alias
-	for the transformation.
-
-	Attributes
-	----------
-	datatypeIdentifier : str
-		Framework datatype identifier to be replaced.
-	typeModule : identifierDotAttribute
-		Module containing the target datatype (e.g., 'codon', 'numpy').
-	typeIdentifier : str
-		Concrete type name in the target module.
-	type_asname : str | None = None
-		Optional import alias for the type.
-	"""
-
-	datatypeIdentifier: str
-	typeModule: identifierDotAttribute
-	typeIdentifier: str
-	type_asname: str | None = None
-
-# TODO replace with dynamic system. Probably use `Final` in the dataclass.
-listIdentifiersStaticValuesHARDCODED: list[str] = ['dimensionsTotal', 'leavesTotal']
-
-# TODO Dynamically calculate the bitwidth of each datatype.
 listDatatypeConfigurations: list[DatatypeConfiguration] = [
 	DatatypeConfiguration(datatypeIdentifier='DatatypeLeavesTotal', typeModule='numpy', typeIdentifier='uint8', type_asname='DatatypeLeavesTotal'),
 	DatatypeConfiguration(datatypeIdentifier='DatatypeElephino', typeModule='numpy', typeIdentifier='uint8', type_asname='DatatypeElephino'),
 	DatatypeConfiguration(datatypeIdentifier='DatatypeFoldsTotal', typeModule='numpy', typeIdentifier='int64', type_asname='DatatypeFoldsTotal'),
-]
-
-listNumPy_dtype: list[DatatypeConfiguration] = [
 	DatatypeConfiguration(datatypeIdentifier='Array1DLeavesTotal', typeModule='numpy', typeIdentifier='uint8', type_asname='Array1DLeavesTotal'),
 	DatatypeConfiguration(datatypeIdentifier='Array1DElephino', typeModule='numpy', typeIdentifier='uint8', type_asname='Array1DElephino'),
 	DatatypeConfiguration(datatypeIdentifier='Array3DLeavesTotal', typeModule='numpy', typeIdentifier='uint8', type_asname='Array3DLeavesTotal'),
@@ -78,55 +50,60 @@ def _addWriteFoldsTotal(ingredientsFunction: IngredientsFunction, job: RecipeJob
 
 	return ingredientsFunction
 
-def _datatypeDefinitions(ingredientsFunction: IngredientsFunction, ingredientsModule: IngredientsModule) -> tuple[IngredientsFunction, IngredientsModule]:
-	for datatypeConfig in [*listDatatypeConfigurations, *listNumPy_dtype]:
-		ingredientsFunction.imports.removeImportFrom(datatypeConfig.typeModule, None, datatypeConfig.datatypeIdentifier)
-		ingredientsFunction.imports.addImportFrom_asStr(datatypeConfig.typeModule, datatypeConfig.typeIdentifier, datatypeConfig.type_asname)
-
-	ingredientsFunction.imports.removeImportFromModule('mapFolding.dataBaskets')
+def _variableCompatibility(ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2) -> IngredientsFunction:
+	"""Ensure the variable is compiled to the correct type.
 
-	return ingredientsFunction, ingredientsModule
+	Add a type constructor to `identifier` to ensure compatibility if
+	- an incompatible type might be assigned to it,
+	- it might be compared with an incompatible type,
+	- it is used as an indexer but its type is not a valid indexer type.
 
-def _pythonCode2expr(string: str) -> ast.expr:
-	"""Convert *one* expression as a string of Python code to an `ast.expr`."""
-	return raiseIfNone(NodeTourist(Be.Expr, Then.extractIt(DOT.value)).captureLastMatch(ast.parse(string)))
+	Parameters
+	----------
+	ingredientsFunction : IngredientsFunction
+		Function to modify.
+	job : RecipeJobTheorem2
+		Configuration settings with identifiers and their type annotations.
 
-def _variableCompatibility(ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2) -> IngredientsFunction:
-	# On some assignment or comparison values, add a type constructor to ensure compatibility.
-	# On some values-as-indexer, add a type constructor to ensure indexing-method compatibility.
+	Returns
+	-------
+	ingredientsFunction : IngredientsFunction
+		Modified function.
+	"""
 	for ast_arg in job.shatteredDataclass.list_argAnnotated4ArgumentsSpecification:
-		identifier = ast_arg.arg
-		annotation = raiseIfNone(ast_arg.annotation)
-
-		# `identifier` in Augmented Assignment, or in Assignments and value is Constant.
-		NodeChanger(findThis=IfThis.isAnyOf(
-				Be.AugAssign.targetIs(IfThis.isNestedNameIdentifier(identifier))
-				, IfThis.isAllOf(
-					Be.Assign.targetsIs(Be.at(0, IfThis.isNestedNameIdentifier(identifier)))
-					, Be.Assign.valueIs(Be.Constant))
+		identifier: str = ast_arg.arg
+		annotation: ast.expr = raiseIfNone(ast_arg.annotation)
+
+	# ------- `identifier` is target of Augmented Assignment, or --------------
+	# ------- `identifier` is target of Assignment and value is Constant. -----
+		NodeChanger(
+			IfThis.isAnyOf(
+							Be.AugAssign.targetIs(IfThis.isNestedNameIdentifier(identifier))
+			,   IfThis.isAllOf(Be.Assign.targetsIs(Be.at(0, IfThis.isNestedNameIdentifier(identifier)))
+							,  Be.Assign.valueIs(Be.Constant))
 			)
 			, doThat=lambda node, annotation=annotation: Grab.valueAttribute(Then.replaceWith(Make.Call(annotation, listParameters=[node.value])))(node)
 		).visit(ingredientsFunction.astFunctionDef)
 
-		# `identifier` - 1.
+	# ------- `identifier` - 1. ----------------------------------------------
 		NodeChanger(Be.BinOp.leftIs(IfThis.isNestedNameIdentifier(identifier))
 			, doThat=lambda node, annotation=annotation: Grab.rightAttribute(Then.replaceWith(Make.Call(annotation, listParameters=[node.right])))(node)
 		).visit(ingredientsFunction.astFunctionDef)
 
-		# `identifier` in Comparison.
+	# ------- `identifier` in Comparison. -------------------------------------
 		NodeChanger(Be.Compare.leftIs(IfThis.isNestedNameIdentifier(identifier))
 			, doThat=lambda node, annotation=annotation: Grab.comparatorsAttribute(lambda at, annotation=annotation: Then.replaceWith([Make.Call(annotation, listParameters=[node.comparators[0]])])(at[0]))(node)
 		).visit(ingredientsFunction.astFunctionDef)
 
-		# `identifier` has exactly one index value.
+	# ------- `identifier` has exactly one index value. -----------------------
 		NodeChanger(IfThis.isAllOf(Be.Subscript.valueIs(IfThis.isNestedNameIdentifier(identifier))
 			, lambda node: not Be.Subscript.sliceIs(Be.Tuple)(node))
 			, doThat=lambda node: Grab.sliceAttribute(Then.replaceWith(Make.Call(Make.Name('int'), listParameters=[node.slice])))(node)
 		).visit(ingredientsFunction.astFunctionDef)
 
-		# `identifier` has multiple index values.
+	# ------- `identifier` has multiple index values. -------------------------
 		NodeChanger(IfThis.isAllOf(Be.Subscript.valueIs(IfThis.isNestedNameIdentifier(identifier))
-			, Be.Subscript.sliceIs(Be.Tuple))
+								,  Be.Subscript.sliceIs(Be.Tuple))
 			, doThat=lambda node: Grab.sliceAttribute(Grab.eltsAttribute(
 				Then.replaceWith([
 					Make.Call(Make.Name('int'), listParameters=[cast('ast.Tuple', node.slice).elts[index]])
@@ -135,19 +112,6 @@ def _variableCompatibility(ingredientsFunction: IngredientsFunction, job: Recipe
 
 	return ingredientsFunction
 
-def _move_arg2body(identifier: str, job: RecipeJobTheorem2) -> ast.AnnAssign | ast.Assign:
-	Ima___Assign, elementConstructor = job.shatteredDataclass.Z0Z_field2AnnAssign[identifier]
-	match elementConstructor:
-		case 'scalar':
-			cast('ast.Constant', cast('ast.Call', Ima___Assign.value).args[0]).value = int(job.state.__dict__[identifier])
-		case 'array':
-			dataAsStrRLE: str = autoDecodingRLE(job.state.__dict__[identifier], assumeAddSpaces=True)
-			dataAs_ast_expr: ast.expr = _pythonCode2expr(dataAsStrRLE)
-			cast('ast.Call', Ima___Assign.value).args = [dataAs_ast_expr]
-		case _:
-			pass
-	return Ima___Assign
-
 def makeJob(job: RecipeJobTheorem2) -> None:
 	"""Generate an optimized module for map folding calculations.
 
@@ -157,22 +121,21 @@ def makeJob(job: RecipeJobTheorem2) -> None:
 	Parameters
 	----------
 	job : RecipeJobTheorem2
-		Configuration recipe containing source locations, target paths, and state.
+		Configuration recipe containing source locations, target paths, raw materials, and state.
 
 	"""
 	ingredientsCount: IngredientsFunction = IngredientsFunction(raiseIfNone(extractFunctionDef(job.source_astModule, job.countCallable)))
 	ingredientsCount.astFunctionDef.decorator_list = []
 
 	# Replace identifiers-with-static-values with their values.
-	listIdentifiersStaticValues: list[str] = listIdentifiersStaticValuesHARDCODED
-	for identifier in listIdentifiersStaticValues:
+	for identifier in job.shatteredDataclass.listIdentifiersStaticScalars:
 		NodeChanger(IfThis.isNameIdentifier(identifier)
-			, Then.replaceWith(Make.Constant(int(job.state.__dict__[identifier])))
+			, Then.replaceWith(Make.Constant(int(eval(f"job.state.{identifier}"))))  # noqa: S307
 		).visit(ingredientsCount.astFunctionDef)
 
 	ingredientsCount.imports.update(job.shatteredDataclass.imports)
 	ingredientsCount = removeUnusedParameters(ingredientsCount)
-	NodeChanger(Be.arg, lambda removeIt: ingredientsCount.astFunctionDef.body.insert(0, _move_arg2body(removeIt.arg, job))).visit(ingredientsCount.astFunctionDef)
+	NodeChanger(Be.arg, lambda removeIt: ingredientsCount.astFunctionDef.body.insert(0, moveShatteredDataclass_arg2body(removeIt.arg, job))).visit(ingredientsCount.astFunctionDef)
 
 	ingredientsCount = _addWriteFoldsTotal(ingredientsCount, job)
 	ingredientsCount = _variableCompatibility(ingredientsCount, job)
@@ -181,11 +144,14 @@ def makeJob(job: RecipeJobTheorem2) -> None:
 		Make.If(Make.Compare(Make.Name('__name__'), [Make.Eq()], [Make.Constant('__main__')])
 			, body=[Make.Expr(Make.Call(Make.Name(job.countCallable)))])]))
 
-	ingredientsCount, ingredientsModule = _datatypeDefinitions(ingredientsCount, ingredientsModule)
+	ingredientsCount, ingredientsModule = customizeDatatypeViaImport(ingredientsCount, ingredientsModule, listDatatypeConfigurations)
+
+	ingredientsCount.imports.removeImportFromModule('mapFolding.dataBaskets')
 
 	ingredientsModule.appendIngredientsFunction(ingredientsCount)
 
 	if sys.platform == 'linux':
+		Path(job.pathFilenameModule).parent.mkdir(parents=True, exist_ok=True)
 		buildCommand: list[str] = ['codon', 'build', '--exe', '--release',
 			'--fast-math', '--enable-unsafe-fp-math', '--disable-exceptions',
 			'--mcpu=native',
@@ -200,6 +166,7 @@ def makeJob(job: RecipeJobTheorem2) -> None:
 		sys.stdout.write(f"sudo systemd-run --unit={job.moduleIdentifier} --nice=-10 --property=CPUAffinity=0 {job.pathFilenameModule.with_suffix('')}\n")
 	else:
 		write_astModule(ingredientsModule, pathFilename=job.pathFilenameModule, packageName=job.packageIdentifier)
+		sys.stdout.write(f"python {Path(job.pathFilenameModule)}\n")
 
 def fromMapShape(mapShape: tuple[DatatypeLeavesTotal, ...]) -> None:
 	"""Create a binary executable for a map-folding job from map dimensions.
@@ -214,14 +181,15 @@ def fromMapShape(mapShape: tuple[DatatypeLeavesTotal, ...]) -> None:
 		along one axis.
 
 	"""
-	state = transitionOnGroupsOfFolds(MapFoldingState(mapShape))
+	state: MapFoldingState = transitionOnGroupsOfFolds(MapFoldingState(mapShape))
 	pathModule = PurePosixPath(Path.home(), 'mapFolding', 'jobs')
-	source_astModule = parseLogicalPath2astModule('mapFolding.syntheticModules.theorem2A007822Numba')
+	logicalPath2astModule: identifierDotAttribute = f'{packageSettings.identifierPackage}.{default['logicalPath']['synthetic']}.theorem2Numba'
+	source_astModule: ast.Module = parseLogicalPath2astModule(logicalPath2astModule)
 	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
 	aJob = RecipeJobTheorem2(state, source_astModule=source_astModule, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
 	makeJob(aJob)
 
 if __name__ == '__main__':
-	mapShape = (1, 3)
+	mapShape: tuple[DatatypeLeavesTotal, ...] = (1, 14)
 	fromMapShape(mapShape)
 

mapFolding/someAssemblyRequired/makingModules_count.py

@@ -9,13 +9,11 @@ from astToolkit import (
 from astToolkit.transformationTools import inlineFunctionDef, removeUnusedParameters, write_astModule
 from hunterMakesPy import raiseIfNone
 from mapFolding import packageSettings
-from mapFolding.someAssemblyRequired import (
-	identifierCallableSourceDEFAULT, identifierCountingDEFAULT, IfThis, ShatteredDataclass)
+from mapFolding.someAssemblyRequired import default, IfThis, ShatteredDataclass
 from mapFolding.someAssemblyRequired.toolkitMakeModules import findDataclass, getLogicalPath, getPathFilename
 from mapFolding.someAssemblyRequired.toolkitNumba import decorateCallableWithNumba, parametersNumbaLight
 from mapFolding.someAssemblyRequired.transformationTools import (
 	removeDataclassFromFunction, shatter_dataclassesDOTdataclass, unpackDataclassCallFunctionRepackDataclass)
-from os import PathLike
 from pathlib import PurePath
 from typing import cast
 import ast
@@ -42,7 +40,7 @@ def makeMapFoldingNumba(astModule: ast.Module, identifierModule: str, identifier
 		Filesystem path where the optimized module was written.
 
 	"""
-	sourceCallableIdentifier: str = identifierCallableSourceDEFAULT
+	sourceCallableIdentifier: str = default['function']['counting']
 	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
 	ingredientsFunction.astFunctionDef.name = identifierCallable or sourceCallableIdentifier
 
@@ -107,13 +105,13 @@ def makeTheorem2(astModule: ast.Module, identifierModule: str, identifierCallabl
 	identifierCallableInitializeDataclass = identifierCallableInitializeDataclassHARDCODED
 	identifierModuleInitializeDataclass = identifierModuleInitializeDataclassHARDCODED
 
-	sourceCallableIdentifier = identifierCallableSourceDEFAULT
+	sourceCallableIdentifier = default['function']['counting']
 	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
 	ingredientsFunction.astFunctionDef.name = identifierCallable or sourceCallableIdentifier
 
 	dataclassInstanceIdentifier: str = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
 
-	theCountingIdentifier: str = identifierCountingDEFAULT
+	theCountingIdentifier: str = default['variable']['counting']
 	doubleTheCount: ast.AugAssign = Make.AugAssign(Make.Attribute(Make.Name(dataclassInstanceIdentifier), theCountingIdentifier), Make.Mult(), Make.Constant(2))
 
 	NodeChanger(
@@ -162,7 +160,7 @@ def makeTheorem2(astModule: ast.Module, identifierModule: str, identifierCallabl
 
 		# Update any calls to the original function name with the new target function name
 		NodeChanger(
-			findThis = Be.Call.funcIs(Be.Name.idIs(IfThis.isIdentifier(identifierCallableSourceDEFAULT)))
+			findThis = Be.Call.funcIs(Be.Name.idIs(IfThis.isIdentifier(default['function']['counting'])))
 			, doThat = Grab.funcAttribute(Grab.idAttribute(Then.replaceWith(targetCallableIdentifier)))
 		).visit(ingredientsFunctionDispatcher.astFunctionDef)
 
@@ -182,7 +180,7 @@ def makeTheorem2(astModule: ast.Module, identifierModule: str, identifierCallabl
 
 	return pathFilename
 
-def numbaOnTheorem2(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
+def numbaOnTheorem2(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:
 	"""Generate Numba-accelerated Theorem 2 implementation with dataclass decomposition.
 
 	Parameters
@@ -204,7 +202,7 @@ def numbaOnTheorem2(astModule: ast.Module, identifierModule: str, identifierCall
 		Filesystem path where the accelerated module was written.
 
 	"""
-	sourceCallableIdentifier = identifierCallableSourceDEFAULT
+	sourceCallableIdentifier = default['function']['counting']
 	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
 	ingredientsFunction.astFunctionDef.name = identifierCallable or sourceCallableIdentifier
 
@@ -244,7 +242,7 @@ def numbaOnTheorem2(astModule: ast.Module, identifierModule: str, identifierCall
 
 	return pathFilename
 
-def trimTheorem2(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
+def trimTheorem2(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:
 	"""Generate constrained Theorem 2 implementation by removing unnecessary logic.
 
 	Parameters
@@ -266,7 +264,7 @@ def trimTheorem2(astModule: ast.Module, identifierModule: str, identifierCallabl
 		Filesystem path where the trimmed module was written.
 
 	"""
-	sourceCallableIdentifier: str = identifierCallableSourceDEFAULT
+	sourceCallableIdentifier: str = default['function']['counting']
 	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
 	ingredientsFunction.astFunctionDef.name = identifierCallable or sourceCallableIdentifier
 
@@ -286,7 +284,7 @@ def trimTheorem2(astModule: ast.Module, identifierModule: str, identifierCallabl
 
 		# Update any calls to the original function name with the new target function name
 		NodeChanger(
-			findThis = Be.Call.funcIs(Be.Name.idIs(IfThis.isIdentifier(identifierCallableSourceDEFAULT)))
+			findThis = Be.Call.funcIs(Be.Name.idIs(IfThis.isIdentifier(default['function']['counting'])))
 			, doThat = Grab.funcAttribute(Grab.idAttribute(Then.replaceWith(targetCallableIdentifier)))
 		).visit(ingredientsFunctionDispatcher.astFunctionDef)
 

mapFolding/someAssemblyRequired/makingModules_doTheNeedful.py

@@ -1,20 +1,13 @@
 """Make functions that are complementary to the `count` function and are often called by `doTheNeedful`."""
 from astToolkit import (
-	astModuleToIngredientsFunction, Be, DOT, extractFunctionDef, Grab, identifierDotAttribute, IngredientsFunction,
-	IngredientsModule, LedgerOfImports, Make, NodeChanger, NodeTourist, parseLogicalPath2astModule, Then)
+	Be, DOT, Grab, identifierDotAttribute, IngredientsFunction, IngredientsModule, LedgerOfImports, NodeChanger,
+	NodeTourist, Then)
 from astToolkit.transformationTools import inlineFunctionDef, write_astModule
 from hunterMakesPy import raiseIfNone
 from mapFolding import packageSettings
-from mapFolding.someAssemblyRequired import (
-	identifierCallableSourceDEFAULT, identifierCallableSourceDispatcherDEFAULT, identifierCountingDEFAULT,
-	identifierModuleDataPackingDEFAULT, identifierModuleSourceAlgorithmDEFAULT, IfThis, logicalPathInfixAlgorithmDEFAULT,
-	logicalPathInfixDEFAULT, ShatteredDataclass)
-from mapFolding.someAssemblyRequired.toolkitMakeModules import findDataclass, getPathFilename
-from mapFolding.someAssemblyRequired.transformationTools import (
-	shatter_dataclassesDOTdataclass, unpackDataclassCallFunctionRepackDataclass)
-from os import PathLike
+from mapFolding.someAssemblyRequired import default, IfThis
+from mapFolding.someAssemblyRequired.toolkitMakeModules import getPathFilename
 from pathlib import PurePath
-from typing import cast
 import ast
 
 def makeInitializeState(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
@@ -49,12 +42,12 @@ def makeInitializeState(astModule: ast.Module, moduleIdentifier: str, callableId
 		Filesystem path where the initialization module was written.
 
 	"""
-	sourceCallableIdentifier: identifierDotAttribute = identifierCallableSourceDEFAULT
+	sourceCallableIdentifier: identifierDotAttribute = default['function']['counting']
 	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
 	ingredientsFunction.astFunctionDef.name = callableIdentifier or sourceCallableIdentifier
 
 	dataclassInstanceIdentifier: identifierDotAttribute = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
-	theCountingIdentifier: identifierDotAttribute = identifierCountingDEFAULT
+	theCountingIdentifier: identifierDotAttribute = default['variable']['counting']
 
 	findThis = IfThis.isWhileAttributeNamespaceIdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
 	doThat = Grab.testAttribute(Grab.andDoAllOf([Grab.opsAttribute(Then.replaceWith([ast.Eq()])), Grab.leftAttribute(Grab.attrAttribute(Then.replaceWith(theCountingIdentifier)))]))
@@ -64,58 +57,3 @@ def makeInitializeState(astModule: ast.Module, moduleIdentifier: str, callableId
 	write_astModule(IngredientsModule(ingredientsFunction), pathFilename, packageSettings.identifierPackage)
 
 	return pathFilename
-
-def makeUnRePackDataclass(astImportFrom: ast.ImportFrom, moduleIdentifier: str = identifierModuleDataPackingDEFAULT) -> PurePath:
-	"""Generate interface module for dataclass unpacking and repacking operations.
-
-	Parameters
-	----------
-	astImportFrom : ast.ImportFrom
-		Import statement specifying the target optimized function to call.
-
-	moduleIdentifier : str = identifierModuleDataPackingDEFAULT
-		Name for the generated interface module.
-
-	Returns
-	-------
-	pathFilename : PurePath
-		Filesystem path where the interface module was written.
-	"""
-	callableIdentifierHARDCODED: str = 'sequential'
-
-	algorithmSourceModule: identifierDotAttribute = identifierModuleSourceAlgorithmDEFAULT
-	callableIdentifier: str = callableIdentifierHARDCODED
-	logicalPathInfix: identifierDotAttribute = logicalPathInfixDEFAULT
-	logicalPathInfixAlgorithm: identifierDotAttribute = logicalPathInfixAlgorithmDEFAULT
-	sourceCallableIdentifier: str = identifierCallableSourceDispatcherDEFAULT
-
-	logicalPathSourceModule: identifierDotAttribute = '.'.join([packageSettings.identifierPackage, logicalPathInfixAlgorithm, algorithmSourceModule])  # noqa: FLY002
-
-	ingredientsFunction: IngredientsFunction = astModuleToIngredientsFunction(parseLogicalPath2astModule(logicalPathSourceModule), sourceCallableIdentifier)
-	ingredientsFunction.astFunctionDef.name = callableIdentifier
-
-	shatteredDataclass: ShatteredDataclass = shatter_dataclassesDOTdataclass(*findDataclass(ingredientsFunction))
-
-	ingredientsFunction.imports.update(shatteredDataclass.imports)
-	ingredientsFunction.imports.addAst(astImportFrom)
-	targetCallableIdentifier: str = astImportFrom.names[0].name
-	ingredientsFunction = raiseIfNone(unpackDataclassCallFunctionRepackDataclass(ingredientsFunction, targetCallableIdentifier, shatteredDataclass))
-	targetFunctionDef: ast.FunctionDef = raiseIfNone(extractFunctionDef(parseLogicalPath2astModule(raiseIfNone(astImportFrom.module)), targetCallableIdentifier))
-	astTuple: ast.Tuple = cast('ast.Tuple', raiseIfNone(NodeTourist(Be.Return.valueIs(Be.Tuple)
-			, doThat=Then.extractIt(DOT.value)).captureLastMatch(targetFunctionDef)))
-	astTuple.ctx = Make.Store()
-
-	changeAssignCallToTarget = NodeChanger(
-		findThis = Be.Assign.valueIs(IfThis.isCallIdentifier(targetCallableIdentifier))
-		, doThat = Then.replaceWith(Make.Assign([astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts))))
-	changeAssignCallToTarget.visit(ingredientsFunction.astFunctionDef)
-
-	ingredientsModule = IngredientsModule(ingredientsFunction)
-	ingredientsModule.removeImportFromModule('numpy')
-
-	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
-
-	write_astModule(ingredientsModule, pathFilename, packageSettings.identifierPackage)
-
-	return pathFilename
-

mapFolding/someAssemblyRequired/{mapFolding → mapFoldingModules}/makeMapFoldingModules.py

@@ -6,17 +6,14 @@ from astToolkit import (
 from astToolkit.transformationTools import inlineFunctionDef, removeUnusedParameters, write_astModule
 from hunterMakesPy import importLogicalPath2Identifier, raiseIfNone
 from mapFolding import packageSettings
-from mapFolding.someAssemblyRequired import (
-	DeReConstructField2ast, identifierCallableSourceDEFAULT, identifierCallableSourceDispatcherDEFAULT, IfThis,
-	logicalPathInfixDEFAULT, ShatteredDataclass)
+from mapFolding.someAssemblyRequired import default, DeReConstructField2ast, IfThis, ShatteredDataclass
 from mapFolding.someAssemblyRequired.makingModules_count import (
 	makeMapFoldingNumba, makeTheorem2, numbaOnTheorem2, trimTheorem2)
-from mapFolding.someAssemblyRequired.makingModules_doTheNeedful import makeInitializeState, makeUnRePackDataclass
-from mapFolding.someAssemblyRequired.toolkitMakeModules import getLogicalPath, getModule, getPathFilename
+from mapFolding.someAssemblyRequired.makingModules_doTheNeedful import makeInitializeState
+from mapFolding.someAssemblyRequired.toolkitMakeModules import getModule, getPathFilename
 from mapFolding.someAssemblyRequired.toolkitNumba import decorateCallableWithNumba, parametersNumbaLight
 from mapFolding.someAssemblyRequired.transformationTools import (
 	removeDataclassFromFunction, shatter_dataclassesDOTdataclass, unpackDataclassCallFunctionRepackDataclass)
-from os import PathLike
 from pathlib import PurePath
 from typing import Any, TYPE_CHECKING
 import ast
@@ -25,7 +22,7 @@ import dataclasses
 if TYPE_CHECKING:
 	from collections.abc import Sequence
 
-def makeDaoOfMapFoldingParallelNumba(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | str | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
+def makeDaoOfMapFoldingParallelNumba(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
 	"""Generate parallel implementation with concurrent execution and task division.
 
 	Parameters
@@ -47,11 +44,11 @@ def makeDaoOfMapFoldingParallelNumba(astModule: ast.Module, moduleIdentifier: st
 		Filesystem path where the parallel module was written.
 
 	"""
-	sourceCallableIdentifier = identifierCallableSourceDEFAULT
-	if callableIdentifier is None:
-		callableIdentifier = sourceCallableIdentifier
+	sourceCallableIdentifier = default['function']['counting']
+	if identifierCallable is None:
+		identifierCallable = sourceCallableIdentifier
 	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
-	ingredientsFunction.astFunctionDef.name = callableIdentifier
+	ingredientsFunction.astFunctionDef.name = identifierCallable
 
 	dataclassName: ast.expr = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(ingredientsFunction.astFunctionDef))
 	dataclassIdentifier: str = raiseIfNone(NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName))
@@ -69,10 +66,10 @@ def makeDaoOfMapFoldingParallelNumba(astModule: ast.Module, moduleIdentifier: st
 	dataclassInstanceIdentifier: identifierDotAttribute = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
 	shatteredDataclass: ShatteredDataclass = shatter_dataclassesDOTdataclass(dataclassLogicalPathModule, dataclassIdentifier, dataclassInstanceIdentifier)
 
-	# START add the parallel state fields to the count function ------------------------------------------------
-	dataclassBaseFields: tuple[dataclasses.Field[Any], ...] = dataclasses.fields(importLogicalPath2Identifier(dataclassLogicalPathModule, dataclassIdentifier))  # pyright: ignore [reportArgumentType]
+# START add the parallel state fields to the count function ------------------------------------------------
+	dataclassBaseFields: tuple[dataclasses.Field[Any], ...] = dataclasses.fields(importLogicalPath2Identifier(dataclassLogicalPathModule, dataclassIdentifier))
 	dataclassIdentifierParallel: identifierDotAttribute = 'Parallel' + dataclassIdentifier
-	dataclassFieldsParallel: tuple[dataclasses.Field[Any], ...] = dataclasses.fields(importLogicalPath2Identifier(dataclassLogicalPathModule, dataclassIdentifierParallel))  # pyright: ignore [reportArgumentType]
+	dataclassFieldsParallel: tuple[dataclasses.Field[Any], ...] = dataclasses.fields(importLogicalPath2Identifier(dataclassLogicalPathModule, dataclassIdentifierParallel))
 	onlyParallelFields: list[dataclasses.Field[Any]] = [field for field in dataclassFieldsParallel if field.name not in [fieldBase.name for fieldBase in dataclassBaseFields]]
 
 	Official_fieldOrder: list[str] = []
@@ -108,12 +105,12 @@ def makeDaoOfMapFoldingParallelNumba(astModule: ast.Module, moduleIdentifier: st
 	shatteredDataclassParallel.imports.update(shatteredDataclass.imports)
 	shatteredDataclassParallel.imports.removeImportFrom(dataclassLogicalPathModule, dataclassIdentifier)
 
-	# END add the parallel state fields to the count function ------------------------------------------------
+# END add the parallel state fields to the count function ------------------------------------------------
 
 	ingredientsFunction.imports.update(shatteredDataclassParallel.imports)
 	ingredientsFunction: IngredientsFunction = removeDataclassFromFunction(ingredientsFunction, shatteredDataclassParallel)
 
-	# START add the parallel logic to the count function ------------------------------------------------
+# START add the parallel logic to the count function ------------------------------------------------
 
 	findThis = Be.While.testIs(Be.Compare.leftIs(IfThis.isNameIdentifier('leafConnectee')))
 	captureCountGapsCodeBlock: NodeTourist[ast.While, Sequence[ast.stmt]] = NodeTourist(findThis, doThat = Then.extractIt(DOT.body))
@@ -127,20 +124,20 @@ def makeDaoOfMapFoldingParallelNumba(astModule: ast.Module, moduleIdentifier: st
 	countGapsCodeBlockNew: list[ast.stmt] = [thisIsMyTaskIndexCodeBlock, countGapsCodeBlock[-1]]
 	NodeChanger[ast.While, hasDOTbody](findThis, doThat = Grab.bodyAttribute(Then.replaceWith(countGapsCodeBlockNew))).visit(ingredientsFunction.astFunctionDef)
 
-	# END add the parallel logic to the count function ------------------------------------------------
+# END add the parallel logic to the count function ------------------------------------------------
 
 	ingredientsFunction = removeUnusedParameters(ingredientsFunction)
 
 	ingredientsFunction = decorateCallableWithNumba(ingredientsFunction, parametersNumbaLight)
 
-	# START unpack/repack the dataclass function ------------------------------------------------
-	sourceCallableIdentifier = identifierCallableSourceDispatcherDEFAULT
+# START unpack/repack the dataclass function ------------------------------------------------
+	sourceCallableIdentifier = default['function']['dispatcher']
 
 	unRepackDataclass: IngredientsFunction = astModuleToIngredientsFunction(astModule, sourceCallableIdentifier)
 	unRepackDataclass.astFunctionDef.name = 'unRepack' + dataclassIdentifierParallel
 	unRepackDataclass.imports.update(shatteredDataclassParallel.imports)
 	NodeChanger(
-			findThis = Be.arg.annotationIs(Be.Name.idIs(lambda thisAttribute: thisAttribute == dataclassIdentifier)) # pyright: ignore[reportArgumentType]
+			findThis = Be.arg.annotationIs(Be.Name.idIs(lambda thisAttribute: thisAttribute == dataclassIdentifier))
 			, doThat = Grab.annotationAttribute(Grab.idAttribute(Then.replaceWith(dataclassIdentifierParallel)))
 		).visit(unRepackDataclass.astFunctionDef)
 	unRepackDataclass.astFunctionDef.returns = Make.Name(dataclassIdentifierParallel)
@@ -187,7 +184,7 @@ def makeDaoOfMapFoldingParallelNumba(astModule: ast.Module, moduleIdentifier: st
 	)
 	ingredientsModule.removeImportFromModule('numpy')
 
-	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
 
 	write_astModule(ingredientsModule, pathFilename, packageSettings.identifierPackage)
 
@@ -196,25 +193,22 @@ def makeDaoOfMapFoldingParallelNumba(astModule: ast.Module, moduleIdentifier: st
 def makeMapFoldingModules() -> None:
 	"""Make multidimensional map folding modules."""
 	astModule = getModule(logicalPathInfix='algorithms')
-	pathFilename: PurePath = makeMapFoldingNumba(astModule, 'daoOfMapFoldingNumba', None, logicalPathInfixDEFAULT, identifierCallableSourceDispatcherDEFAULT)
+	pathFilename: PurePath = makeMapFoldingNumba(astModule, 'daoOfMapFoldingNumba', None, default['logicalPath']['synthetic'], default['function']['dispatcher'])
 
 	astModule = getModule(logicalPathInfix='algorithms')
-	pathFilename = makeDaoOfMapFoldingParallelNumba(astModule, 'countParallelNumba', None, logicalPathInfixDEFAULT, identifierCallableSourceDispatcherDEFAULT)
+	pathFilename = makeDaoOfMapFoldingParallelNumba(astModule, 'countParallelNumba', None, default['logicalPath']['synthetic'], default['function']['dispatcher'])
 
 	astModule: ast.Module = getModule(logicalPathInfix='algorithms')
-	makeInitializeState(astModule, 'initializeState', 'transitionOnGroupsOfFolds', logicalPathInfixDEFAULT)
+	makeInitializeState(astModule, default['module']['initializeState'], default['function']['initializeState'], default['logicalPath']['synthetic'])
 
 	astModule = getModule(logicalPathInfix='algorithms')
-	pathFilename = makeTheorem2(astModule, 'theorem2', None, logicalPathInfixDEFAULT, identifierCallableSourceDispatcherDEFAULT)
+	pathFilename = makeTheorem2(astModule, 'theorem2', None, default['logicalPath']['synthetic'], default['function']['dispatcher'])
 
 	astModule = parsePathFilename2astModule(pathFilename)
-	pathFilename = trimTheorem2(astModule, 'theorem2Trimmed', None, logicalPathInfixDEFAULT, None)
+	pathFilename = trimTheorem2(astModule, 'theorem2Trimmed', None, default['logicalPath']['synthetic'], default['function']['dispatcher'])
 
 	astModule = parsePathFilename2astModule(pathFilename)
-	pathFilename = numbaOnTheorem2(astModule, 'theorem2Numba', None, logicalPathInfixDEFAULT, None)
-
-	astImportFrom: ast.ImportFrom = Make.ImportFrom(getLogicalPath(packageSettings.identifierPackage, logicalPathInfixDEFAULT, 'theorem2Numba'), list_alias=[Make.alias(identifierCallableSourceDEFAULT)])
-	makeUnRePackDataclass(astImportFrom)
+	pathFilename = numbaOnTheorem2(astModule, 'theorem2Numba', None, default['logicalPath']['synthetic'], default['function']['dispatcher'])
 
 if __name__ == '__main__':
 	makeMapFoldingModules()

mapFolding/someAssemblyRequired/meanders/makeMeandersModules.py

@@ -3,8 +3,7 @@ from astToolkit import (
 	astModuleToIngredientsFunction, Be, Grab, identifierDotAttribute, Make, NodeChanger, NodeTourist, Then)
 from hunterMakesPy import raiseIfNone
 from mapFolding import packageSettings
-from mapFolding.someAssemblyRequired import (
-	identifierCallableSourceDEFAULT, identifierCallableSourceDispatcherDEFAULT, IfThis, logicalPathInfixDEFAULT)
+from mapFolding.someAssemblyRequired import default, IfThis
 from mapFolding.someAssemblyRequired.toolkitMakeModules import (
 	findDataclass, getModule, getPathFilename, write_astModule)
 from pathlib import PurePath
@@ -12,14 +11,14 @@ import ast
 
 identifierDataclassNumPyHARDCODED = 'MatrixMeandersNumPyState'
 
-logicalPathInfixMeanders: str = logicalPathInfixDEFAULT + '.meanders'
+logicalPathInfixMeanders: str = default['logicalPath']['synthetic'] + '.meanders'
 
 def makeCountBigInt(astModule: ast.Module, identifierModule: str, callableIdentifier: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:
 	"""Make `countBigInt` module for meanders using `MatrixMeandersNumPyState` dataclass."""
 	identifierDataclassNumPy: str = identifierDataclassNumPyHARDCODED
 	_logicalPathDataclass, identifierDataclassOld, identifierDataclassInstance = findDataclass(astModuleToIngredientsFunction(astModule, raiseIfNone(sourceCallableDispatcher)))
 
-	NodeChanger(findThis=Be.FunctionDef.nameIs(IfThis.isIdentifier(identifierCallableSourceDEFAULT))
+	NodeChanger(findThis=Be.FunctionDef.nameIs(IfThis.isIdentifier(default['function']['counting']))
 		, doThat=Grab.nameAttribute(Then.replaceWith(raiseIfNone(callableIdentifier)))
 	).visit(astModule)
 
@@ -56,8 +55,11 @@ def makeCountBigInt(astModule: ast.Module, identifierModule: str, callableIdenti
 
 	return pathFilename
 
-if __name__ == '__main__':
+def makeMeandersModules() -> None:
+	"""Make meanders modules."""
 	astModule: ast.Module = getModule(logicalPathInfix='algorithms', identifierModule='matrixMeanders')
-	pathFilename: PurePath = makeCountBigInt(astModule, 'bigInt', 'countBigInt', logicalPathInfixMeanders, identifierCallableSourceDispatcherDEFAULT)
+	pathFilename: PurePath = makeCountBigInt(astModule, 'bigInt', 'countBigInt', logicalPathInfixMeanders, default['function']['dispatcher'])
 
+if __name__ == '__main__':
+	makeMeandersModules()
 

mapFolding/someAssemblyRequired/toolkitMakeModules.py

@@ -36,7 +36,7 @@ from astToolkit import (
 from autoflake import fix_code as autoflake_fix_code
 from hunterMakesPy import raiseIfNone, writeStringToHere
 from mapFolding import packageSettings
-from mapFolding.someAssemblyRequired import identifierModuleSourceAlgorithmDEFAULT, logicalPathInfixDEFAULT
+from mapFolding.someAssemblyRequired import default
 from os import PathLike
 from pathlib import PurePath
 from typing import Any
@@ -96,7 +96,7 @@ def getLogicalPath(identifierPackage: str | None = None, logicalPathInfix: ident
 		listLogicalPathParts.extend([module for module in identifierModule if module is not None])
 	return '.'.join(listLogicalPathParts)
 
-def getModule(identifierPackage: str | None = packageSettings.identifierPackage, logicalPathInfix: identifierDotAttribute | None = logicalPathInfixDEFAULT, identifierModule: str | None = identifierModuleSourceAlgorithmDEFAULT) -> ast.Module:
+def getModule(identifierPackage: str | None = packageSettings.identifierPackage, logicalPathInfix: identifierDotAttribute | None = default['logicalPath']['synthetic'], identifierModule: str | None = default['module']['algorithm']) -> ast.Module:
 	"""Get Module."""
 	logicalPathSourceModule: identifierDotAttribute = getLogicalPath(identifierPackage, logicalPathInfix, identifierModule)
 	astModule: ast.Module = parseLogicalPath2astModule(logicalPathSourceModule)