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

mapFolding/someAssemblyRequired/A007822/makeA007822AsynchronousModules.py

@@ -0,0 +1,197 @@
+"""addSymmetryCheckAsynchronous."""
+from astToolkit import Be, extractFunctionDef, Grab, Make, NodeChanger, NodeTourist, parsePathFilename2astModule, Then
+from hunterMakesPy import raiseIfNone
+from mapFolding import packageSettings
+from mapFolding.someAssemblyRequired import IfThis, logicalPathInfixAlgorithmDEFAULT
+from mapFolding.someAssemblyRequired.A007822.A007822rawMaterials import (
+	A007822adjustFoldsTotal, astExprCall_filterAsymmetricFoldsDataclass, identifier_filterAsymmetricFolds,
+	identifierCounting, identifierDataclass, logicalPathInfixA007822, sourceCallableDispatcherA007822,
+	sourceCallableIdentifierA007822)
+from mapFolding.someAssemblyRequired.makingModules_count import makeTheorem2, numbaOnTheorem2, trimTheorem2
+from mapFolding.someAssemblyRequired.toolkitMakeModules import getModule, getPathFilename, write_astModule
+from os import PathLike
+from pathlib import PurePath
+import ast
+
+identifier_getAsymmetricFoldsTotal = 'getAsymmetricFoldsTotal'
+identifier_initializeConcurrencyManager = 'initializeConcurrencyManager'
+identifier_processCompletedFutures = '_processCompletedFutures'
+
+astExprCall_initializeConcurrencyManager: ast.Expr = Make.Expr(Make.Call(Make.Name(identifier_initializeConcurrencyManager)))
+AssignTotal2CountingIdentifier: ast.Assign = Make.Assign(
+	[Make.Attribute(Make.Name(identifierDataclass), identifierCounting, context=Make.Store())]
+	, value=Make.Call(Make.Name(identifier_getAsymmetricFoldsTotal))
+)
+
+def addSymmetryCheckAsynchronous(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | str | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
+	"""Add symmetry check to the counting function.
+
+	To do asynchronous filtering, a few things must happen.
+	1. When the algorithm finds a `groupOfFolds`, the call to `filterAsymmetricFolds` must be non-blocking.
+	2. Filtering the `groupOfFolds` into symmetric folds must start immediately, and run concurrently.
+	3. When filtering, the module must immediately discard `leafBelow` and sum the filtered folds into a global total.
+	4. Of course, the filtering must be complete before `getAsymmetricFoldsTotal` fulfills the request for the total.
+
+	Why _must_ those things happen?
+	1. Filtering takes as long as finding the `groupOfFolds`, so we can't block.
+	2. Filtering must start immediately to keep up with the finding process.
+	3. To discover A007822(27), which is currently unknown, I estimate there will be 369192702554 calls to filterAsymmetricFolds.
+	Each `leafBelow` array will be 28 * 8-bits, so if the queue has only 0.3% of the total calls in it, that is 28 GiB of data.
+	"""
+	astFunctionDef_count: ast.FunctionDef = raiseIfNone(NodeTourist(
+		findThis = Be.FunctionDef.nameIs(IfThis.isIdentifier(sourceCallableIdentifierA007822))
+		, doThat = Then.extractIt
+		).captureLastMatch(astModule))
+
+	NodeChanger(Be.Return, Then.insertThisAbove([A007822adjustFoldsTotal])).visit(astFunctionDef_count)
+
+	NodeChanger(
+		findThis=Be.AugAssign.targetIs(IfThis.isAttributeNamespaceIdentifier(identifierDataclass, identifierCounting))
+		, doThat=Then.replaceWith(astExprCall_filterAsymmetricFoldsDataclass)
+		).visit(astFunctionDef_count)
+
+	NodeChanger(
+		findThis=Be.While.testIs(IfThis.isCallIdentifier('activeLeafGreaterThan0'))
+		, doThat=Grab.orelseAttribute(Then.replaceWith([AssignTotal2CountingIdentifier]))
+	).visit(astFunctionDef_count)
+
+	NodeChanger(
+		findThis=Be.FunctionDef.nameIs(IfThis.isIdentifier(sourceCallableIdentifierA007822))
+		, doThat=Then.replaceWith(astFunctionDef_count)
+		).visit(astModule)
+
+	astFunctionDef_doTheNeedful: ast.FunctionDef = raiseIfNone(NodeTourist(
+		findThis = Be.FunctionDef.nameIs(IfThis.isIdentifier(sourceCallableDispatcher))
+		, doThat = Then.extractIt
+		).captureLastMatch(astModule))
+
+	astFunctionDef_doTheNeedful.body.insert(0, astExprCall_initializeConcurrencyManager)
+
+	NodeChanger(
+		findThis=Be.FunctionDef.nameIs(IfThis.isIdentifier(sourceCallableDispatcher))
+		, doThat=Then.replaceWith(astFunctionDef_doTheNeedful)
+		).visit(astModule)
+
+	astImportFrom = ast.ImportFrom(f'{packageSettings.identifierPackage}.{logicalPathInfix}.{moduleIdentifier}Annex'
+			, [Make.alias(identifier_filterAsymmetricFolds), Make.alias(identifier_getAsymmetricFoldsTotal), Make.alias(identifier_initializeConcurrencyManager)], 0)
+
+	astModule.body.insert(0, astImportFrom)
+
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
+	pathFilenameAnnex: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier + 'Annex')
+
+	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
+	del astModule
+# ----------------- Ingredients Module Annex ------------------------------------------------------------------------------
+	ImaString = """from concurrent.futures import Future as ConcurrentFuture, ThreadPoolExecutor
+from hunterMakesPy import raiseIfNone
+from mapFolding import Array1DLeavesTotal
+from queue import Empty, Queue
+from threading import Thread
+import numpy"""
+
+	astModule = ast.parse(ImaString)
+	del ImaString
+
+	ImaString = f"""concurrencyManager = None
+{identifierCounting}Total: int = 0
+processingThread = None
+queueFutures: Queue[ConcurrentFuture[int]] = Queue()
+	"""
+	astModule.body.extend(ast.parse(ImaString).body)
+	del ImaString
+
+	ImaString = f"""def {identifier_initializeConcurrencyManager}(maxWorkers: int | None = None, {identifierCounting}: int = 0) -> None:
+	global concurrencyManager, queueFutures, {identifierCounting}Total, processingThread
+	concurrencyManager = ThreadPoolExecutor(max_workers=maxWorkers)
+	queueFutures = Queue()
+	{identifierCounting}Total = {identifierCounting}
+	processingThread = Thread(target={identifier_processCompletedFutures})
+	processingThread.start()
+	"""
+	astModule.body.append(raiseIfNone(extractFunctionDef(ast.parse(ImaString), identifier_initializeConcurrencyManager)))
+	del ImaString
+
+	ImaString = f"""def {identifier_processCompletedFutures}() -> None:
+	global queueFutures, {identifierCounting}Total
+	while True:
+		try:
+			claimTicket: ConcurrentFuture[int] = queueFutures.get(timeout=1)
+			if claimTicket is None:
+				break
+			{identifierCounting}Total += claimTicket.result()
+		except Empty:
+			continue
+	"""
+	astModule.body.append(raiseIfNone(extractFunctionDef(ast.parse(ImaString), identifier_processCompletedFutures)))
+	del ImaString
+
+	ImaString = f"""def _{identifier_filterAsymmetricFolds}(leafBelow: Array1DLeavesTotal) -> int:
+	{identifierCounting} = 0
+	leafComparison: Array1DLeavesTotal = numpy.zeros_like(leafBelow)
+	leavesTotal = leafBelow.size - 1
+
+	indexLeaf = 0
+	leafConnectee = 0
+	while leafConnectee < leavesTotal + 1:
+		leafNumber = int(leafBelow[indexLeaf])
+		leafComparison[leafConnectee] = (leafNumber - indexLeaf + leavesTotal) % leavesTotal
+		indexLeaf = leafNumber
+		leafConnectee += 1
+
+	indexInMiddle = leavesTotal // 2
+	indexDistance = 0
+	while indexDistance < leavesTotal + 1:
+		ImaSymmetricFold = True
+		leafConnectee = 0
+		while leafConnectee < indexInMiddle:
+			if leafComparison[(indexDistance + leafConnectee) % (leavesTotal + 1)] != leafComparison[(indexDistance + leavesTotal - 1 - leafConnectee) % (leavesTotal + 1)]:
+				ImaSymmetricFold = False
+				break
+			leafConnectee += 1
+		{identifierCounting} += ImaSymmetricFold
+		indexDistance += 1
+	return {identifierCounting}
+	"""
+	astModule.body.append(raiseIfNone(extractFunctionDef(ast.parse(ImaString), f'_{identifier_filterAsymmetricFolds}')))
+	del ImaString
+
+	ImaString = f"""
+def {identifier_filterAsymmetricFolds}(leafBelow: Array1DLeavesTotal) -> None:
+	global concurrencyManager, queueFutures
+	queueFutures.put_nowait(raiseIfNone(concurrencyManager).submit(_{identifier_filterAsymmetricFolds}, leafBelow.copy()))
+	"""
+	astModule.body.append(raiseIfNone(extractFunctionDef(ast.parse(ImaString), identifier_filterAsymmetricFolds)))
+	del ImaString
+
+	ImaString = f"""
+def {identifier_getAsymmetricFoldsTotal}() -> int:
+	global concurrencyManager, queueFutures, processingThread
+	raiseIfNone(concurrencyManager).shutdown(wait=True)
+	queueFutures.put(None)
+	raiseIfNone(processingThread).join()
+	return {identifierCounting}Total
+	"""
+	astModule.body.append(raiseIfNone(extractFunctionDef(ast.parse(ImaString), identifier_getAsymmetricFoldsTotal)))
+	del ImaString
+
+	write_astModule(astModule, pathFilenameAnnex, packageSettings.identifierPackage)
+
+	return pathFilename
+
+def _makeA007822AsynchronousModules() -> None:
+
+	astModule = getModule(logicalPathInfix=logicalPathInfixAlgorithmDEFAULT)
+	pathFilename = addSymmetryCheckAsynchronous(astModule, 'asynchronous', None, logicalPathInfixA007822, sourceCallableDispatcherA007822)
+
+	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, moduleIdentifier='asynchronous')
+	pathFilename = makeTheorem2(astModule, 'asynchronousTheorem2', None, logicalPathInfixA007822, None)
+
+	astModule = parsePathFilename2astModule(pathFilename)
+	pathFilename = trimTheorem2(astModule, 'asynchronousTrimmed', None, logicalPathInfixA007822, None)
+
+	astModule = parsePathFilename2astModule(pathFilename)
+	pathFilename = numbaOnTheorem2(astModule, 'asynchronousNumba', None, logicalPathInfixA007822, None)
+
+if __name__ == '__main__':
+	_makeA007822AsynchronousModules()

mapFolding/someAssemblyRequired/A007822/makeA007822Modules.py

@@ -0,0 +1,74 @@
+"""addSymmetryCheck."""
+from astToolkit import Be, Make, NodeChanger, NodeTourist, parsePathFilename2astModule, Then
+from hunterMakesPy import raiseIfNone
+from mapFolding import packageSettings
+from mapFolding.someAssemblyRequired import (
+	identifierCallableSourceDEFAULT, identifierCountingDEFAULT, identifierDataclassInstanceDEFAULT, IfThis)
+from mapFolding.someAssemblyRequired.A007822.A007822rawMaterials import (
+	A007822adjustFoldsTotal, A007822incrementCount, FunctionDef_filterAsymmetricFolds, logicalPathInfixA007822,
+	sourceCallableDispatcherA007822, sourceCallableIdentifierA007822)
+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, write_astModule)
+from os import PathLike
+from pathlib import PurePath
+import ast
+
+def addSymmetryCheck(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | str | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
+	"""Add logic to check for symmetric folds."""
+# NOTE HEY HEY! Are you trying to figure out why there is more than one copy of `filterAsymmetricFolds`? See the TODO NOTE, below.
+
+	astFunctionDef_count: ast.FunctionDef = raiseIfNone(NodeTourist(
+		findThis = Be.FunctionDef.nameIs(IfThis.isIdentifier(identifierCallableSourceDEFAULT))
+		, doThat = Then.extractIt
+		).captureLastMatch(astModule))
+	astFunctionDef_count.name = sourceCallableIdentifierA007822
+
+	NodeChanger(Be.Return, Then.insertThisAbove([A007822adjustFoldsTotal])).visit(astFunctionDef_count)
+
+	NodeChanger(
+		findThis=Be.AugAssign.targetIs(IfThis.isAttributeNamespaceIdentifier(identifierDataclassInstanceDEFAULT, identifierCountingDEFAULT))
+		, doThat=Then.replaceWith(A007822incrementCount)
+		).visit(astFunctionDef_count)
+
+# TODO NOTE This will insert a copy of `filterAsymmetricFolds` for each `ast.ImportFrom` in the source module. Find or make a
+# system to replace the `Ingredients` paradigm.
+	NodeChanger(Be.ImportFrom, Then.insertThisBelow([FunctionDef_filterAsymmetricFolds])).visit(astModule)
+
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
+
+	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
+
+	return pathFilename
+
+def _makeA007822Modules() -> None:
+	astModule = getModule(logicalPathInfix='algorithms')
+	pathFilename = addSymmetryCheck(astModule, 'algorithm', None, logicalPathInfixA007822, None)
+
+	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, moduleIdentifier='algorithm')
+	pathFilename: PurePath = makeDaoOfMapFoldingNumba(astModule, 'algorithmNumba', None, logicalPathInfixA007822, sourceCallableDispatcherA007822)
+
+	# NOTE I can't handle parallel right now.
+
+	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, moduleIdentifier='algorithm')
+	makeInitializeState(astModule, 'initializeState', 'transitionOnGroupsOfFolds', logicalPathInfixA007822)
+
+	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, moduleIdentifier='algorithm')
+	pathFilename = makeTheorem2(astModule, 'theorem2', None, logicalPathInfixA007822, None)
+
+	astModule = parsePathFilename2astModule(pathFilename)
+	pathFilename = trimTheorem2(astModule, 'theorem2Trimmed', None, logicalPathInfixA007822, None)
+
+	astModule = parsePathFilename2astModule(pathFilename)
+	pathFilename = numbaOnTheorem2(astModule, 'theorem2Numba', None, logicalPathInfixA007822, None)
+# TODO from mapFolding.syntheticModules.dataPackingA007822 import unRePackDataclass
+# @unRePackDataclass
+
+# TODO Make this decorator.
+	# astImportFrom: ast.ImportFrom = Make.ImportFrom(getLogicalPath(packageSettings.identifierPackage, logicalPathInfixA007822, 'theorem2Numba'), list_alias=[Make.alias(sourceCallableIdentifierA007822)])
+	# makeUnRePackDataclass(astImportFrom, 'dataPackingA007822')
+
+if __name__ == '__main__':
+	_makeA007822Modules()

mapFolding/someAssemblyRequired/RecipeJob.py

@@ -4,9 +4,9 @@ from ast import Module
 from astToolkit import identifierDotAttribute, parseLogicalPath2astModule
 from mapFolding import (
 	DatatypeElephino as TheDatatypeElephino, DatatypeFoldsTotal as TheDatatypeFoldsTotal,
-	DatatypeLeavesTotal as TheDatatypeLeavesTotal, getPathFilenameFoldsTotal, getPathRootJobDEFAULT, MapFoldingState,
-	packageSettings)
-from mapFolding.someAssemblyRequired import dataclassInstanceIdentifierDEFAULT, ShatteredDataclass
+	DatatypeLeavesTotal as TheDatatypeLeavesTotal, getPathFilenameFoldsTotal, getPathRootJobDEFAULT, packageSettings)
+from mapFolding.dataBaskets import MapFoldingState
+from mapFolding.someAssemblyRequired import identifierDataclassInstanceDEFAULT, ShatteredDataclass
 from mapFolding.someAssemblyRequired.transformationTools import shatter_dataclassesDOTdataclass
 from pathlib import Path, PurePosixPath
 import dataclasses
@@ -98,7 +98,7 @@ class RecipeJobTheorem2:
 	"""Logical path to the dataclass module."""
 	sourceDataclassIdentifier: str = 'MapFoldingState'
 	"""Name of the source dataclass."""
-	sourceDataclassInstance: str = dataclassInstanceIdentifierDEFAULT
+	sourceDataclassInstance: str = identifierDataclassInstanceDEFAULT
 	"""Instance identifier for the dataclass."""
 
 	sourcePathPackage: PurePosixPath | None = PurePosixPath(packageSettings.pathPackage)  # noqa: RUF009

mapFolding/someAssemblyRequired/__init__.py

@@ -73,8 +73,15 @@ calculations through the strategic application of compiler optimization techniqu
 """
 
 from mapFolding.someAssemblyRequired.infoBooth import (
-	dataclassInstanceIdentifierDEFAULT as dataclassInstanceIdentifierDEFAULT,
-	sourceCallableDispatcherDEFAULT as sourceCallableDispatcherDEFAULT,
+	dictionaryEstimatesMapFolding as dictionaryEstimatesMapFolding,
+	identifierCallableSourceDEFAULT as identifierCallableSourceDEFAULT,
+	identifierCallableSourceDispatcherDEFAULT as identifierCallableSourceDispatcherDEFAULT,
+	identifierCountingDEFAULT as identifierCountingDEFAULT,
+	identifierDataclassInstanceDEFAULT as identifierDataclassInstanceDEFAULT,
+	identifierModuleDataPackingDEFAULT as identifierModuleDataPackingDEFAULT,
+	identifierModuleSourceAlgorithmDEFAULT as identifierModuleSourceAlgorithmDEFAULT,
+	logicalPathInfixAlgorithmDEFAULT as logicalPathInfixAlgorithmDEFAULT,
+	logicalPathInfixDEFAULT as logicalPathInfixDEFAULT,
 )
 
 from mapFolding.someAssemblyRequired._toolIfThis import IfThis as IfThis

mapFolding/someAssemblyRequired/_toolIfThis.py

@@ -67,7 +67,7 @@ class IfThis(astToolkit_IfThis):
 
 		"""
 		return lambda node: (Be.Compare.leftIs(IfThis.isAttributeNamespaceIdentifier(namespace, identifier))(node)
-					and Be.Compare.opsIs(lambda at: Be.LtE(at[0]))(node)
+					and Be.Compare.opsIs(Be.at(0, Be.LtE))(node)
 				)
 
 	@staticmethod
@@ -94,8 +94,9 @@ class IfThis(astToolkit_IfThis):
 
 		"""
 		return lambda node: (Be.Compare.leftIs(IfThis.isAttributeNamespaceIdentifier(namespace, identifier))(node)
-					and Be.Gt(node.ops[0])
-					and IfThis.isConstant_value(0)(node.comparators[0]))
+					and Be.Compare.opsIs(Be.at(0, Be.Gt))(node)
+					and Be.Compare.comparatorsIs(Be.at(0, IfThis.isConstant_value(0)))(node)
+				)
 
 	@staticmethod
 	def isIfAttributeNamespaceIdentifierGreaterThan0(namespace: str, identifier: str) -> Callable[[ast.AST], TypeIs[ast.If]]:

mapFolding/someAssemblyRequired/_toolkitContainers.py

@@ -62,10 +62,10 @@ class ShatteredDataclass:
 	countingVariableName: ast.Name
 	"""AST name node representing the counting variable identifier."""
 
-	field2AnnAssign: dict[str, ast.AnnAssign | ast.Assign] = dataclasses.field(default_factory=lambda: dict[str, ast.AnnAssign | ast.Assign]())
+	field2AnnAssign: dict[str, ast.AnnAssign | ast.Assign] = dataclasses.field(default_factory=dict[str, ast.AnnAssign | ast.Assign])
 	"""Maps field names to their corresponding AST assignment expressions for initialization."""
 
-	Z0Z_field2AnnAssign: dict[str, tuple[ast.AnnAssign | ast.Assign, str]] = dataclasses.field(default_factory=lambda: dict[str, tuple[ast.AnnAssign | ast.Assign, str]]())
+	Z0Z_field2AnnAssign: dict[str, tuple[ast.AnnAssign | ast.Assign, str]] = dataclasses.field(default_factory=dict[str, tuple[ast.AnnAssign | ast.Assign, str]])
 	"""Temporary mapping for field assignments with constructor type information."""
 
 	fragments4AssignmentOrParameters: ast.Tuple = dummyTuple
@@ -74,22 +74,22 @@ class ShatteredDataclass:
 	imports: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
 	"""Import records for the dataclass and its constituent field types."""
 
-	list_argAnnotated4ArgumentsSpecification: list[ast.arg] = dataclasses.field(default_factory=lambda: list[ast.arg]())
+	list_argAnnotated4ArgumentsSpecification: list[ast.arg] = dataclasses.field(default_factory=list[ast.arg])
 	"""Function argument nodes with type annotations for parameter specification."""
 
-	list_keyword_field__field4init: list[ast.keyword] = dataclasses.field(default_factory=lambda: list[ast.keyword]())
+	list_keyword_field__field4init: list[ast.keyword] = dataclasses.field(default_factory=list[ast.keyword])
 	"""Keyword arguments for dataclass initialization using field=field format."""
 
-	listAnnotations: list[ast.expr] = dataclasses.field(default_factory=lambda: list[ast.expr]())
+	listAnnotations: list[ast.expr] = dataclasses.field(default_factory=list[ast.expr])
 	"""Type annotations for each dataclass field in declaration order."""
 
-	listName4Parameters: list[ast.Name] = dataclasses.field(default_factory=lambda: list[ast.Name]())
+	listName4Parameters: list[ast.Name] = dataclasses.field(default_factory=list[ast.Name])
 	"""Name nodes for each dataclass field used as function parameters."""
 
-	listUnpack: list[ast.AnnAssign] = dataclasses.field(default_factory=lambda: list[ast.AnnAssign]())
+	listUnpack: list[ast.AnnAssign] = dataclasses.field(default_factory=list[ast.AnnAssign])
 	"""Annotated assignment statements to extract individual fields from dataclass instances."""
 
-	map_stateDOTfield2Name: dict[ast.AST, ast.Name] = dataclasses.field(default_factory=lambda: dict[ast.AST, ast.Name]())
+	map_stateDOTfield2Name: dict[ast.AST, ast.Name] = dataclasses.field(default_factory=dict[ast.AST, ast.Name])
 	"""Maps dataclass attribute access expressions to field name nodes for find-replace operations."""
 
 	repack: ast.Assign = dummyAssign

mapFolding/someAssemblyRequired/infoBooth.py

@@ -11,42 +11,39 @@ on empirical measurements and theoretical analysis of map folding algorithms for
 specific dimensional configurations.
 """
 
-algorithmSourceModuleDEFAULT: str = 'daoOfMapFolding'
-"""Default identifier for the algorithm source module containing the base implementation."""
-
-dataclassInstanceIdentifierDEFAULT: str = 'state'
-"""Default variable name for dataclass instances in generated code."""
-
-dataPackingModuleIdentifierDEFAULT: str = 'dataPacking'
-"""Default identifier for modules containing data packing and unpacking functions."""
-
-logicalPathInfixDEFAULT: str = 'syntheticModules'
-"""Default path component for organizing synthetic generated modules."""
-
-sourceCallableDispatcherDEFAULT: str = 'doTheNeedful'
-"""Default identifier for dispatcher functions that route computational tasks."""
-
-sourceCallableIdentifierDEFAULT: str = 'count'
-"""Default identifier for the core counting function in algorithms."""
+from hunterMakesPy import identifierDotAttribute
+from typing import Final
 
-theCountingIdentifierDEFAULT: str = 'groupsOfFolds'
-"""Default identifier for the primary counting variable in map folding computations."""
-
-dictionaryEstimates: dict[tuple[int, ...], int] = {
+dictionaryEstimatesMapFolding: Final[dict[tuple[int, ...], int]] = {
 	(2,2,2,2,2,2,2,2): 798148657152000,
 	(2,21): 776374224866624,
 	(3,15): 824761667826225,
 	(3,3,3,3): 85109616000000000000000000000000,
 	(8,8): 791274195985524900,
 }
-"""
-Registry of computational complexity estimates for specific map dimension configurations.
+"""Estimates of multidimensional map folding `foldsTotal`."""
 
-Maps dimensional tuples to estimated fold counts based on empirical measurements and
-theoretical analysis. These estimates guide optimization decisions and resource planning
-for computational tasks with known dimensional parameters.
+identifierCallableSourceDEFAULT: Final[str] = 'count'
+"""Default identifier for the core counting function in algorithms."""
+
+identifierCallableSourceDispatcherDEFAULT: Final[str] = 'doTheNeedful'
+"""Default identifier for dispatcher functions that route computational tasks."""
+
+identifierCountingDEFAULT: Final[str] = 'groupsOfFolds'
+"""Default identifier for the primary counting variable in map folding computations."""
+
+identifierDataclassInstanceDEFAULT: Final[str] = 'state'
+"""Default variable name for dataclass instances in generated code."""
+
+identifierModuleDataPackingDEFAULT: Final[str] = 'dataPacking'
+"""Default identifier for modules containing data packing and unpacking functions."""
+
+identifierModuleSourceAlgorithmDEFAULT: Final[str] = 'daoOfMapFolding'
+"""Default identifier for the algorithm source module containing the base implementation."""
+
+logicalPathInfixAlgorithmDEFAULT: Final[identifierDotAttribute] = 'algorithms'
+"""Default logical path component for handmade algorithms."""
+
+logicalPathInfixDEFAULT: Final[identifierDotAttribute] = 'syntheticModules'
+"""Default logical path component for organizing synthetic generated modules."""
 
-The estimates represent the expected number of computational operations or fold
-configurations for the given map dimensions, helping determine appropriate optimization
-strategies and computational resource allocation.
-"""

mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py

@@ -33,7 +33,8 @@ from astToolkit import (
 	NodeChanger, NodeTourist, Then)
 from astToolkit.transformationTools import write_astModule
 from hunterMakesPy import autoDecodingRLE, raiseIfNone
-from mapFolding import getPathFilenameFoldsTotal, MapFoldingState, packageSettings
+from mapFolding import getPathFilenameFoldsTotal, packageSettings
+from mapFolding.dataBaskets import MapFoldingState
 from mapFolding.someAssemblyRequired import IfThis
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2
 from mapFolding.someAssemblyRequired.toolkitNumba import decorateCallableWithNumba, parametersNumbaLight, SpicesJobNumba
@@ -161,9 +162,9 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 				ImaAnnAssign, elementConstructor = job.shatteredDataclass.Z0Z_field2AnnAssign[ast_arg.arg]
 				match elementConstructor:
 					case 'scalar':
-						cast('ast.Constant', cast('ast.Call', ImaAnnAssign.value).args[0]).value = int(job.state.__dict__[ast_arg.arg])
+						cast('ast.Constant', cast('ast.Call', ImaAnnAssign.value).args[0]).value = int(eval(f"job.state.{ast_arg.arg}"))  # noqa: S307
 					case 'array':
-						dataAsStrRLE: str = autoDecodingRLE(job.state.__dict__[ast_arg.arg], assumeAddSpaces=True)
+						dataAsStrRLE: str = autoDecodingRLE(eval(f"job.state.{ast_arg.arg}"), assumeAddSpaces=True)  # noqa: S307
 						dataAs_astExpr: ast.expr = cast('ast.Expr', ast.parse(dataAsStrRLE).body[0]).value
 						cast('ast.Call', ImaAnnAssign.value).args = [dataAs_astExpr]
 					case _:
@@ -220,7 +221,7 @@ def makeJobNumba(job: RecipeJobTheorem2, spices: SpicesJobNumba) -> None:
 	listIdentifiersStaticValues: list[str] = listIdentifiersStaticValuesHARDCODED
 	for identifier in listIdentifiersStaticValues:
 		findThis: Callable[[ast.AST], TypeIs[ast.Name] | bool] = IfThis.isNameIdentifier(identifier)
-		doThat: Callable[[ast.Name], ast.Constant] = Then.replaceWith(Make.Constant(int(job.state.__dict__[identifier])))
+		doThat: Callable[[ast.Name], ast.Constant] = Then.replaceWith(Make.Constant(int(eval(f"job.state.{identifier}"))))  # noqa: S307
 		NodeChanger(findThis, doThat).visit(ingredientsCount.astFunctionDef)
 
 	ingredientsModule = IngredientsModule()
@@ -326,7 +327,7 @@ if __name__ == '__main__':
 	"""
 
 if __name__ == '__main__':
-	state = transitionOnGroupsOfFolds(MapFoldingState((2,4)))
+	state = transitionOnGroupsOfFolds(MapFoldingState((1,27)))
 	pathModule = PurePosixPath(packageSettings.pathPackage, 'jobs')
 	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
 	aJob = RecipeJobTheorem2(state, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)

mapFolding/someAssemblyRequired/makeJobTheorem2codon.py

@@ -8,10 +8,11 @@ from astToolkit import (
 	NodeTourist, parseLogicalPath2astModule, Then)
 from astToolkit.transformationTools import removeUnusedParameters, write_astModule
 from hunterMakesPy import autoDecodingRLE, raiseIfNone
-from mapFolding import DatatypeLeavesTotal, getPathFilenameFoldsTotal, MapFoldingState
+from mapFolding import DatatypeLeavesTotal, getPathFilenameFoldsTotal
+from mapFolding.dataBaskets import MapFoldingState
 from mapFolding.someAssemblyRequired import IfThis
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2
-from mapFolding.syntheticModules.initializeStateA007822 import transitionOnGroupsOfFolds
+from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
 from pathlib import Path, PurePosixPath
 from typing import cast, NamedTuple, TYPE_CHECKING
 import ast
@@ -100,7 +101,8 @@ def _variableCompatibility(ingredientsFunction: IngredientsFunction, job: Recipe
 		# `identifier` in Augmented Assignment, or in Assignments and value is Constant.
 		NodeChanger(findThis=IfThis.isAnyOf(
 				Be.AugAssign.targetIs(IfThis.isNestedNameIdentifier(identifier))
-				, IfThis.isAllOf(IfThis.isAssignAndTargets0Is(IfThis.isNameIdentifier(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)
@@ -220,6 +222,6 @@ def fromMapShape(mapShape: tuple[DatatypeLeavesTotal, ...]) -> None:
 	makeJob(aJob)
 
 if __name__ == '__main__':
-	mapShape = (1, 15)
+	mapShape = (1, 3)
 	fromMapShape(mapShape)