mapFolding 0.13.0__py3-none-any.whl → 0.14.0__py3-none-any.whl

mapFolding/reference/matrixMeandersBaselineAnnex.py

@@ -0,0 +1,84 @@
+from typing import NamedTuple
+import sys
+
+class limitLocators(NamedTuple):
+	curveLocationsMAXIMUM: int
+	bifurcationEvenLocator: int
+	bifurcationOddLocator: int
+
+curveMaximum: dict[int, limitLocators] = {
+0: limitLocators(16, 0x2a, 0x15),
+1: limitLocators(64, 0xaa, 0x55),
+2: limitLocators(256, 0x2aa, 0x155),
+3: limitLocators(1024, 0xaaa, 0x555),
+4: limitLocators(4096, 0x2aaa, 0x1555),
+5: limitLocators(16384, 0xaaaa, 0x5555),
+6: limitLocators(65536, 0x2aaaa, 0x15555),
+7: limitLocators(262144, 0xaaaaa, 0x55555),
+8: limitLocators(1048576, 0x2aaaaa, 0x155555),
+9: limitLocators(4194304, 0xaaaaaa, 0x555555),
+10: limitLocators(16777216, 0x2aaaaaa, 0x1555555),
+11: limitLocators(67108864, 0xaaaaaaa, 0x5555555),
+12: limitLocators(268435456, 0x2aaaaaaa, 0x15555555),
+13: limitLocators(1073741824, 0xaaaaaaaa, 0x55555555),
+14: limitLocators(4294967296, 0x2aaaaaaaa, 0x155555555),
+15: limitLocators(17179869184, 0xaaaaaaaaa, 0x555555555),
+16: limitLocators(68719476736, 0x2aaaaaaaaa, 0x1555555555),
+17: limitLocators(274877906944, 0xaaaaaaaaaa, 0x5555555555),
+18: limitLocators(1099511627776, 0x2aaaaaaaaaa, 0x15555555555),
+19: limitLocators(4398046511104, 0xaaaaaaaaaaa, 0x55555555555),
+20: limitLocators(17592186044416, 0x2aaaaaaaaaaa, 0x155555555555),
+21: limitLocators(70368744177664, 0xaaaaaaaaaaaa, 0x555555555555),
+22: limitLocators(281474976710656, 0x2aaaaaaaaaaaa, 0x1555555555555),
+23: limitLocators(1125899906842624, 0xaaaaaaaaaaaaa, 0x5555555555555),
+24: limitLocators(4503599627370496, 0x2aaaaaaaaaaaaa, 0x15555555555555),
+25: limitLocators(18014398509481984, 0xaaaaaaaaaaaaaa, 0x55555555555555),
+26: limitLocators(72057594037927936, 0x2aaaaaaaaaaaaaa, 0x155555555555555),
+27: limitLocators(288230376151711744, 0xaaaaaaaaaaaaaaa, 0x555555555555555),
+28: limitLocators(1152921504606846976, 0x2aaaaaaaaaaaaaaa, 0x1555555555555555),
+29: limitLocators(4611686018427387904, 0xaaaaaaaaaaaaaaaa, 0x5555555555555555),
+30: limitLocators(18446744073709551616, 0x2aaaaaaaaaaaaaaaa, 0x15555555555555555),
+31: limitLocators(73786976294838206464, 0xaaaaaaaaaaaaaaaaa, 0x55555555555555555),
+32: limitLocators(295147905179352825856, 0x2aaaaaaaaaaaaaaaaa, 0x155555555555555555),
+33: limitLocators(1180591620717411303424, 0xaaaaaaaaaaaaaaaaaa, 0x555555555555555555),
+34: limitLocators(4722366482869645213696, 0x2aaaaaaaaaaaaaaaaaa, 0x1555555555555555555),
+35: limitLocators(18889465931478580854784, 0xaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555),
+36: limitLocators(75557863725914323419136, 0x2aaaaaaaaaaaaaaaaaaa, 0x15555555555555555555),
+37: limitLocators(302231454903657293676544, 0xaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555),
+38: limitLocators(1208925819614629174706176, 0x2aaaaaaaaaaaaaaaaaaaa, 0x155555555555555555555),
+39: limitLocators(4835703278458516698824704, 0xaaaaaaaaaaaaaaaaaaaaa, 0x555555555555555555555),
+40: limitLocators(19342813113834066795298816, 0x2aaaaaaaaaaaaaaaaaaaaa, 0x1555555555555555555555),
+41: limitLocators(77371252455336267181195264, 0xaaaaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555555),
+42: limitLocators(309485009821345068724781056, 0x2aaaaaaaaaaaaaaaaaaaaaa, 0x15555555555555555555555),
+43: limitLocators(1237940039285380274899124224, 0xaaaaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555555),
+44: limitLocators(4951760157141521099596496896, 0x2aaaaaaaaaaaaaaaaaaaaaaa, 0x155555555555555555555555),
+45: limitLocators(19807040628566084398385987584, 0xaaaaaaaaaaaaaaaaaaaaaaaa, 0x555555555555555555555555),
+46: limitLocators(79228162514264337593543950336, 0x2aaaaaaaaaaaaaaaaaaaaaaaa, 0x1555555555555555555555555),
+47: limitLocators(316912650057057350374175801344, 0xaaaaaaaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555555555),
+48: limitLocators(1267650600228229401496703205376, 0x2aaaaaaaaaaaaaaaaaaaaaaaaa, 0x15555555555555555555555555),
+49: limitLocators(5070602400912917605986812821504, 0xaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555555555),
+50: limitLocators(20282409603651670423947251286016, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaa, 0x155555555555555555555555555),
+51: limitLocators(81129638414606681695789005144064, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x555555555555555555555555555),
+52: limitLocators(324518553658426726783156020576256, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x1555555555555555555555555555),
+53: limitLocators(1298074214633706907132624082305024, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555555555555),
+54: limitLocators(5192296858534827628530496329220096, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x15555555555555555555555555555),
+55: limitLocators(20769187434139310514121985316880384, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555555555555),
+56: limitLocators(83076749736557242056487941267521536, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x155555555555555555555555555555),
+57: limitLocators(332306998946228968225951765070086144, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x555555555555555555555555555555),
+58: limitLocators(1329227995784915872903807060280344576, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x1555555555555555555555555555555),
+59: limitLocators(5316911983139663491615228241121378304, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555555555555555),
+60: limitLocators(21267647932558653966460912964485513216, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x15555555555555555555555555555555),
+61: limitLocators(85070591730234615865843651857942052864, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555555555555555),
+}
+
+def makeCurveMaximum() -> None:
+	sys.stdout.write("curveMaximum: dict[int, limitLocators] = {\n")
+	for n in range(62):
+		curveLocationsMAXIMUM = 1 << (2 * n + 4)
+		bifurcationOddLocator = int('01' * ((curveLocationsMAXIMUM.bit_length() + 1) // 2), 2)
+		sys.stdout.write(f"{n}: limitLocators({curveLocationsMAXIMUM}, {hex(bifurcationOddLocator << 1)}, {hex(bifurcationOddLocator)}),\n")
+	sys.stdout.write("}\n")
+
+if __name__ == '__main__':
+	makeCurveMaximum()
+

mapFolding/someAssemblyRequired/RecipeJob.py

@@ -9,7 +9,6 @@ from mapFolding import (
 from mapFolding.someAssemblyRequired import dataclassInstanceIdentifierDEFAULT, ShatteredDataclass
 from mapFolding.someAssemblyRequired.transformationTools import shatter_dataclassesDOTdataclass
 from pathlib import Path, PurePosixPath
-from typing import TypeAlias
 import dataclasses
 
 @dataclasses.dataclass
@@ -134,11 +133,11 @@ class RecipeJobTheorem2:
 	"""Logical path to target dataclass module."""
 
 	# Datatypes ------------------------------------------
-	DatatypeFoldsTotal: TypeAlias = TheDatatypeFoldsTotal
+	type DatatypeFoldsTotal = TheDatatypeFoldsTotal
 	"""Type alias for datatype linked to the magnitude of `foldsTotal`."""
-	DatatypeElephino: TypeAlias = TheDatatypeElephino
+	type DatatypeElephino = TheDatatypeElephino
 	"""Type alias for intermediate computation datatype."""
-	DatatypeLeavesTotal: TypeAlias = TheDatatypeLeavesTotal
+	type DatatypeLeavesTotal = TheDatatypeLeavesTotal
 	"""Type alias for datatype linked to the magnitude of `leavesTotal`."""
 
 	def _makePathFilename(self, pathRoot: PurePosixPath | None = None, logicalPathINFIX: identifierDotAttribute | None = None, filenameStem: str | None = None, fileExtension: str | None = None) -> PurePosixPath:

mapFolding/someAssemblyRequired/_toolkitContainers.py

@@ -217,10 +217,10 @@ class DeReConstructField2ast:
 		self.ast_keyword_field__field = Make.keyword(self.name, self.astName)
 		self.ast_nameDOTname = Make.Attribute(Make.Name(dataclassesDOTdataclassInstanceIdentifier), self.name)
 
-		self.astAnnotation = raiseIfNone(NodeTourist[ast.AnnAssign, ast.Name | None](
+		self.astAnnotation = cast('ast.Name', raiseIfNone(NodeTourist(
 			findThis = Be.AnnAssign.targetIs(IfThis.isNameIdentifier(self.name))
-			, doThat = Then.extractIt(cast("Callable[[ast.AnnAssign], ast.Name | None]", DOT.annotation))
-			).captureLastMatch(dataclassClassDef))
+			, doThat = Then.extractIt(DOT.annotation)
+			).captureLastMatch(dataclassClassDef)))
 
 		self.ast_argAnnotated = Make.arg(self.name, self.astAnnotation)
 

mapFolding/someAssemblyRequired/makeAllModules.py

@@ -299,7 +299,7 @@ def makeDaoOfMapFolding(astModule: ast.Module, moduleIdentifier: str, callableId
 		ingredientsFunctionDispatcher.imports.update(shatteredDataclass.imports)
 		targetCallableIdentifier = ingredientsFunction.astFunctionDef.name
 		ingredientsFunctionDispatcher = unpackDataclassCallFunctionRepackDataclass(ingredientsFunctionDispatcher, targetCallableIdentifier, shatteredDataclass)
-		astTuple: ast.Tuple = cast('ast.Tuple', raiseIfNone(NodeTourist[ast.Return, ast.expr | None](Be.Return.valueIs(Be.Tuple)
+		astTuple: ast.Tuple = cast('ast.Tuple', raiseIfNone(NodeTourist(Be.Return.valueIs(Be.Tuple)
 				, doThat=Then.extractIt(DOT.value)).captureLastMatch(ingredientsFunction.astFunctionDef)))
 		astTuple.ctx = ast.Store()
 
@@ -743,7 +743,7 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom) -> None:
 	targetCallableIdentifier = 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[ast.Return, ast.expr | None](Be.Return.valueIs(Be.Tuple)
+	astTuple: ast.Tuple = cast('ast.Tuple', raiseIfNone(NodeTourist(Be.Return.valueIs(Be.Tuple)
 			, doThat=Then.extractIt(DOT.value)).captureLastMatch(targetFunctionDef)))
 	astTuple.ctx = ast.Store()
 

mapFolding/someAssemblyRequired/makeJobTheorem2codon.py

@@ -1,28 +1,32 @@
 """codon.
 
-https://docs.exaloop.io/start/install/"""
+https://docs.exaloop.io/start/install/
+"""
 
 from astToolkit import (
-	Be, DOT, extractFunctionDef, Grab, hasDOTvalue, identifierDotAttribute, IngredientsFunction, IngredientsModule, Make,
-	NodeChanger, NodeTourist, Then)
-from astToolkit.transformationTools import write_astModule
+	Be, DOT, extractFunctionDef, Grab, identifierDotAttribute, IngredientsFunction, IngredientsModule, Make, NodeChanger,
+	NodeTourist, Then)
+from astToolkit.transformationTools import removeUnusedParameters, write_astModule
 from hunterMakesPy import autoDecodingRLE, raiseIfNone
-from mapFolding import getPathFilenameFoldsTotal, MapFoldingState, packageSettings
+from mapFolding import DatatypeLeavesTotal, getPathFilenameFoldsTotal, MapFoldingState
 from mapFolding.someAssemblyRequired import IfThis
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2
 from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
 from pathlib import Path, PurePosixPath
-from typing import cast, NamedTuple
+from typing import cast, NamedTuple, TYPE_CHECKING
 import ast
 import subprocess
 import sys
 
+if TYPE_CHECKING:
+	from io import TextIOBase
+
 class DatatypeConfiguration(NamedTuple):
 	"""Configuration for mapping framework datatypes to compiled datatypes.
 
 	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.
+	datatypes during code generation. Each configuration specifies the source module, target type name, and optional import alias
+	for the transformation.
 
 	Attributes
 	----------
@@ -44,34 +48,39 @@ class DatatypeConfiguration(NamedTuple):
 # TODO replace with dynamic system. Probably use `Final` in the dataclass.
 listIdentifiersStaticValuesHARDCODED: list[str] = ['dimensionsTotal', 'leavesTotal']
 
-listDatatypeConfigs: list[DatatypeConfiguration] = [
-	DatatypeConfiguration(datatypeIdentifier='DatatypeLeavesTotal', typeModule='numpy', typeIdentifier='uint16', type_asname='DatatypeLeavesTotal'),
-	DatatypeConfiguration(datatypeIdentifier='DatatypeElephino', typeModule='numpy', typeIdentifier='uint16', type_asname='DatatypeElephino'),
+# 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'),
 ]
 
-listNumPyTypeConfigs: list[DatatypeConfiguration] = [
-	DatatypeConfiguration(datatypeIdentifier='Array1DLeavesTotal', typeModule='numpy', typeIdentifier='uint16', type_asname='Array1DLeavesTotal'),
-	DatatypeConfiguration(datatypeIdentifier='Array1DElephino', typeModule='numpy', typeIdentifier='uint16', type_asname='Array1DElephino'),
-	DatatypeConfiguration(datatypeIdentifier='Array3D', typeModule='numpy', typeIdentifier='uint16', type_asname='Array3D'),
+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='Array3D', typeModule='numpy', typeIdentifier='uint8', type_asname='Array3D'),
 ]
 
-def _datatypeDefinitions(ingredientsFunction: IngredientsFunction, ingredientsModule: IngredientsModule) -> tuple[IngredientsFunction, IngredientsModule]:
-	for datatypeConfig in listDatatypeConfigs:
-		ingredientsFunction.imports.removeImportFrom(datatypeConfig.typeModule, None, datatypeConfig.datatypeIdentifier)
-		ingredientsFunction.imports.addImportFrom_asStr(datatypeConfig.typeModule, datatypeConfig.typeIdentifier, datatypeConfig.type_asname)
-		continue
-		ingredientsModule.appendPrologue(statement=Make.Assign([Make.Name(datatypeConfig.datatypeIdentifier, ast.Store())]
-			, value=Make.Name(datatypeConfig.typeIdentifier)
-		))
+def _addWriteFoldsTotal(ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2) -> IngredientsFunction:
+	NodeChanger(Be.Return, Then.removeIt).visit(ingredientsFunction.astFunctionDef)
+	ingredientsFunction.astFunctionDef.returns = Make.Constant(None)
+
+	writeFoldsTotal = Make.Expr(Make.Call(Make.Attribute(
+		Make.Call(Make.Name('open'), listParameters=[Make.Constant(str(job.pathFilenameFoldsTotal.as_posix())), Make.Constant('w')])
+		, 'write'), listParameters=[Make.Call(Make.Name('str'), listParameters=[
+			Make.Mult().join([job.shatteredDataclass.countingVariableName, Make.Constant(job.state.leavesTotal * 2)])])]))
+
+	NodeChanger(IfThis.isAllOf(Be.AugAssign.targetIs(IfThis.isNameIdentifier(job.shatteredDataclass.countingVariableName.id))
+			, Be.AugAssign.opIs(Be.Mult), Be.AugAssign.valueIs(Be.Constant))
+		, doThat=Then.replaceWith(writeFoldsTotal)
+	).visit(ingredientsFunction.astFunctionDef)
+
+	return ingredientsFunction
 
-	for datatypeConfig in listNumPyTypeConfigs:
+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)
-		continue
-		ingredientsModule.appendPrologue(statement=Make.Assign([Make.Name(datatypeConfig.datatypeIdentifier, ast.Store())]
-			, value=Make.Name(datatypeConfig.typeIdentifier)
-		))
 
 	ingredientsFunction.imports.removeImportFromModule('mapFolding.dataBaskets')
 
@@ -82,111 +91,66 @@ def _pythonCode2expr(string: str) -> ast.expr:
 	return raiseIfNone(NodeTourist(Be.Expr, Then.extractIt(DOT.value)).captureLastMatch(ast.parse(string)))
 
 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.
 	for ast_arg in job.shatteredDataclass.list_argAnnotated4ArgumentsSpecification:
 		identifier = ast_arg.arg
 		annotation = raiseIfNone(ast_arg.annotation)
 
-		# `identifier` in Augmented Assignment.
-		NodeChanger(Be.AugAssign.targetIs(IfThis.isNestedNameIdentifier(identifier))
-			, doThat=lambda node: Grab.valueAttribute(Then.replaceWith(Make.Call(annotation, listParameters=[node.value])))(node)
-		).visit(ingredientsFunction.astFunctionDef)
-
-		# `identifier` in Assignments; exclude `numpy.array`.
-		NodeChanger(findThis=lambda node: IfThis.isAssignAndTargets0Is(IfThis.isNameIdentifier(identifier))(node)
-			and Be.Assign.valueIs(Be.Constant)(node)
-			, doThat=lambda node: Grab.valueAttribute(Then.replaceWith(Make.Call(annotation, listParameters=[node.value])))(node)
+		# `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))
+					, 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.
 		NodeChanger(Be.BinOp.leftIs(IfThis.isNestedNameIdentifier(identifier))
-			, doThat=lambda node: Grab.rightAttribute(Then.replaceWith(Make.Call(annotation, listParameters=[node.right])))(node)
+			, doThat=lambda node, annotation=annotation: Grab.rightAttribute(Then.replaceWith(Make.Call(annotation, listParameters=[node.right])))(node)
 		).visit(ingredientsFunction.astFunctionDef)
 
 		# `identifier` in Comparison.
 		NodeChanger(Be.Compare.leftIs(IfThis.isNestedNameIdentifier(identifier))
-			, doThat=lambda node: Grab.comparatorsAttribute(lambda at: Then.replaceWith([Make.Call(annotation, listParameters=[node.comparators[0]])])(at[0]))(node)
+			, 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.
-		NodeChanger(
-			findThis=lambda node: Be.Subscript.valueIs(IfThis.isNestedNameIdentifier(identifier))(node)
-			and not Be.Subscript.sliceIs(Be.Tuple)(node)
+		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.
-		NodeChanger(
-			findThis=lambda node: Be.Subscript.valueIs(IfThis.isNestedNameIdentifier(identifier))(node)
-			and Be.Subscript.sliceIs(Be.Tuple)(node)
+		NodeChanger(IfThis.isAllOf(Be.Subscript.valueIs(IfThis.isNestedNameIdentifier(identifier))
+			, 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]])
-					for index in range(len(cast(ast.Tuple, node.slice).elts))
-					])
-			))(node)
+					Make.Call(Make.Name('int'), listParameters=[cast('ast.Tuple', node.slice).elts[index]])
+					for index in range(len(cast('ast.Tuple', node.slice).elts))])))(node)
 		).visit(ingredientsFunction.astFunctionDef)
 
 	return ingredientsFunction
 
-def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2) -> IngredientsFunction:
-	"""Convert function parameters into initialized variables with concrete values.
-
-	This function converts function arguments into statically initialized variables in the function body.
-
-	The function handles different data types (scalars, arrays, custom types) appropriately, replacing abstract parameter
-	references with concrete values from the computation state. It also removes unused parameters and variables.
-
-	Parameters
-	----------
-	ingredientsFunction : IngredientsFunction
-		The function to transform.
-	job : RecipeJobTheorem2
-		Recipe containing concrete values for parameters and field metadata.
-
-	Returns
-	-------
-	modifiedFunction : IngredientsFunction
-		The modified function with parameters converted to initialized variables.
-
-	"""
-	ingredientsFunction.imports.update(job.shatteredDataclass.imports)
-
-	list_argCuzMyBrainRefusesToThink: list[ast.arg] = ingredientsFunction.astFunctionDef.args.args + ingredientsFunction.astFunctionDef.args.posonlyargs + ingredientsFunction.astFunctionDef.args.kwonlyargs
-	list_arg_arg: list[str] = [ast_arg.arg for ast_arg in list_argCuzMyBrainRefusesToThink]
-	listName: list[ast.Name] = []
-	NodeTourist(Be.Name, Then.appendTo(listName)).visit(ingredientsFunction.astFunctionDef)
-	listIdentifiers: list[str] = [astName.id for astName in listName]
-	listIdentifiersNotUsed: list[str] = list(set(list_arg_arg) - set(listIdentifiers))
-
-	for ast_arg in list_argCuzMyBrainRefusesToThink:
-		if ast_arg.arg in job.shatteredDataclass.field2AnnAssign:
-			if ast_arg.arg in listIdentifiersNotUsed:
-				pass
-			else:
-				Ima___Assign, elementConstructor = job.shatteredDataclass.Z0Z_field2AnnAssign[ast_arg.arg]
-				match elementConstructor:
-					case 'scalar':
-						cast('ast.Constant', cast('ast.Call', Ima___Assign.value).args[0]).value = int(job.state.__dict__[ast_arg.arg])
-					case 'array':
-						dataAsStrRLE: str = autoDecodingRLE(job.state.__dict__[ast_arg.arg], assumeAddSpaces=True)
-						dataAs_ast_expr: ast.expr = _pythonCode2expr(dataAsStrRLE)
-						cast('ast.Call', Ima___Assign.value).args = [dataAs_ast_expr]
-					case _:
-						pass
-
-				ingredientsFunction.astFunctionDef.body.insert(0, Ima___Assign)
-
-			NodeChanger(IfThis.is_argIdentifier(ast_arg.arg), Then.removeIt).visit(ingredientsFunction.astFunctionDef)
-
-	ast.fix_missing_locations(ingredientsFunction.astFunctionDef)
-	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.
 
-	This function orchestrates the complete code transformation assembly line to convert
-	a generic map folding algorithm into a highly optimized, specialized computation
-	module.
+	This function orchestrates the complete code transformation assembly line to convert a generic map folding algorithm into a
+	highly optimized, specialized computation module.
 
 	Parameters
 	----------
@@ -204,53 +168,57 @@ def makeJob(job: RecipeJobTheorem2) -> None:
 			, Then.replaceWith(Make.Constant(int(job.state.__dict__[identifier])))
 		).visit(ingredientsCount.astFunctionDef)
 
-	linesLaunch: str = f"""
-if __name__ == '__main__':
-	foldsTotal = {job.countCallable}()
-	print('\\nmap {job.state.mapShape} =', foldsTotal)
-	writeStream = open('{job.pathFilenameFoldsTotal.as_posix()}', 'w')
-	writeStream.write(str(foldsTotal))
-	writeStream.close()
-"""
-	ingredientsModule = IngredientsModule(launcher=ast.parse(linesLaunch))
-
-	# TODO think about `groupsOfFolds *= DatatypeFoldsTotal({2 * job.state.leavesTotal}); return groupsOfFolds`
-	NodeChanger(Be.Return
-		, Then.replaceWith(Make.Return(job.shatteredDataclass.countingVariableName))).visit(ingredientsCount.astFunctionDef)
-	groupsOfFolds2foldsTotal = NodeChanger[ast.AugAssign, hasDOTvalue](
-		findThis=(lambda node: Be.AugAssign.targetIs(IfThis.isNameIdentifier(job.shatteredDataclass.countingVariableName.id))(node)
-			and Be.AugAssign.opIs(Be.Mult)(node)
-			and Be.AugAssign.valueIs(Be.Constant)(node)
-		)
-		, doThat=lambda node: Grab.valueAttribute(Then.replaceWith(Make.Constant(job.state.leavesTotal * ast.literal_eval(node.value))))(node)
-	)
-	groupsOfFolds2foldsTotal.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)
 
-	# TODO think about assigning `returns` here, then removing `returns` a few lines from now.
-	ingredientsCount.astFunctionDef.returns = job.shatteredDataclass.countingVariableAnnotation
+	ingredientsCount = _addWriteFoldsTotal(ingredientsCount, job)
+	ingredientsCount = _variableCompatibility(ingredientsCount, job)
 
-	ingredientsCount = move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsCount, job)
+	ingredientsModule = IngredientsModule(launcher=Make.Module([
+		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)
-	# NOTE Reminder, `returns = None` means "type information is null"; the identifier for the return was removed by `_datatypeDefinitions`.
-	ingredientsCount.astFunctionDef.returns = None
-
-	ingredientsCount = _variableCompatibility(ingredientsCount, job)
 
 	ingredientsModule.appendIngredientsFunction(ingredientsCount)
-	write_astModule(ingredientsModule, pathFilename=job.pathFilenameModule, packageName=job.packageIdentifier)
 
 	if sys.platform == 'linux':
-		pathFilenameBuild = Path.home() / 'mapFolding' / 'jobs' / job.pathFilenameModule.stem
-		pathFilenameBuild.parent.mkdir(parents=True, exist_ok=True)
+		buildCommand: list[str] = ['codon', 'build', '--exe', '--release',
+			'--fast-math', '--enable-unsafe-fp-math', '--disable-exceptions',
+			'--mcpu=native',
+			'-o', str(job.pathFilenameModule.with_suffix('')),
+			'-']
+		streamText = subprocess.Popen(buildCommand, stdin=subprocess.PIPE, text=True)
+		if streamText.stdin is not None:
+			write_astModule(ingredientsModule, pathFilename=cast('TextIOBase', streamText.stdin), packageName=job.packageIdentifier)
+			streamText.stdin.close()
+		streamText.wait()
+		subprocess.run(['/usr/bin/strip', str(job.pathFilenameModule.with_suffix(''))], check=False)
+		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)
+
+def fromMapShape(mapShape: tuple[DatatypeLeavesTotal, ...]) -> None:
+	"""Create a binary executable for a map-folding job from map dimensions.
+
+	This function initializes a map folding computation state from the given map shape, sets up the necessary file paths, and
+	generates an optimized executable for the specific map configuration.
 
-		buildCommand = ['codon', 'build', '-release', '-disable-exceptions', '-o', str(pathFilenameBuild), str(job.pathFilenameModule)]
-		subprocess.run(buildCommand)
+	Parameters
+	----------
+	mapShape : tuple[DatatypeLeavesTotal, ...]
+		Dimensions of the map as a tuple where each element represents the size
+		along one axis.
 
-if __name__ == '__main__':
-	state = initializeGroupsOfFolds(MapFoldingState((2,4)))
-	pathModule = PurePosixPath(packageSettings.pathPackage, 'jobs')
-	# TODO put `pathFilenameFoldsTotal` in wsl.
+	"""
+	state = initializeGroupsOfFolds(MapFoldingState(mapShape))
+	pathModule = PurePosixPath(Path.home(), 'mapFolding', 'jobs')
 	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
 	aJob = RecipeJobTheorem2(state, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
 	makeJob(aJob)
+
+if __name__ == '__main__':
+	mapShape = (2, 21)
+	fromMapShape(mapShape)
+

mapFolding/someAssemblyRequired/toolkitNumba.py

@@ -26,7 +26,9 @@ system to produce standalone modules optimized for specific map dimensions and c
 """
 
 from astToolkit import identifierDotAttribute, IngredientsFunction, Make
-from typing import cast, Final, NotRequired, TYPE_CHECKING, TypedDict
+from collections.abc import Callable
+from numba.core.compiler import CompilerBase as numbaCompilerBase
+from typing import Any, Final, NotRequired, TYPE_CHECKING, TypedDict
 import ast
 import dataclasses
 import warnings
@@ -69,7 +71,7 @@ class ParametersNumba(TypedDict):
 	forceinline: NotRequired[bool]
 	forceobj: NotRequired[bool]
 	inline: NotRequired[str]
-	# locals: NotRequired[dict[str, Any]]
+	locals: NotRequired[dict[str, Any]]
 	looplift: NotRequired[bool]
 	no_cfunc_wrapper: NotRequired[bool]
 	no_cpython_wrapper: NotRequired[bool]
@@ -77,8 +79,8 @@ class ParametersNumba(TypedDict):
 	nogil: NotRequired[bool]
 	nopython: NotRequired[bool]
 	parallel: NotRequired[bool]
-	# pipeline_class: NotRequired[type[numbaCompilerBase]]
-	# signature_or_function: NotRequired[Any | Callable[..., Any] | str | tuple[Any, ...]]
+	pipeline_class: NotRequired[type[numbaCompilerBase]]
+	signature_or_function: NotRequired[Any | Callable[..., Any] | str | tuple[Any, ...]]
 	target: NotRequired[str]
 
 parametersNumbaDefault: Final[ParametersNumba] = { '_nrt': True, 'boundscheck': False, 'cache': True, 'error_model': 'numpy', 'fastmath': True, 'forceinline': True, 'inline': 'always', 'looplift': False, 'no_cfunc_wrapper': False, 'no_cpython_wrapper': False, 'nopython': True, 'parallel': False }
@@ -257,10 +259,10 @@ def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, paramete
 
 	if ingredientsFunction.astFunctionDef.returns and isinstance(ingredientsFunction.astFunctionDef.returns, ast.Name):
 		theReturn: ast.Name = ingredientsFunction.astFunctionDef.returns
-		list_argsDecorator = [cast("ast.expr", Make.Call(Make.Name(theReturn.id)
-							, list_arg4signature_or_function if list_arg4signature_or_function else [], [] ) )]
+		list_argsDecorator = [Make.Call(Make.Name(theReturn.id)
+							, list_arg4signature_or_function if list_arg4signature_or_function else [], [] )]
 	elif list_arg4signature_or_function:
-		list_argsDecorator = [cast("ast.expr", Make.Tuple(list_arg4signature_or_function))]
+		list_argsDecorator = [Make.Tuple(list_arg4signature_or_function)]
 
 	ingredientsFunction.astFunctionDef = Z0Z_UnhandledDecorators(ingredientsFunction.astFunctionDef)
 	if parametersNumba is None:

mapFolding/tests/conftest.py

@@ -24,8 +24,8 @@ research domain.
 """
 
 from collections.abc import Callable, Generator, Sequence
-from mapFolding import getLeavesTotal, makeDataContainer, oeis, packageSettings, validateListDimensions
-from mapFolding.oeis import oeisIDsImplemented, settingsOEIS
+from mapFolding import _theSSOT, getLeavesTotal, makeDataContainer, packageSettings, validateListDimensions
+from mapFolding.oeis import dictionaryOEIS, oeisIDsImplemented
 from pathlib import Path
 from typing import Any
 import numpy
@@ -149,10 +149,10 @@ def pathCacheTesting(path_tmpTesting: Path) -> Generator[Path, Any, None]:
 		Context manager that provides the temporary cache path and restores original.
 
 	"""
-	pathCacheOriginal = oeis.pathCache
-	oeis.pathCache = path_tmpTesting
+	pathCacheOriginal = _theSSOT.pathCache
+	_theSSOT.pathCache = path_tmpTesting
 	yield path_tmpTesting
-	oeis.pathCache = pathCacheOriginal
+	_theSSOT.pathCache = pathCacheOriginal
 
 @pytest.fixture
 def pathFilenameFoldsTotalTesting(path_tmpTesting: Path) -> Path:
@@ -212,10 +212,10 @@ def oneTestCuzTestsOverwritingTests(oeisID_1random: str) -> tuple[int, ...]:
 
 	"""
 	while True:
-		n = random.choice(settingsOEIS[oeisID_1random]['valuesTestValidation'])
+		n = random.choice(dictionaryOEIS[oeisID_1random]['valuesTestValidation'])
 		if n < 2:
 			continue
-		listDimensionsCandidate = list(settingsOEIS[oeisID_1random]['getMapShape'](n))
+		listDimensionsCandidate = list(dictionaryOEIS[oeisID_1random]['getMapShape'](n))
 
 		try:
 			return validateListDimensions(listDimensionsCandidate)
@@ -238,10 +238,10 @@ def mapShapeTestCountFolds(oeisID: str) -> tuple[int, ...]:
 
 	"""
 	while True:
-		n = random.choice(settingsOEIS[oeisID]['valuesTestValidation'])
+		n = random.choice(dictionaryOEIS[oeisID]['valuesTestValidation'])
 		if n < 2:
 			continue
-		listDimensionsCandidate = list(settingsOEIS[oeisID]['getMapShape'](n))
+		listDimensionsCandidate = list(dictionaryOEIS[oeisID]['getMapShape'](n))
 
 		try:
 			return validateListDimensions(listDimensionsCandidate)
@@ -266,10 +266,10 @@ def mapShapeTestFunctionality(oeisID_1random: str) -> tuple[int, ...]:
 
 	"""
 	while True:
-		n = random.choice(settingsOEIS[oeisID_1random]['valuesTestValidation'])
+		n = random.choice(dictionaryOEIS[oeisID_1random]['valuesTestValidation'])
 		if n < 2:
 			continue
-		listDimensionsCandidate = list(settingsOEIS[oeisID_1random]['getMapShape'](n))
+		listDimensionsCandidate = list(dictionaryOEIS[oeisID_1random]['getMapShape'](n))
 
 		try:
 			return validateListDimensions(listDimensionsCandidate)
@@ -291,8 +291,8 @@ def mapShapeTestParallelization(oeisID: str) -> tuple[int, ...]:
 		Map dimensions suitable for testing parallelization features.
 
 	"""
-	n = random.choice(settingsOEIS[oeisID]['valuesTestParallelization'])
-	return settingsOEIS[oeisID]['getMapShape'](n)
+	n = random.choice(dictionaryOEIS[oeisID]['valuesTestParallelization'])
+	return dictionaryOEIS[oeisID]['getMapShape'](n)
 
 @pytest.fixture
 def mockBenchmarkTimer() -> Generator[unittest.mock.MagicMock | unittest.mock.AsyncMock, Any, None]:

mapFolding/tests/test_computations.py

@@ -27,9 +27,9 @@ which is useful if you're working with the code synthesis features of the packag
 
 from mapFolding import countFolds, getFoldsTotalKnown, oeisIDfor_n
 from mapFolding.dataBaskets import MapFoldingState
-from mapFolding.oeis import settingsOEIS
-from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2
+from mapFolding.oeis import dictionaryOEIS
 from mapFolding.someAssemblyRequired.makeAllModules import parametersNumbaLight
+from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2
 from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
 from mapFolding.tests.conftest import registrarRecordsTemporaryFilesystemObject, standardizedEqualToCallableReturn
 from pathlib import Path, PurePosixPath
@@ -83,8 +83,8 @@ def test_aOFn_calculate_value(oeisID: str) -> None:
 		The OEIS sequence identifier to test calculations for.
 
 	"""
-	for n in settingsOEIS[oeisID]['valuesTestValidation']:
-		standardizedEqualToCallableReturn(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
+	for n in dictionaryOEIS[oeisID]['valuesTestValidation']:
+		standardizedEqualToCallableReturn(dictionaryOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
 
 @pytest.mark.parametrize('pathFilename_tmpTesting', ['.py'], indirect=True)
 def test_writeJobNumba(oneTestCuzTestsOverwritingTests: tuple[int, ...], pathFilename_tmpTesting: Path) -> None: