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

mapFolding/someAssemblyRequired/A007822/makeA007822AsynchronousModules.py

@@ -1,30 +1,49 @@
 """addSymmetryCheckAsynchronous."""
-from astToolkit import Be, extractFunctionDef, Grab, Make, NodeChanger, NodeTourist, parsePathFilename2astModule, Then
+from astToolkit import (
+	Be, extractFunctionDef, Grab, identifierDotAttribute, Make, NodeChanger, NodeTourist, parsePathFilename2astModule,
+	Then)
 from hunterMakesPy import raiseIfNone
 from mapFolding import packageSettings
-from mapFolding.someAssemblyRequired import IfThis, logicalPathInfixAlgorithmDEFAULT
+from mapFolding.someAssemblyRequired import (
+	identifierCallableSourceDispatcherDEFAULT, identifierCountingDEFAULT, identifierDataclassInstanceDEFAULT, IfThis,
+	logicalPathInfixAlgorithmDEFAULT)
 from mapFolding.someAssemblyRequired.A007822.A007822rawMaterials import (
 	A007822adjustFoldsTotal, astExprCall_filterAsymmetricFoldsDataclass, identifier_filterAsymmetricFolds,
 	identifierCounting, identifierDataclass, logicalPathInfixA007822, sourceCallableDispatcherA007822,
 	sourceCallableIdentifierA007822)
+from mapFolding.someAssemblyRequired.infoBooth import identifierCallableSourceDEFAULT
 from mapFolding.someAssemblyRequired.makingModules_count import makeTheorem2, numbaOnTheorem2, trimTheorem2
-from mapFolding.someAssemblyRequired.toolkitMakeModules import getModule, getPathFilename, write_astModule
-from os import PathLike
+from mapFolding.someAssemblyRequired.toolkitMakeModules import (
+	getLogicalPath, getModule, getPathFilename, write_astModule)
 from pathlib import PurePath
 import ast
 
+identifier_asynchronous = 'asynchronous'
+identifier_getSymmetricFoldsTotal = 'getSymmetricFoldsTotal'
 identifier_initializeConcurrencyManager = 'initializeConcurrencyManager'
+identifier_processCompletedFutures = '_processCompletedFutures'
 
-astExprCall_initializeConcurrencyManager = Make.Expr(Make.Call(Make.Name(identifier_initializeConcurrencyManager)))
-identifier_getAsymmetricFoldsTotal = 'getAsymmetricFoldsTotal'
+astExprCall_initializeConcurrencyManager: ast.Expr = Make.Expr(Make.Call(Make.Name(identifier_initializeConcurrencyManager), listParameters=[Make.Name('maxWorkers')]))
 AssignTotal2CountingIdentifier: ast.Assign = Make.Assign(
 	[Make.Attribute(Make.Name(identifierDataclass), identifierCounting, context=Make.Store())]
-	, value=Make.Call(Make.Name(identifier_getAsymmetricFoldsTotal))
+	, value=Make.Call(Make.Name(identifier_getSymmetricFoldsTotal))
 )
-identifier_processCompletedFutures = '_processCompletedFutures'
 
-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."""
+def addSymmetryCheckAsynchronous(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute  | 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
@@ -53,24 +72,26 @@ def addSymmetryCheckAsynchronous(astModule: ast.Module, moduleIdentifier: str, c
 		).captureLastMatch(astModule))
 
 	astFunctionDef_doTheNeedful.body.insert(0, astExprCall_initializeConcurrencyManager)
+	astFunctionDef_doTheNeedful.args.args.append(Make.arg('maxWorkers', Make.BitOr.join([Make.Name('int'), Make.Constant(None)])))
+	astFunctionDef_doTheNeedful.args.defaults.append(Make.Constant(None))
 
 	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)
+	astImportFrom = ast.ImportFrom(getLogicalPath(packageSettings.identifierPackage, logicalPathInfix, identifierModule + 'Annex')
+			, [Make.alias(identifier_filterAsymmetricFolds), Make.alias(identifier_getSymmetricFoldsTotal), 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')
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
+	pathFilenameAnnex: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule + 'Annex')
 
 	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
 	del astModule
 # ----------------- Ingredients Module Annex ------------------------------------------------------------------------------
-	ImaString = """from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
+	ImaString = """from concurrent.futures import Future as ConcurrentFuture, ThreadPoolExecutor
 from hunterMakesPy import raiseIfNone
 from mapFolding import Array1DLeavesTotal
 from queue import Empty, Queue
@@ -90,7 +111,7 @@ queueFutures: Queue[ConcurrentFuture[int]] = Queue()
 
 	ImaString = f"""def {identifier_initializeConcurrencyManager}(maxWorkers: int | None = None, {identifierCounting}: int = 0) -> None:
 	global concurrencyManager, queueFutures, {identifierCounting}Total, processingThread
-	concurrencyManager = ProcessPoolExecutor(max_workers=maxWorkers)
+	concurrencyManager = ThreadPoolExecutor(max_workers=maxWorkers)
 	queueFutures = Queue()
 	{identifierCounting}Total = {identifierCounting}
 	processingThread = Thread(target={identifier_processCompletedFutures})
@@ -136,8 +157,7 @@ queueFutures: Queue[ConcurrentFuture[int]] = Queue()
 				ImaSymmetricFold = False
 				break
 			leafConnectee += 1
-		if ImaSymmetricFold:
-			{identifierCounting} += 1
+		{identifierCounting} += ImaSymmetricFold
 		indexDistance += 1
 	return {identifierCounting}
 	"""
@@ -147,39 +167,93 @@ queueFutures: Queue[ConcurrentFuture[int]] = Queue()
 	ImaString = f"""
 def {identifier_filterAsymmetricFolds}(leafBelow: Array1DLeavesTotal) -> None:
 	global concurrencyManager, queueFutures
-	queueFutures.put(raiseIfNone(concurrencyManager).submit(_{identifier_filterAsymmetricFolds}, leafBelow.copy()))
+	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:
+def {identifier_getSymmetricFoldsTotal}() -> 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)))
+	astModule.body.append(raiseIfNone(extractFunctionDef(ast.parse(ImaString), identifier_getSymmetricFoldsTotal)))
 	del ImaString
-
 	write_astModule(astModule, pathFilenameAnnex, packageSettings.identifierPackage)
 
 	return pathFilename
 
+def makeAsynchronousNumbaOnTheorem2(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:
+	"""Make the asynchronous numba on theorem2 module."""
+	pathFilename: PurePath = numbaOnTheorem2(astModule, identifierModule, identifierCallable, logicalPathInfix, sourceCallableDispatcher)
+
+	astModule = parsePathFilename2astModule(pathFilename)
+
+	listAssignToMove: list[ast.Assign] = []
+
+	findThis = IfThis.isAnyOf(IfThis.isAssignAndTargets0Is(IfThis.isNameIdentifier(identifierCountingDEFAULT))
+					, Be.AugAssign.targetIs(IfThis.isNameIdentifier(identifierCountingDEFAULT)))
+	NodeTourist(findThis, Then.appendTo(listAssignToMove)).visit(astModule)
+
+	NodeChanger(findThis, Then.removeIt).visit(astModule)
+
+	NodeChanger(
+		findThis=Be.Assign.valueIs(IfThis.isCallIdentifier(identifierCallableSourceDEFAULT))
+		, doThat=Then.insertThisBelow(listAssignToMove)
+	).visit(astModule)
+
+	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
+
+	return pathFilename
+
+def makeAsynchronousTheorem2(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:
+	"""Make the asynchronous theorem2 module."""
+	pathFilename: PurePath = makeTheorem2(astModule, identifierModule, identifierCallable, logicalPathInfix, sourceCallableDispatcher)
+
+	astModule = parsePathFilename2astModule(pathFilename)
+
+	astAttribute = Make.Attribute(Make.Name(identifierDataclassInstanceDEFAULT), identifierCountingDEFAULT)
+	astAssign = Make.Assign([astAttribute], value=Make.Constant(0))
+
+	NodeChanger[ast.Call, ast.Call](
+		findThis = IfThis.isCallIdentifier(identifier_initializeConcurrencyManager)
+		, doThat = Grab.argsAttribute(lambda args: [*args, astAttribute]) # pyright: ignore[reportArgumentType]
+	).visit(astModule)
+
+	NodeChanger(
+		findThis = Be.Expr.valueIs(IfThis.isCallIdentifier(identifier_initializeConcurrencyManager))
+		, doThat = Then.insertThisBelow([astAssign])
+	).visit(astModule)
+
+	identifierAnnex: identifierDotAttribute = getLogicalPath(packageSettings.identifierPackage, logicalPathInfix, identifier_asynchronous + 'Annex')
+	identifierAnnexNumba: identifierDotAttribute = identifierAnnex + 'Numba'
+
+	NodeChanger(
+		findThis=Be.ImportFrom.moduleIs(IfThis.isIdentifier(identifierAnnex))
+		, doThat=Grab.moduleAttribute(Then.replaceWith(identifierAnnexNumba))
+	).visit(astModule)
+
+	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
+
+	return pathFilename
+
 def _makeA007822AsynchronousModules() -> None:
 
-	astModule = getModule(logicalPathInfix=logicalPathInfixAlgorithmDEFAULT)
-	pathFilename = addSymmetryCheckAsynchronous(astModule, 'asynchronous', None, logicalPathInfixA007822, sourceCallableDispatcherA007822)
+	astModule: ast.Module = getModule(logicalPathInfix=logicalPathInfixAlgorithmDEFAULT)
+	pathFilename: PurePath = addSymmetryCheckAsynchronous(astModule, 'asynchronous', None, logicalPathInfixA007822, sourceCallableDispatcherA007822)
 
-	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, moduleIdentifier='asynchronous')
-	pathFilename = makeTheorem2(astModule, 'asynchronousTheorem2', None, logicalPathInfixA007822, None)
+	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, identifierModule='asynchronous')
+	pathFilename = makeAsynchronousTheorem2(astModule, 'asynchronousTheorem2', None, logicalPathInfixA007822, identifierCallableSourceDispatcherDEFAULT)
 
 	astModule = parsePathFilename2astModule(pathFilename)
-	pathFilename = trimTheorem2(astModule, 'asynchronousTrimmed', None, logicalPathInfixA007822, None)
+	pathFilename = trimTheorem2(astModule, 'asynchronousTrimmed', None, logicalPathInfixA007822, identifierCallableSourceDispatcherDEFAULT)
 
-	# astModule = parsePathFilename2astModule(pathFilename)
-	# pathFilename = numbaOnTheorem2(astModule, 'asynchronousNumba', None, logicalPathInfixA007822, identifier_filterAsymmetricFolds)
+	astModule = parsePathFilename2astModule(pathFilename)
+	pathFilename = makeAsynchronousNumbaOnTheorem2(astModule, 'asynchronousNumba', None, logicalPathInfixA007822, identifierCallableSourceDispatcherDEFAULT)
 
 if __name__ == '__main__':
 	_makeA007822AsynchronousModules()
+

mapFolding/someAssemblyRequired/A007822/makeA007822Modules.py

@@ -1,14 +1,15 @@
 """addSymmetryCheck."""
-from astToolkit import Be, Make, NodeChanger, NodeTourist, parsePathFilename2astModule, Then
+from astToolkit import Be, identifierDotAttribute, Make, NodeChanger, NodeTourist, parsePathFilename2astModule, Then
 from hunterMakesPy import raiseIfNone
 from mapFolding import packageSettings
 from mapFolding.someAssemblyRequired import (
-	identifierCallableSourceDEFAULT, identifierCountingDEFAULT, identifierDataclassInstanceDEFAULT, IfThis)
+	identifierCallableSourceDEFAULT, identifierCallableSourceDispatcherDEFAULT, 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)
+	makeMapFoldingNumba, makeTheorem2, numbaOnTheorem2, trimTheorem2)
 from mapFolding.someAssemblyRequired.makingModules_doTheNeedful import makeInitializeState, makeUnRePackDataclass
 from mapFolding.someAssemblyRequired.toolkitMakeModules import (
 	getLogicalPath, getModule, getPathFilename, write_astModule)
@@ -16,7 +17,7 @@ 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
+def addSymmetryCheck(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute | 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.
 
@@ -37,7 +38,7 @@ def addSymmetryCheck(astModule: ast.Module, moduleIdentifier: str, callableIdent
 # system to replace the `Ingredients` paradigm.
 	NodeChanger(Be.ImportFrom, Then.insertThisBelow([FunctionDef_filterAsymmetricFolds])).visit(astModule)
 
-	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
 
 	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
 
@@ -47,25 +48,28 @@ 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)
+	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, identifierModule='algorithm')
+	pathFilename: PurePath = makeMapFoldingNumba(astModule, 'algorithmNumba', None, logicalPathInfixA007822, sourceCallableDispatcherA007822)
 
 	# NOTE I can't handle parallel right now.
 
-	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, moduleIdentifier='algorithm')
+	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, identifierModule='algorithm')
 	makeInitializeState(astModule, 'initializeState', 'transitionOnGroupsOfFolds', logicalPathInfixA007822)
 
-	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, moduleIdentifier='algorithm')
-	pathFilename = makeTheorem2(astModule, 'theorem2', None, logicalPathInfixA007822, None)
+	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, identifierModule='algorithm')
+	pathFilename = makeTheorem2(astModule, 'theorem2', None, logicalPathInfixA007822, identifierCallableSourceDispatcherDEFAULT)
 
 	astModule = parsePathFilename2astModule(pathFilename)
-	pathFilename = trimTheorem2(astModule, 'theorem2Trimmed', None, logicalPathInfixA007822, None)
+	pathFilename = trimTheorem2(astModule, 'theorem2Trimmed', None, logicalPathInfixA007822, identifierCallableSourceDispatcherDEFAULT)
 
 	astModule = parsePathFilename2astModule(pathFilename)
-	pathFilename = numbaOnTheorem2(astModule, 'theorem2Numba', None, logicalPathInfixA007822, None)
+	pathFilename = numbaOnTheorem2(astModule, 'theorem2Numba', None, logicalPathInfixA007822, identifierCallableSourceDispatcherDEFAULT)
+# TODO from mapFolding.syntheticModules.dataPackingA007822 import unRePackDataclass
+# @unRePackDataclass
 
-	astImportFrom: ast.ImportFrom = Make.ImportFrom(getLogicalPath(packageSettings.identifierPackage, logicalPathInfixA007822, 'theorem2Numba'), list_alias=[Make.alias(sourceCallableIdentifierA007822)])
-	makeUnRePackDataclass(astImportFrom, 'dataPackingA007822')
+# 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,8 +4,8 @@ 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)
+	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

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,11 +327,11 @@ if __name__ == '__main__':
 	"""
 
 if __name__ == '__main__':
-	state = transitionOnGroupsOfFolds(MapFoldingState((1,27)))
+	state = transitionOnGroupsOfFolds(MapFoldingState((2,5)))
 	pathModule = PurePosixPath(packageSettings.pathPackage, 'jobs')
 	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
 	aJob = RecipeJobTheorem2(state, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
-	spices = SpicesJobNumba(useNumbaProgressBar=False, parametersNumba=parametersNumbaLight)
+	spices = SpicesJobNumba(useNumbaProgressBar=True, parametersNumba=parametersNumbaLight)
 	makeJobNumba(aJob, spices)
 
 # TODO Improve this module with lessons learned in `makeJobTheorem2codon`.

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
@@ -102,7 +103,6 @@ def _variableCompatibility(ingredientsFunction: IngredientsFunction, job: Recipe
 				Be.AugAssign.targetIs(IfThis.isNestedNameIdentifier(identifier))
 				, IfThis.isAllOf(
 					Be.Assign.targetsIs(Be.at(0, IfThis.isNestedNameIdentifier(identifier)))
-					# IfThis.isAssignAndTargets0Is(IfThis.isNameIdentifier(identifier))
 					, Be.Assign.valueIs(Be.Constant))
 			)
 			, doThat=lambda node, annotation=annotation: Grab.valueAttribute(Then.replaceWith(Make.Call(annotation, listParameters=[node.value])))(node)
@@ -115,7 +115,6 @@ def _variableCompatibility(ingredientsFunction: IngredientsFunction, job: Recipe
 
 		# `identifier` in Comparison.
 		NodeChanger(Be.Compare.leftIs(IfThis.isNestedNameIdentifier(identifier))
-			# , doThat=Grab.comparatorsAttribute(Grab.index(0, lambda comparator, annotation=annotation: Then.replaceWith(Make.Call(annotation, listParameters=[comparator]))))
 			, 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)