mapFolding 0.7.0__tar.gz → 0.7.1__tar.gz

{mapfolding-0.7.0 → mapfolding-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.7.0
+Version: 0.7.1
 Summary: Count distinct ways to fold a map (or a strip of stamps)
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0

{mapfolding-0.7.0 → mapfolding-0.7.1}/mapFolding/__init__.py

@@ -1,4 +1,4 @@
-from mapFolding.basecamp import countFolds
+from mapFolding.basecamp import countFolds as countFolds
 from mapFolding.oeis import clearOEIScache, getOEISids, OEIS_for_n
 
 __all__ = [

{mapfolding-0.7.0 → mapfolding-0.7.1}/mapFolding/basecamp.py

@@ -43,8 +43,8 @@ def countFolds(listDimensions: Sequence[int]
 	concurrencyLimit: int = setCPUlimit(CPUlimit)
 	computationStateInitialized: ComputationState = outfitCountFolds(mapShape, computationDivisions, concurrencyLimit)
 
-	dispatcher = getPackageDispatcher()
-	computationStateComplete: ComputationState = dispatcher(computationStateInitialized)
+	dispatcherCallableProxy = getPackageDispatcher()
+	computationStateComplete: ComputationState = dispatcherCallableProxy(computationStateInitialized)
 
 	computationStateComplete.getFoldsTotal()
 

{mapfolding-0.7.0 → mapfolding-0.7.1}/mapFolding/beDRY.py

@@ -73,7 +73,14 @@ def makeDataContainer(shape: int | tuple[int, ...], datatype: type[numpy.signedi
 	return numpy.zeros(shape, dtype=numpyDtype)
 
 def setCPUlimit(CPUlimit: Any | None) -> int:
-	"""Sets CPU limit for Numba concurrent operations. Note that it can only affect Numba-jitted functions that have not yet been imported.
+	"""Sets CPU limit for concurrent operations.
+
+	If the concurrency is managed by `numba`, the maximum number of CPUs is retrieved from `numba.get_num_threads()` and not by polling the hardware. Therefore, if there are
+	numba environment variables limiting the number of available CPUs, that will effect this function. That _should_ be a good thing: you control the number of CPUs available
+	to numba. But if you're not aware of that, you might be surprised by the results.
+
+	If you are designing custom modules that use numba, note that you must call `numba.set_num_threads()` (i.e., this function) before executing an `import` statement
+	on a Numba-jitted function. Otherwise, the `numba.set_num_threads()` call will have no effect on the imported function.
 
 	Parameters:
 		CPUlimit: whether and how to limit the CPU usage. See notes for details.
@@ -93,17 +100,17 @@ def setCPUlimit(CPUlimit: Any | None) -> int:
 	if not (CPUlimit is None or isinstance(CPUlimit, (bool, int, float))):
 		CPUlimit = oopsieKwargsie(CPUlimit)
 
-	concurrencyLimit: int = int(defineConcurrencyLimit(CPUlimit))
 	from mapFolding.theSSOT import concurrencyPackage
 	if concurrencyPackage == 'numba':
 		from numba import get_num_threads, set_num_threads
+		concurrencyLimit: int = defineConcurrencyLimit(CPUlimit, get_num_threads())
 		set_num_threads(concurrencyLimit)
 		concurrencyLimit = get_num_threads()
 	elif concurrencyPackage == 'algorithm':
-		concurrencyLimit = 1
+		# When to use multiprocessing.set_start_method https://github.com/hunterhogan/mapFolding/issues/6
+		concurrencyLimit: int = defineConcurrencyLimit(CPUlimit)
 	else:
-		raise NotImplementedError("This function only supports the 'numba' concurrency package.")
-
+		raise NotImplementedError(f"I received {concurrencyPackage=} but I don't know what to do with that.")
 	return concurrencyLimit
 
 def getTaskDivisions(computationDivisions: int | str | None, concurrencyLimit: int, leavesTotal: int) -> int:
@@ -160,5 +167,5 @@ def getTaskDivisions(computationDivisions: int | str | None, concurrencyLimit: i
 def outfitCountFolds(mapShape: tuple[int, ...], computationDivisions: int | str | None = None, concurrencyLimit: int = 1) -> ComputationState:
 	leavesTotal = getLeavesTotal(mapShape)
 	taskDivisions = getTaskDivisions(computationDivisions, concurrencyLimit, leavesTotal)
-	computationStateInitialized = ComputationState(mapShape, leavesTotal, taskDivisions)
+	computationStateInitialized = ComputationState(mapShape, leavesTotal, taskDivisions, concurrencyLimit)
 	return computationStateInitialized

{mapfolding-0.7.0 → mapfolding-0.7.1}/mapFolding/filesystem.py

@@ -1,35 +1,8 @@
 """Filesystem functions for mapFolding package."""
-from pathlib import Path
+from pathlib import Path, PurePath
+from typing import Any
 import os
 
-def saveFoldsTotal(pathFilename: str | os.PathLike[str], foldsTotal: int) -> None:
-	"""
-	Save foldsTotal with multiple fallback mechanisms.
-
-	Parameters:
-		pathFilename: Target save location
-		foldsTotal: Critical computed value to save
-	"""
-	try:
-		pathFilenameFoldsTotal = Path(pathFilename)
-		pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
-		pathFilenameFoldsTotal.write_text(str(foldsTotal))
-	except Exception as ERRORmessage:
-		try:
-			print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
-			print(ERRORmessage)
-			print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
-			randomnessPlanB = (int(str(foldsTotal).strip()[-1]) + 1) * ['YO_']
-			filenameInfixUnique = ''.join(randomnessPlanB)
-			pathFilenamePlanB = os.path.join(os.getcwd(), 'foldsTotal' + filenameInfixUnique + '.txt')
-			writeStreamFallback = open(pathFilenamePlanB, 'w')
-			writeStreamFallback.write(str(foldsTotal))
-			writeStreamFallback.close()
-			print(str(pathFilenamePlanB))
-		except Exception:
-			print(foldsTotal)
-	return None
-
 def getFilenameFoldsTotal(mapShape: tuple[int, ...]) -> str:
 	"""Imagine your computer has been counting folds for 9 days, and when it tries to save your newly discovered value,
 	the filename is invalid. I bet you think this function is more important after that thought experiment.
@@ -85,3 +58,38 @@ def getPathFilenameFoldsTotal(mapShape: tuple[int, ...], pathLikeWriteFoldsTotal
 
 	pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
 	return pathFilenameFoldsTotal
+
+def saveFoldsTotal(pathFilename: str | os.PathLike[str], foldsTotal: int) -> None:
+	"""
+	Save foldsTotal with multiple fallback mechanisms.
+
+	Parameters:
+		pathFilename: Target save location
+		foldsTotal: Critical computed value to save
+	"""
+	try:
+		pathFilenameFoldsTotal = Path(pathFilename)
+		pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
+		pathFilenameFoldsTotal.write_text(str(foldsTotal))
+	except Exception as ERRORmessage:
+		try:
+			print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
+			print(ERRORmessage)
+			print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
+			randomnessPlanB = (int(str(foldsTotal).strip()[-1]) + 1) * ['YO_']
+			filenameInfixUnique = ''.join(randomnessPlanB)
+			pathFilenamePlanB = os.path.join(os.getcwd(), 'foldsTotal' + filenameInfixUnique + '.txt')
+			writeStreamFallback = open(pathFilenamePlanB, 'w')
+			writeStreamFallback.write(str(foldsTotal))
+			writeStreamFallback.close()
+			print(str(pathFilenamePlanB))
+		except Exception:
+			print(foldsTotal)
+	return None
+
+def writeStringToHere(this: str, pathFilename: str | os.PathLike[Any] | PurePath) -> None:
+	"""Write the string `this` to the file at `pathFilename`."""
+	pathFilename = Path(pathFilename)
+	pathFilename.parent.mkdir(parents=True, exist_ok=True)
+	pathFilename.write_text(str(this))
+	return None

{mapfolding-0.7.0 → mapfolding-0.7.1}/mapFolding/someAssemblyRequired/Z0Z_workbench.py

@@ -1,4 +1,3 @@
-from mapFolding.someAssemblyRequired.synthesizeDataConverters import makeStateJob
 from mapFolding.someAssemblyRequired.synthesizeDataConverters import makeDataclassConverter
 from mapFolding.someAssemblyRequired.whatWillBe import IngredientsFunction, IngredientsModule, numbaFlow
 from mapFolding.someAssemblyRequired.synthesizeCountingFunctions import Z0Z_makeCountingFunction
@@ -6,13 +5,13 @@ import ast
 
 if __name__ == '__main__':
 	ingredientsFunctionDataConverter = makeDataclassConverter(
-		dataclassIdentifierAsStr=numbaFlow.dataclassIdentifierAsStr
+		dataclassIdentifier=numbaFlow.sourceDataclassIdentifier
 		, logicalPathModuleDataclass=numbaFlow.logicalPathModuleDataclass
-		, dataclassInstanceAsStr=numbaFlow.dataclassInstanceAsStr
+		, dataclassInstance=numbaFlow.dataclassInstance
 
-		, dispatcherCallableAsStr=numbaFlow.dispatcherCallableAsStr
+		, dispatcherCallable=numbaFlow.dispatcherCallable
 		, logicalPathModuleDispatcher=numbaFlow.logicalPathModuleDispatcher
-		, dataConverterCallableAsStr=numbaFlow.dataConverterCallableAsStr
+		, dataConverterCallable=numbaFlow.dataConverterCallable
 		)
 
 	# initialize with theDao
@@ -20,7 +19,7 @@ if __name__ == '__main__':
 	ingredientsFunctionDataConverter.FunctionDef.body.insert(0, ast.parse(dataInitializationHack).body[0])
 	ingredientsFunctionDataConverter.imports.addImportFromStr('mapFolding.someAssemblyRequired', 'makeStateJob')
 
-	ingredientsSequential = Z0Z_makeCountingFunction(numbaFlow.sequentialCallableAsStr
+	ingredientsSequential = Z0Z_makeCountingFunction(numbaFlow.sequentialCallable
 													, numbaFlow.sourceAlgorithm
 													, inline=True
 													, dataclass=False)
@@ -28,7 +27,7 @@ if __name__ == '__main__':
 	ingredientsModuleDataConverter = IngredientsModule(
 		name=numbaFlow.dataConverterModule,
 		ingredientsFunction=ingredientsFunctionDataConverter,
-		logicalPathINFIX=numbaFlow.moduleOfSyntheticModules,
+		logicalPathINFIX=numbaFlow.Z0Z_flowLogicalPathRoot,
 	)
 
 	ingredientsModuleDataConverter.writeModule()

{mapfolding-0.7.0 → mapfolding-0.7.1}/mapFolding/someAssemblyRequired/synthesizeDataConverters.py

@@ -67,19 +67,19 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: strDotStrCuzPyStoopid, da
 	astTupleForAssignTargetsToFragments: ast.Tuple = Make.astTuple(list_astNameDataclassFragments, ast.Store())
 	return astNameDataclass, ledgerDataclassAndFragments, list_astAnnAssign, list_astNameDataclassFragments, listKeywordForDataclassInitialization, astTupleForAssignTargetsToFragments
 
-def makeDataclassConverter(dataclassIdentifierAsStr: str,
+def makeDataclassConverter(dataclassIdentifier: str,
 		logicalPathModuleDataclass: str,
-		dataclassInstanceAsStr: str,
-		dispatcherCallableAsStr: str,
+		dataclassInstance: str,
+		dispatcherCallable: str,
 		logicalPathModuleDispatcher: str,
-		dataConverterCallableAsStr: str,
+		dataConverterCallable: str,
 		) -> IngredientsFunction:
 
-	astNameDataclass, ledgerDataclassAndFragments, list_astAnnAssign, list_astNameDataclassFragments, list_astKeywordDataclassFragments, astTupleForAssignTargetsToFragments = shatter_dataclassesDOTdataclass(logicalPathModuleDataclass, dataclassIdentifierAsStr, dataclassInstanceAsStr)
+	astNameDataclass, ledgerDataclassAndFragments, list_astAnnAssign, list_astNameDataclassFragments, list_astKeywordDataclassFragments, astTupleForAssignTargetsToFragments = shatter_dataclassesDOTdataclass(logicalPathModuleDataclass, dataclassIdentifier, dataclassInstance)
 
 	ingredientsFunction = IngredientsFunction(
-		FunctionDef = Make.astFunctionDef(name=dataConverterCallableAsStr
-										, argumentsSpecification=Make.astArgumentsSpecification(args=[Make.astArg(dataclassInstanceAsStr, astNameDataclass)])
+		FunctionDef = Make.astFunctionDef(name=dataConverterCallable
+										, argumentsSpecification=Make.astArgumentsSpecification(args=[Make.astArg(dataclassInstance, astNameDataclass)])
 										, body = cast(list[ast.stmt], list_astAnnAssign)
 										, returns = astNameDataclass
 										)
@@ -87,9 +87,9 @@ def makeDataclassConverter(dataclassIdentifierAsStr: str,
 	)
 
 	callToDispatcher = Make.astAssign(listTargets=[astTupleForAssignTargetsToFragments]
-										, value=Make.astCall(Make.astName(dispatcherCallableAsStr), args=list_astNameDataclassFragments))
+										, value=Make.astCall(Make.astName(dispatcherCallable), args=list_astNameDataclassFragments))
 	ingredientsFunction.FunctionDef.body.append(callToDispatcher)
-	ingredientsFunction.imports.addImportFromStr(logicalPathModuleDispatcher, dispatcherCallableAsStr)
+	ingredientsFunction.imports.addImportFromStr(logicalPathModuleDispatcher, dispatcherCallable)
 
 	ingredientsFunction.FunctionDef.body.append(Make.astReturn(Make.astCall(astNameDataclass, list_astKeywords=list_astKeywordDataclassFragments)))
 

{mapfolding-0.7.0 → mapfolding-0.7.1}/mapFolding/someAssemblyRequired/transformationTools.py

@@ -316,7 +316,7 @@ class Make:
 
 	@staticmethod
 	def astModule(body: list[ast.stmt], type_ignores: list[ast.TypeIgnore] = []) -> ast.Module:
-		return ast.Module(body=body, type_ignores=type_ignores)
+		return ast.Module(body, type_ignores)
 
 	@staticmethod
 	def astName(identifier: ast_Identifier) -> ast.Name:

{mapfolding-0.7.0 → mapfolding-0.7.1}/mapFolding/someAssemblyRequired/whatWillBe.py

@@ -4,68 +4,69 @@
 - Therefore, an abstracted system for creating settings for the package
 - And with only a little more effort, an abstracted system for creating settings to synthesize arbitrary subsets of modules for arbitrary packages
 """
-from mapFolding.someAssemblyRequired.transformationTools import *
+from mapFolding.someAssemblyRequired.transformationTools import (
+	ast_Identifier,
+	executeActionUnlessDescendantMatches,
+	extractClassDef,
+	extractFunctionDef,
+	ifThis,
+	Make,
+	NodeCollector,
+	NodeReplacer,
+	strDotStrCuzPyStoopid,
+	Then,
+)
+from mapFolding.filesystem import writeStringToHere
 from mapFolding.theSSOT import (
 	FREAKOUT,
 	getDatatypePackage,
 	getSourceAlgorithm,
-	theDataclassIdentifierAsStr,
-	theDataclassInstanceAsStr,
-	theDispatcherCallableAsStr,
+	theDataclassIdentifier,
+	theDataclassInstance,
+	theDispatcherCallable,
 	theFileExtension,
 	theFormatStrModuleForCallableSynthetic,
 	theFormatStrModuleSynthetic,
 	theLogicalPathModuleDataclass,
 	theLogicalPathModuleDispatcherSynthetic,
+	theModuleDispatcherSynthetic,
 	theModuleOfSyntheticModules,
 	thePackageName,
 	thePathPackage,
-	Z0Z_sequentialCallableAsStr,
+	theSourceInitializeCallable,
+	theSourceParallelCallable,
+	theSourceSequentialCallable,
 )
 from autoflake import fix_code as autoflake_fix_code
 from collections import defaultdict
 from collections.abc import Sequence
 from inspect import getsource as inspect_getsource
 from mapFolding.someAssemblyRequired.ingredientsNumba import parametersNumbaDEFAULT, parametersNumbaSuperJit, parametersNumbaSuperJitParallel, ParametersNumba
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from types import ModuleType
 from typing import NamedTuple
 from Z0Z_tools import updateExtendPolishDictionaryLists
 import ast
 import dataclasses
 
-"""
-Start with what is: theDao.py
-Create settings that can transform into what I or the user want it to be.
-
-The simplest flow with numba is:
-1. one module
-2. dispatcher
-	- initialize data with makeJob
-	- smash dataclass
-	- call countSequential
-3. countSequential
-	- jitted, not super-jitted
-	- functions inlined (or I'd have to jit them)
-	- return groupsOfFolds
-4. recycle the dataclass with groupsOfFolds
-5. return the dataclass
-"""
-
 @dataclasses.dataclass
 class RecipeSynthesizeFlow:
 	"""Settings for synthesizing flow."""
 	# TODO consider `IngredientsFlow` or similar
+	# ========================================
+	# Source
 	sourceAlgorithm: ModuleType = getSourceAlgorithm()
 	sourcePython: str = inspect_getsource(sourceAlgorithm)
-	# sourcePython: str = inspect_getsource(self.sourceAlgorithm)
-	# "self" is not defined
-	# I still hate the OOP paradigm. But I like this dataclass stuff.
 	source_astModule: ast.Module = ast.parse(sourcePython)
+	# https://github.com/hunterhogan/mapFolding/issues/4
+	sourceDispatcherCallable: str = theDispatcherCallable
+	sourceSequentialCallable: str = theSourceSequentialCallable
+	sourceDataclassIdentifier: str = theDataclassIdentifier
+	# I still hate the OOP paradigm. But I like this dataclass stuff.
 
 	# ========================================
 	# Filesystem
-	pathPackage: Path = thePathPackage
+	pathPackage: PurePosixPath = PurePosixPath(thePathPackage)
 	fileExtension: str = theFileExtension
 
 	# ========================================
@@ -78,19 +79,23 @@ class RecipeSynthesizeFlow:
 	packageName: ast_Identifier = thePackageName
 
 	# Module
-	moduleOfSyntheticModules: str = theModuleOfSyntheticModules
+	# https://github.com/hunterhogan/mapFolding/issues/4
+	Z0Z_flowLogicalPathRoot: str = theModuleOfSyntheticModules
+	moduleDispatcher: str = theModuleDispatcherSynthetic
 	logicalPathModuleDataclass: str = theLogicalPathModuleDataclass
+	# https://github.com/hunterhogan/mapFolding/issues/4
+	# `theLogicalPathModuleDispatcherSynthetic` is a problem. It is defined in theSSOT, but it can also be calculated.
 	logicalPathModuleDispatcher: str = theLogicalPathModuleDispatcherSynthetic
 	dataConverterModule: str = 'dataNamespaceFlattened'
 
 	# Function
-	dataclassIdentifierAsStr: str = theDataclassIdentifierAsStr
-	dispatcherCallableAsStr: str = theDispatcherCallableAsStr
-	dataConverterCallableAsStr: str = 'flattenData'
-	sequentialCallableAsStr: str = Z0Z_sequentialCallableAsStr
+	sequentialCallable: str = sourceSequentialCallable
+	dataclassIdentifier: str = sourceDataclassIdentifier
+	dataConverterCallable: str = 'unpackDataclassPackUp'
+	dispatcherCallable: str = sourceDispatcherCallable
 
 	# Variable
-	dataclassInstanceAsStr: str = theDataclassInstanceAsStr
+	dataclassInstance: str = theDataclassInstance
 
 class LedgerOfImports:
 	def __init__(self, startWith: ast.AST | None = None) -> None:
@@ -117,6 +122,11 @@ class LedgerOfImports:
 	def addImportFromStr(self, module: str, name: str, asname: str | None = None) -> None:
 		self.dictionaryImportFrom[module].append((name, asname))
 
+	def exportListModuleNames(self) -> list[str]:
+		listModuleNames: list[str] = list(self.dictionaryImportFrom.keys())
+		listModuleNames.extend(self.listImport)
+		return sorted(set(listModuleNames))
+
 	def makeListAst(self) -> list[ast.ImportFrom | ast.Import]:
 		listAstImportFrom: list[ast.ImportFrom] = []
 
@@ -147,6 +157,12 @@ class LedgerOfImports:
 			if isinstance(smurf, (ast.Import, ast.ImportFrom)):
 				self.addAst(smurf)
 
+@dataclasses.dataclass
+class Z0Z_IngredientsDataStructure:
+	"""Everything necessary to create a data structure should be here."""
+	dataclassDef: ast.ClassDef
+	imports: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
+
 @dataclasses.dataclass
 class IngredientsFunction:
 	"""Everything necessary to integrate a function into a module should be here."""
@@ -155,21 +171,89 @@ class IngredientsFunction:
 
 @dataclasses.dataclass
 class IngredientsModule:
-	"""Everything necessary to create a module, including the package context, should be here."""
-	name: ast_Identifier
+	"""Everything necessary to create one _logical_ `ast.Module` should be here.
+	Extrinsic qualities should be handled externally, such as with `RecipeModule`."""
+	# If an `ast.Module` had a logical name that would be reasonable, but Python is firmly opposed
+	# to a reasonable namespace, therefore, Hunter, you were silly to add a `name` field to this
+	# dataclass for building an `ast.Module`.
+	# name: ast_Identifier
+	# Hey, genius, note that this is dataclasses.InitVar
 	ingredientsFunction: dataclasses.InitVar[Sequence[IngredientsFunction] | IngredientsFunction | None] = None
 
+	# `body` attribute of `ast.Module`
 	imports: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
 	prologue: list[ast.stmt] = dataclasses.field(default_factory=list)
 	functions: list[ast.FunctionDef | ast.stmt] = dataclasses.field(default_factory=list)
 	epilogue: list[ast.stmt] = dataclasses.field(default_factory=list)
 	launcher: list[ast.stmt] = dataclasses.field(default_factory=list)
 
+	# parameter for `ast.Module` constructor
+	type_ignores: list[ast.TypeIgnore] = dataclasses.field(default_factory=list)
+
+	def __post_init__(self, ingredientsFunction: Sequence[IngredientsFunction] | IngredientsFunction | None = None) -> None:
+		if ingredientsFunction is not None:
+			if isinstance(ingredientsFunction, IngredientsFunction):
+				self.addIngredientsFunction(ingredientsFunction)
+			else:
+				self.addIngredientsFunction(*ingredientsFunction)
+
+	def addIngredientsFunction(self, *ingredientsFunction: IngredientsFunction) -> None:
+		"""Add one or more `IngredientsFunction`. """
+		listLedgers: list[LedgerOfImports] = []
+		for definition in ingredientsFunction:
+			self.functions.append(definition.FunctionDef)
+			listLedgers.append(definition.imports)
+		self.imports.update(*listLedgers)
+
+	def _makeModuleBody(self) -> list[ast.stmt]:
+		body: list[ast.stmt] = []
+		body.extend(self.imports.makeListAst())
+		body.extend(self.prologue)
+		body.extend(self.functions)
+		body.extend(self.epilogue)
+		body.extend(self.launcher)
+		# TODO `launcher`, if it exists, must start with `if __name__ == '__main__':` and be indented
+		return body
+
+	def export(self) -> ast.Module:
+		"""Create a new `ast.Module` from the ingredients."""
+		return Make.astModule(self._makeModuleBody(), self.type_ignores)
+
+@dataclasses.dataclass
+class RecipeCountingFunction:
+	"""Settings for synthesizing counting functions."""
+	ingredients: IngredientsFunction
+
+@dataclasses.dataclass
+class RecipeDispatchFunction:
+	# A "dispatcher" must receive a dataclass instance and return a dataclass instance.
+	# computationStateComplete: ComputationState = dispatcher(computationStateInitialized)
+	# The most critical values in the returned dataclass are foldGroups[0:-1] and leavesTotal
+	# self.foldsTotal = DatatypeFoldsTotal(self.foldGroups[0:-1].sum() * self.leavesTotal)
+	# the function name is required by IngredientsFunction
+	ingredients: IngredientsFunction
+	logicalPathModuleDataclass: str = theLogicalPathModuleDataclass
+	dataclassIdentifier: str = theDataclassIdentifier
+	dataclassInstance: str = theDataclassInstance
+	Z0Z_unpackDataclass: bool = True
+	countDispatcher: bool = True
+	# is this the countDispatcher or what is the information for calling the countDispatcher: import or no? callable identifier? parameters? return type?
+	# countDispatcher lives in `theLogicalPathModuleDispatcherSynthetic`
+	# countDispatcher is named `theDispatcherCallable`
+	# post init
+	# addImportFromStr(self, module: str, name: str, asname: str | None = None)
+
+@dataclasses.dataclass
+class RecipeModule:
+	"""How to get one or more logical `ast.Module` on disk as one physical module."""
+	# Physical namespace
+	filenameStem: str
+	fileExtension: str = theFileExtension
+	pathPackage: PurePosixPath = PurePosixPath(thePathPackage)
+
+	# Physical and logical namespace
 	packageName: ast_Identifier | None= thePackageName
 	logicalPathINFIX: ast_Identifier | strDotStrCuzPyStoopid | None = None # module names other than the module itself and the package name
-	pathPackage: Path = thePathPackage
-	fileExtension: str = theFileExtension
-	type_ignores: list[ast.TypeIgnore] = dataclasses.field(default_factory=list)
 
 	def _getLogicalPathParent(self) -> str | None:
 		listModules: list[ast_Identifier] = []
@@ -185,18 +269,22 @@ class IngredientsModule:
 		logicalPathParent: str | None = self._getLogicalPathParent()
 		if logicalPathParent:
 			listModules.append(logicalPathParent)
-		listModules.append(self.name)
+		listModules.append(self.filenameStem)
 		return '.'.join(listModules)
 
 	@property
-	def pathFilename(self) -> Path:
-		pathRoot: Path = self.pathPackage
-		filename = self.name + self.fileExtension
+	def pathFilename(self):
+		""" `PurePosixPath` ensures os-independent formatting of the `dataclass.field` value,
+		but you must convert to `Path` to perform filesystem operations."""
+		pathRoot: PurePosixPath = self.pathPackage
+		filename: str = self.filenameStem + self.fileExtension
 		if self.logicalPathINFIX:
-			whyIsThisStillAThing = self.logicalPathINFIX.split('.')
+			whyIsThisStillAThing: list[str] = self.logicalPathINFIX.split('.')
 			pathRoot = pathRoot.joinpath(*whyIsThisStillAThing)
 		return pathRoot.joinpath(filename)
 
+	ingredients: IngredientsModule = IngredientsModule()
+
 	@property
 	def absoluteImport(self) -> ast.Import:
 		return Make.astImport(self._getLogicalPathAbsolute())
@@ -204,76 +292,33 @@ class IngredientsModule:
 	@property
 	def absoluteImportFrom(self) -> ast.ImportFrom:
 		""" `from . import theModule` """
-		logicalPathParent: str | None = self._getLogicalPathParent()
-		if logicalPathParent is None:
-			logicalPathParent = '.'
-		return Make.astImportFrom(logicalPathParent, [Make.astAlias(self.name)])
-
-	def __post_init__(self, ingredientsFunction: Sequence[IngredientsFunction] | IngredientsFunction | None = None) -> None:
-		if ingredientsFunction is not None:
-			if isinstance(ingredientsFunction, IngredientsFunction):
-				self.addIngredientsFunction(ingredientsFunction)
-			else:
-				self.addIngredientsFunction(*ingredientsFunction)
-
-	def addIngredientsFunction(self, *ingredientsFunction: IngredientsFunction) -> None:
-		"""Add one or more `IngredientsFunction`. """
-		listLedgers: list[LedgerOfImports] = []
-		for definition in ingredientsFunction:
-			self.functions.append(definition.FunctionDef)
-			listLedgers.append(definition.imports)
-		self.imports.update(*listLedgers)
-
-	def _makeModuleBody(self) -> list[ast.stmt]:
-		"""Constructs the body of the module, including prologue, functions, epilogue, and launcher."""
-		body: list[ast.stmt] = []
-		body.extend(self.imports.makeListAst())
-		body.extend(self.prologue)
-		body.extend(self.functions)
-		body.extend(self.epilogue)
-		body.extend(self.launcher)
-		# TODO `launcher` must start with `if __name__ == '__main__':` and be indented
-		return body
+		logicalPathParent: str = self._getLogicalPathParent() or '.'
+		return Make.astImportFrom(logicalPathParent, [Make.astAlias(self.filenameStem)])
 
 	def writeModule(self) -> None:
-		"""Writes the module to disk with proper imports and functions.
-
-		This method creates a proper AST module with imports and function definitions,
-		fixes missing locations, unpacks the AST to Python code, applies autoflake
-		to clean up imports, and writes the resulting code to the appropriate file.
-		"""
-		astModule = Make.astModule(body=self._makeModuleBody(), type_ignores=self.type_ignores)
+		astModule = self.ingredients.export()
 		ast.fix_missing_locations(astModule)
 		pythonSource: str = ast.unparse(astModule)
 		if not pythonSource: raise FREAKOUT
-		autoflake_additional_imports: list[str] = []
+		autoflake_additional_imports: list[str] = self.ingredients.imports.exportListModuleNames()
 		if self.packageName:
 			autoflake_additional_imports.append(self.packageName)
-		# TODO LedgerOfImports method: list of package names. autoflake_additional_imports.extend()
-		autoflake_additional_imports.append(getDatatypePackage())
 		pythonSource = autoflake_fix_code(pythonSource, autoflake_additional_imports, expand_star_imports=False, remove_all_unused_imports=False, remove_duplicate_keys = False, remove_unused_variables = False,)
-		self.pathFilename.write_text(pythonSource)
-
-@dataclasses.dataclass
-class RecipeSynthesizeCountingFunction:
-	"""Settings for synthesizing counting functions."""
-	ingredients: IngredientsFunction
+		writeStringToHere(pythonSource, self.pathFilename)
 
 numbaFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()
 
 # https://github.com/hunterhogan/mapFolding/issues/3
-sequentialFunctionDef = extractFunctionDef(numbaFlow.sequentialCallableAsStr, numbaFlow.source_astModule)
-if sequentialFunctionDef is None: raise FREAKOUT
+sourceSequentialFunctionDef = extractFunctionDef(numbaFlow.sourceSequentialCallable, numbaFlow.source_astModule)
+if sourceSequentialFunctionDef is None: raise FREAKOUT
 
-numbaCountSequential = RecipeSynthesizeCountingFunction(IngredientsFunction(
-	FunctionDef=sequentialFunctionDef,
+numbaCountSequential = RecipeCountingFunction(IngredientsFunction(
+	FunctionDef=sourceSequentialFunctionDef,
 	imports=LedgerOfImports(numbaFlow.source_astModule)
 ))
 
-# the data converter and the dispatcher could be in the same module.
-
-Z0Z_autoflake_additional_imports: list[str] = []
-Z0Z_autoflake_additional_imports.append(thePackageName)
+numbaDispatcher = RecipeModule(filenameStem=numbaFlow.moduleDispatcher, fileExtension=numbaFlow.fileExtension, pathPackage=numbaFlow.pathPackage,
+								packageName=numbaFlow.packageName, logicalPathINFIX=numbaFlow.Z0Z_flowLogicalPathRoot)
 
 class ParametersSynthesizeNumbaCallable(NamedTuple):
 	callableTarget: str
@@ -292,6 +337,7 @@ _decoratorCallable = ''
 # if numba
 _datatypeModuleScalar = 'numba'
 _decoratorCallable = 'jit'
+Z0Z_autoflake_additional_imports: list[str] = []
 Z0Z_autoflake_additional_imports.append('numba')
 
 def Z0Z_getDatatypeModuleScalar() -> str: