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

mapFolding/someAssemblyRequired/makingModules_doTheNeedful.py

@@ -1,23 +1,16 @@
 """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: PathLike[str] | PurePath | identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
+def makeInitializeState(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
 	"""Generate initialization module for counting variable setup.
 
 	(AI generated docstring)
@@ -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,54 +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) -> None:
-	"""Generate interface module for dataclass unpacking and repacking operations.
-
-	Parameters
-	----------
-	astImportFrom : ast.ImportFrom
-		Import statement specifying the target optimized function to call.
-
-	Returns
-	-------
-	None
-		The generated module is written directly to the filesystem.
-
-	"""
-	callableIdentifierHARDCODED: str = 'sequential'
-
-	algorithmSourceModule: identifierDotAttribute = identifierModuleSourceAlgorithmDEFAULT
-	callableIdentifier: identifierDotAttribute = callableIdentifierHARDCODED
-	logicalPathInfix: identifierDotAttribute = logicalPathInfixDEFAULT
-	logicalPathInfixAlgorithm: identifierDotAttribute = logicalPathInfixAlgorithmDEFAULT
-	sourceCallableIdentifier: identifierDotAttribute = 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)
-

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 (
-	makeDaoOfMapFoldingNumba, makeTheorem2, numbaOnTheorem2, trimTheorem2)
-from mapFolding.someAssemblyRequired.makingModules_doTheNeedful import makeInitializeState, makeUnRePackDataclass
-from mapFolding.someAssemblyRequired.toolkitMakeModules import getLogicalPath, getModule, getPathFilename
+	makeMapFoldingNumba, makeTheorem2, numbaOnTheorem2, trimTheorem2)
+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 = makeDaoOfMapFoldingNumba(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, None)
+	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,24 +3,22 @@ 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 os import PathLike
 from pathlib import PurePath
 import ast
 
 identifierDataclassNumPyHARDCODED = 'MatrixMeandersNumPyState'
 
-logicalPathInfixMeanders: str = logicalPathInfixDEFAULT + '.meanders'
+logicalPathInfixMeanders: str = default['logicalPath']['synthetic'] + '.meanders'
 
-def makeCountBigInt(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:
+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)
 
@@ -36,29 +34,32 @@ def makeCountBigInt(astModule: ast.Module, moduleIdentifier: str, callableIdenti
 			, Grab.nameAttribute(Then.replaceWith(identifierDataclassNumPy))
 		).visit(astModule)
 
-	# while (state.kOfMatrix > 0 and areIntegersWide(state)):  # noqa: ERA001
+	# while (state.boundary > 0 and areIntegersWide(state)):  # noqa: ERA001
 	Call_areIntegersWide: ast.Call = Make.Call(Make.Name('areIntegersWide'), listParameters=[Make.Name('state')])
 	astCompare: ast.Compare = raiseIfNone(NodeTourist(
-		findThis=IfThis.isAttributeNamespaceIdentifierGreaterThan0(identifierDataclassInstance, 'kOfMatrix')
+		findThis=IfThis.isAttributeNamespaceIdentifierGreaterThan0(identifierDataclassInstance, 'boundary')
 		, doThat=Then.extractIt
 	).captureLastMatch(astModule))
 	newTest: ast.expr = Make.And.join([astCompare, Call_areIntegersWide])
 
-	NodeChanger(IfThis.isWhileAttributeNamespaceIdentifierGreaterThan0(identifierDataclassInstance, 'kOfMatrix')
+	NodeChanger(IfThis.isWhileAttributeNamespaceIdentifierGreaterThan0(identifierDataclassInstance, 'boundary')
 			, Grab.testAttribute(Then.replaceWith(newTest))
 	).visit(astModule)
 
 	# from mapFolding.algorithms.matrixMeandersBeDry import areIntegersWide  # noqa: ERA001
 	astModule.body.insert(0, Make.ImportFrom('mapFolding.algorithms.matrixMeandersBeDry', list_alias=[Make.alias('areIntegersWide')]))
 
-	pathFilename = getPathFilename(logicalPathInfix=logicalPathInfix, moduleIdentifier=moduleIdentifier)
+	pathFilename: PurePath = getPathFilename(logicalPathInfix=logicalPathInfix, identifierModule=identifierModule)
 
 	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
 
 	return pathFilename
 
-if __name__ == '__main__':
-	astModule = getModule(logicalPathInfix='algorithms', moduleIdentifier='matrixMeanders')
-	pathFilename = makeCountBigInt(astModule, 'bigInt', 'countBigInt', logicalPathInfixMeanders, identifierCallableSourceDispatcherDEFAULT)
+def makeMeandersModules() -> None:
+	"""Make meanders modules."""
+	astModule: ast.Module = getModule(logicalPathInfix='algorithms', identifierModule='matrixMeanders')
+	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
@@ -85,32 +85,32 @@ def findDataclass(ingredientsFunction: IngredientsFunction) -> tuple[identifierD
 	identifierDataclassInstance: identifierDotAttribute = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
 	return raiseIfNone(logicalPathDataclass), identifierDataclass, identifierDataclassInstance
 
-def getLogicalPath(identifierPackage: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, *moduleIdentifier: str | None) -> identifierDotAttribute:
+def getLogicalPath(identifierPackage: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, *identifierModule: str | None) -> identifierDotAttribute:
 	"""Get logical path from components."""
 	listLogicalPathParts: list[str] = []
 	if identifierPackage:
 		listLogicalPathParts.append(identifierPackage)
 	if logicalPathInfix:
 		listLogicalPathParts.append(logicalPathInfix)
-	if moduleIdentifier:
-		listLogicalPathParts.extend([module for module in moduleIdentifier if module is not None])
+	if identifierModule:
+		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, moduleIdentifier: 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, moduleIdentifier)
+	logicalPathSourceModule: identifierDotAttribute = getLogicalPath(identifierPackage, logicalPathInfix, identifierModule)
 	astModule: ast.Module = parseLogicalPath2astModule(logicalPathSourceModule)
 	return astModule
 
-def getPathFilename(pathRoot: PathLike[str] | PurePath | None = packageSettings.pathPackage, logicalPathInfix: PathLike[str] | PurePath | str | None = None, moduleIdentifier: str = '', fileExtension: str = packageSettings.fileExtension) -> PurePath:
+def getPathFilename(pathRoot: PathLike[str] | PurePath | None = packageSettings.pathPackage, logicalPathInfix: identifierDotAttribute | None = None, identifierModule: str = '', fileExtension: str = packageSettings.fileExtension) -> PurePath:
 	"""Construct filesystem path from logical path.
 
 	Parameters
 	----------
 	pathRoot : PathLike[str] | PurePath | None = packageSettings.pathPackage
 		Base directory for the package structure.
-	logicalPathInfix : PathLike[str] | PurePath | str | None = None
-		Subdirectory for organizing generated modules.
+	logicalPathInfix : identifierDotAttribute | None = None
+		Logical path in dot notation.
 	moduleIdentifier : str = ''
 		Name of the specific module file.
 	fileExtension : str = packageSettings.fileExtension
@@ -122,7 +122,7 @@ def getPathFilename(pathRoot: PathLike[str] | PurePath | None = packageSettings.
 		Complete filesystem path for the generated module file.
 
 	"""
-	pathFilename = PurePath(moduleIdentifier + fileExtension)
+	pathFilename = PurePath(identifierModule + fileExtension)
 	if logicalPathInfix:
 		pathFilename = PurePath(*(str(logicalPathInfix).split('.')), pathFilename)
 	if pathRoot:

mapFolding/someAssemblyRequired/toolkitNumba.py

@@ -281,7 +281,7 @@ def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, paramete
 	return ingredientsFunction
 
 @dataclasses.dataclass
-class SpicesJobNumba:
+class SpicesJobNumba: # slots?
 	"""Configuration container for Numba-specific job processing options.
 
 	(AI generated docstring)

mapFolding/someAssemblyRequired/transformationTools.py

@@ -34,7 +34,7 @@ from mapFolding.someAssemblyRequired import DeReConstructField2ast, IfThis, Shat
 import ast
 import dataclasses
 
-def shatter_dataclassesDOTdataclass(logicalPathModule: identifierDotAttribute, dataclassIdentifier: str, instanceIdentifier: str) -> ShatteredDataclass:
+def shatter_dataclassesDOTdataclass(logicalPathDataclass: identifierDotAttribute, identifierDataclass: str, identifierDataclassInstance: str) -> ShatteredDataclass:
 	"""Decompose a dataclass definition into AST components for manipulation and code generation.
 
 	(AI generated docstring)
@@ -77,19 +77,19 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: identifierDotAttribute, d
 	Official_fieldOrder: list[str] = []
 	dictionaryDeReConstruction: dict[str, DeReConstructField2ast] = {}
 
-	dataclassClassDef: ast.ClassDef | None = extractClassDef(parseLogicalPath2astModule(logicalPathModule), dataclassIdentifier)
+	dataclassClassDef: ast.ClassDef | None = extractClassDef(parseLogicalPath2astModule(logicalPathDataclass), identifierDataclass)
 	if not dataclassClassDef:
-		message = f"I could not find `{dataclassIdentifier = }` in `{logicalPathModule = }`."
+		message: str = f"I could not find `{identifierDataclass = }` in `{logicalPathDataclass = }`."
 		raise ValueError(message)
 
-	countingVariable = None
-	for aField in dataclasses.fields(importLogicalPath2Identifier(logicalPathModule, dataclassIdentifier)): # pyright: ignore [reportArgumentType]
+	countingVariable: str | None = None
+	for aField in dataclasses.fields(importLogicalPath2Identifier(logicalPathDataclass, identifierDataclass)): # pyright: ignore [reportArgumentType]
 		Official_fieldOrder.append(aField.name)
-		dictionaryDeReConstruction[aField.name] = DeReConstructField2ast(logicalPathModule, dataclassClassDef, instanceIdentifier, aField)
+		dictionaryDeReConstruction[aField.name] = DeReConstructField2ast(logicalPathDataclass, dataclassClassDef, identifierDataclassInstance, aField)
 		if aField.metadata.get('theCountingIdentifier', False):
 			countingVariable = dictionaryDeReConstruction[aField.name].name
 	if countingVariable is None:
-		message = f"I could not find the counting variable in `{dataclassIdentifier = }` in `{logicalPathModule = }`."
+		message = f"I could not find the counting variable in `{identifierDataclass = }` in `{logicalPathDataclass = }`."
 		raise ValueError(message)
 
 	shatteredDataclass = ShatteredDataclass(
@@ -99,17 +99,18 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: identifierDotAttribute, d
 		Z0Z_field2AnnAssign={dictionaryDeReConstruction[field].name: dictionaryDeReConstruction[field].Z0Z_hack for field in Official_fieldOrder},
 		list_argAnnotated4ArgumentsSpecification=[dictionaryDeReConstruction[field].ast_argAnnotated for field in Official_fieldOrder],
 		list_keyword_field__field4init=[dictionaryDeReConstruction[field].ast_keyword_field__field for field in Official_fieldOrder if dictionaryDeReConstruction[field].init],
+		listIdentifiersStaticScalars=[dictionaryDeReConstruction[field].name for field in Official_fieldOrder if (dictionaryDeReConstruction[field].Z0Z_hack[1] == 'scalar' and not dictionaryDeReConstruction[field].init)],
 		listAnnotations=[dictionaryDeReConstruction[field].astAnnotation for field in Official_fieldOrder],
 		listName4Parameters=[dictionaryDeReConstruction[field].astName for field in Official_fieldOrder],
 		listUnpack=[Make.AnnAssign(dictionaryDeReConstruction[field].astName, dictionaryDeReConstruction[field].astAnnotation, dictionaryDeReConstruction[field].ast_nameDOTname) for field in Official_fieldOrder],
 		map_stateDOTfield2Name={dictionaryDeReConstruction[field].ast_nameDOTname: dictionaryDeReConstruction[field].astName for field in Official_fieldOrder},
 		)
 	shatteredDataclass.fragments4AssignmentOrParameters = Make.Tuple(shatteredDataclass.listName4Parameters, ast.Store())
-	shatteredDataclass.repack = Make.Assign([Make.Name(instanceIdentifier)], value=Make.Call(Make.Name(dataclassIdentifier), list_keyword=shatteredDataclass.list_keyword_field__field4init))
+	shatteredDataclass.repack = Make.Assign([Make.Name(identifierDataclassInstance)], value=Make.Call(Make.Name(identifierDataclass), list_keyword=shatteredDataclass.list_keyword_field__field4init))
 	shatteredDataclass.signatureReturnAnnotation = Make.Subscript(Make.Name('tuple'), Make.Tuple(shatteredDataclass.listAnnotations))
 
 	shatteredDataclass.imports.update(*(dictionaryDeReConstruction[field].ledger for field in Official_fieldOrder))
-	shatteredDataclass.imports.addImportFrom_asStr(logicalPathModule, dataclassIdentifier)
+	shatteredDataclass.imports.addImportFrom_asStr(logicalPathDataclass, identifierDataclass)
 
 	return shatteredDataclass
 
@@ -145,12 +146,11 @@ def removeDataclassFromFunction(ingredientsTarget: IngredientsFunction, shattere
 	"""
 	ingredientsTarget.astFunctionDef.args = Make.arguments(list_arg=shatteredDataclass.list_argAnnotated4ArgumentsSpecification)
 	ingredientsTarget.astFunctionDef.returns = shatteredDataclass.signatureReturnAnnotation
-	changeReturnCallable = NodeChanger(Be.Return, Then.replaceWith(Make.Return(shatteredDataclass.fragments4AssignmentOrParameters)))
-	changeReturnCallable.visit(ingredientsTarget.astFunctionDef)
+	NodeChanger(Be.Return, Then.replaceWith(Make.Return(shatteredDataclass.fragments4AssignmentOrParameters))).visit(ingredientsTarget.astFunctionDef)
 	ingredientsTarget.astFunctionDef = unparseFindReplace(ingredientsTarget.astFunctionDef, shatteredDataclass.map_stateDOTfield2Name)
 	return ingredientsTarget
 
-def unpackDataclassCallFunctionRepackDataclass(ingredientsCaller: IngredientsFunction, targetCallableIdentifier: str, shatteredDataclass: ShatteredDataclass) -> IngredientsFunction:
+def unpackDataclassCallFunctionRepackDataclass(ingredientsCaller: IngredientsFunction, identifierCallee: str, shatteredDataclass: ShatteredDataclass) -> IngredientsFunction:
 	"""Transform a caller function to interface with a dataclass-free target function.
 
 	(AI generated docstring)
@@ -184,12 +184,10 @@ def unpackDataclassCallFunctionRepackDataclass(ingredientsCaller: IngredientsFun
 		The modified caller function with appropriate unpacking and repacking around the target call.
 
 	"""
-	astCallTargetCallable = Make.Call(Make.Name(targetCallableIdentifier), shatteredDataclass.listName4Parameters)
-	replaceAssignTargetCallable = NodeChanger(Be.Assign.valueIs(IfThis.isCallIdentifier(targetCallableIdentifier)), Then.replaceWith(Make.Assign([shatteredDataclass.fragments4AssignmentOrParameters], value=astCallTargetCallable)))
-	unpack4targetCallable = NodeChanger(Be.Assign.valueIs(IfThis.isCallIdentifier(targetCallableIdentifier)), Then.insertThisAbove(shatteredDataclass.listUnpack))
-	repack4targetCallable = NodeChanger(Be.Assign.valueIs(IfThis.isCallIdentifier(targetCallableIdentifier)), Then.insertThisBelow([shatteredDataclass.repack]))
-	replaceAssignTargetCallable.visit(ingredientsCaller.astFunctionDef)
-	unpack4targetCallable.visit(ingredientsCaller.astFunctionDef)
-	repack4targetCallable.visit(ingredientsCaller.astFunctionDef)
+	AssignAndCall: ast.Assign = Make.Assign([shatteredDataclass.fragments4AssignmentOrParameters], value=Make.Call(Make.Name(identifierCallee), shatteredDataclass.listName4Parameters))
+	NodeChanger(Be.Assign.valueIs(IfThis.isCallIdentifier(identifierCallee)), Then.replaceWith(AssignAndCall)).visit(ingredientsCaller.astFunctionDef)
+	NodeChanger(Be.Assign.valueIs(IfThis.isCallIdentifier(identifierCallee)), Then.insertThisAbove(shatteredDataclass.listUnpack)).visit(ingredientsCaller.astFunctionDef)
+	NodeChanger(Be.Assign.valueIs(IfThis.isCallIdentifier(identifierCallee)), Then.insertThisBelow([shatteredDataclass.repack])).visit(ingredientsCaller.astFunctionDef)
 	return ingredientsCaller
 
+