mapFolding 0.7.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

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/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/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/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/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/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/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/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:

mapFolding/syntheticModules/multiprocessingCount_doTheNeedful.py

@@ -0,0 +1,216 @@
+from concurrent.futures import ProcessPoolExecutor
+from mapFolding.theSSOT import ComputationState
+import concurrent.futures
+import copy
+import multiprocessing
+
+def activeLeafConnectedToItself(state: ComputationState) -> bool:
+	return state.leafConnectee == state.leaf1ndex
+
+def activeLeafGreaterThan0(state: ComputationState) -> bool:
+	return state.leaf1ndex > 0
+
+def activeLeafGreaterThanLeavesTotal(state: ComputationState) -> bool:
+	return state.leaf1ndex > state.leavesTotal
+
+def activeLeafIsTheFirstLeaf(state: ComputationState) -> bool:
+	return state.leaf1ndex <= 1
+
+def allDimensionsAreUnconstrained(state: ComputationState) -> bool:
+	return not state.dimensionsUnconstrained
+
+def backtrack(state: ComputationState) -> ComputationState:
+	state.leaf1ndex -= 1
+	state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leafBelow[state.leaf1ndex]
+	state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leafAbove[state.leaf1ndex]
+	return state
+
+def countGaps(state: ComputationState) -> ComputationState:
+	state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
+	if state.countDimensionsGapped[state.leafConnectee] == 0:
+		state = incrementGap1ndexCeiling(state)
+	state.countDimensionsGapped[state.leafConnectee] += 1
+	return state
+
+def decrementDimensionsUnconstrained(state: ComputationState) -> ComputationState:
+	state.dimensionsUnconstrained -= 1
+	return state
+
+def dimensionsUnconstrainedCondition(state: ComputationState) -> bool:
+	return state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex] == state.leaf1ndex
+
+def filterCommonGaps(state: ComputationState) -> ComputationState:
+	state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
+	if state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] == state.dimensionsUnconstrained:
+		state = incrementActiveGap(state)
+	state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] = 0
+	return state
+
+def incrementActiveGap(state: ComputationState) -> ComputationState:
+	state.gap1ndex += 1
+	return state
+
+def incrementGap1ndexCeiling(state: ComputationState) -> ComputationState:
+	state.gap1ndexCeiling += 1
+	return state
+
+def incrementIndexDimension(state: ComputationState) -> ComputationState:
+	state.indexDimension += 1
+	return state
+
+def incrementIndexMiniGap(state: ComputationState) -> ComputationState:
+	state.indexMiniGap += 1
+	return state
+
+def initializeIndexMiniGap(state: ComputationState) -> ComputationState:
+	state.indexMiniGap = state.gap1ndex
+	return state
+
+def initializeLeafConnectee(state: ComputationState) -> ComputationState:
+	state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
+	return state
+
+def initializeVariablesToFindGaps(state: ComputationState) -> ComputationState:
+	state.dimensionsUnconstrained = state.dimensionsTotal
+	state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
+	state.indexDimension = 0
+	return state
+
+def insertUnconstrainedLeaf(state: ComputationState) -> ComputationState:
+	indexLeaf = 0
+	while indexLeaf < state.leaf1ndex:
+		state.gapsWhere[state.gap1ndexCeiling] = indexLeaf
+		state.gap1ndexCeiling += 1
+		indexLeaf += 1
+	return state
+
+def leafBelowSentinelIs1(state: ComputationState) -> bool:
+	return state.leafBelow[0] == 1
+
+def loopingLeavesConnectedToActiveLeaf(state: ComputationState) -> bool:
+	return state.leafConnectee != state.leaf1ndex
+
+def loopingToActiveGapCeiling(state: ComputationState) -> bool:
+	return state.indexMiniGap < state.gap1ndexCeiling
+
+def loopUpToDimensionsTotal(state: ComputationState) -> bool:
+	return state.indexDimension < state.dimensionsTotal
+
+def noGapsHere(state: ComputationState) -> bool:
+	return (state.leaf1ndex > 0) and (state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1])
+
+def placeLeaf(state: ComputationState) -> ComputationState:
+	state.gap1ndex -= 1
+	state.leafAbove[state.leaf1ndex] = state.gapsWhere[state.gap1ndex]
+	state.leafBelow[state.leaf1ndex] = state.leafBelow[state.leafAbove[state.leaf1ndex]]
+	state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leaf1ndex
+	state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
+	state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
+	state.leaf1ndex += 1
+	return state
+
+def thereIsAnActiveLeaf(state: ComputationState) -> bool:
+	return state.leaf1ndex > 0
+
+def thisIsMyTaskIndex(state: ComputationState) -> bool:
+	return (state.leaf1ndex != state.taskDivisions) or (state.leafConnectee % state.taskDivisions == state.taskIndex)
+
+def updateLeafConnectee(state: ComputationState) -> ComputationState:
+	state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
+	return state
+
+def countInitialize(state: ComputationState) -> ComputationState:
+	while activeLeafGreaterThan0(state):
+		if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
+				state = initializeVariablesToFindGaps(state)
+				while loopUpToDimensionsTotal(state):
+					state = initializeLeafConnectee(state)
+					if activeLeafConnectedToItself(state):
+						state = decrementDimensionsUnconstrained(state)
+					else:
+						while loopingLeavesConnectedToActiveLeaf(state):
+							state = countGaps(state)
+							state = updateLeafConnectee(state)
+					state = incrementIndexDimension(state)
+				if allDimensionsAreUnconstrained(state):
+					state = insertUnconstrainedLeaf(state)
+				state = initializeIndexMiniGap(state)
+				while loopingToActiveGapCeiling(state):
+					state = filterCommonGaps(state)
+					state = incrementIndexMiniGap(state)
+		if thereIsAnActiveLeaf(state):
+			state = placeLeaf(state)
+		if state.gap1ndex > 0:
+			break
+	return state
+
+def countParallel(state: ComputationState) -> ComputationState:
+	while activeLeafGreaterThan0(state):
+		if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
+			if activeLeafGreaterThanLeavesTotal(state):
+				state.groupsOfFolds += 1
+			else:
+				state = initializeVariablesToFindGaps(state)
+				while loopUpToDimensionsTotal(state):
+					if dimensionsUnconstrainedCondition(state):
+						state = decrementDimensionsUnconstrained(state)
+					else:
+						state = initializeLeafConnectee(state)
+						while loopingLeavesConnectedToActiveLeaf(state):
+							if thisIsMyTaskIndex(state):
+								state = countGaps(state)
+							state = updateLeafConnectee(state)
+					state = incrementIndexDimension(state)
+				state = initializeIndexMiniGap(state)
+				while loopingToActiveGapCeiling(state):
+					state = filterCommonGaps(state)
+					state = incrementIndexMiniGap(state)
+		while noGapsHere(state):
+			state = backtrack(state)
+		if thereIsAnActiveLeaf(state):
+			state = placeLeaf(state)
+	state.foldGroups[state.taskIndex] = state.groupsOfFolds
+	return state
+
+def countSequential(state: ComputationState) -> ComputationState:
+	while activeLeafGreaterThan0(state):
+		if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
+			if activeLeafGreaterThanLeavesTotal(state):
+				state.groupsOfFolds += 1
+			else:
+				state = initializeVariablesToFindGaps(state)
+				while loopUpToDimensionsTotal(state):
+					state = initializeLeafConnectee(state)
+					if activeLeafConnectedToItself(state):
+						state = decrementDimensionsUnconstrained(state)
+					else:
+						while loopingLeavesConnectedToActiveLeaf(state):
+							state = countGaps(state)
+							state = updateLeafConnectee(state)
+					state = incrementIndexDimension(state)
+				state = initializeIndexMiniGap(state)
+				while loopingToActiveGapCeiling(state):
+					state = filterCommonGaps(state)
+					state = incrementIndexMiniGap(state)
+		while noGapsHere(state):
+			state = backtrack(state)
+		if thereIsAnActiveLeaf(state):
+			state = placeLeaf(state)
+	state.foldGroups[state.taskIndex] = state.groupsOfFolds
+	return state
+
+def doTheNeedful(state: ComputationState) -> ComputationState:
+	state = countInitialize(state)
+	if state.taskDivisions > 0:
+		multiprocessing.set_start_method('spawn')
+		dictionaryConcurrency: dict[int, concurrent.futures.Future[ComputationState]] = {}
+		with ProcessPoolExecutor() as concurrencyManager:
+			for indexSherpa in range(state.taskDivisions):
+				stateParallel = copy.deepcopy(state)
+				stateParallel.taskIndex = indexSherpa
+				dictionaryConcurrency[indexSherpa] = concurrencyManager.submit(countParallel, stateParallel)
+			for indexSherpa in range(state.taskDivisions):
+				state.foldGroups[indexSherpa] = dictionaryConcurrency[indexSherpa].result().foldGroups[indexSherpa]
+		return state
+	else:
+		return countSequential(state)

mapFolding/syntheticModules/numbaCountSequential.py

@@ -1,4 +1,4 @@
-from mapFolding.theDao import countInitialize, countParallel
+from mapFolding.theDao import countInitialize, doTheNeedful
 from mapFolding.theSSOT import Array1DElephino, Array1DLeavesTotal, Array3D, ComputationState, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
 from numba import jit
 
@@ -65,9 +65,10 @@ def countSequential(
 
 def flattenData(state: ComputationState) -> ComputationState:
 
-	state = countInitialize(state)
 	if state.taskDivisions > 0:
-		return countParallel(state)
+		return doTheNeedful(state)
+
+	state = countInitialize(state)
 
 	connectionGraph: Array3D = state.connectionGraph
 	countDimensionsGapped: Array1DLeavesTotal = state.countDimensionsGapped

mapFolding/theDao.py

@@ -1,5 +1,12 @@
+from concurrent.futures import ProcessPoolExecutor
 from mapFolding.theSSOT import ComputationState
+import concurrent.futures
 import copy
+import multiprocessing
+
+# When to use multiprocessing.set_start_method https://github.com/hunterhogan/mapFolding/issues/6
+if __name__ == '__main__':
+	multiprocessing.set_start_method('spawn')
 
 def activeLeafConnectedToItself(state: ComputationState) -> bool:
 	return state.leafConnectee == state.leaf1ndex
@@ -141,37 +148,33 @@ def countInitialize(state: ComputationState) -> ComputationState:
 			break
 	return state
 
-def countParallel(statePARALLEL: ComputationState) -> ComputationState:
-	stateCOMPLETE = copy.deepcopy(statePARALLEL)
-	for indexSherpa in range(statePARALLEL.taskDivisions):
-		state = copy.deepcopy(statePARALLEL)
-		state.taskIndex = indexSherpa
-		while activeLeafGreaterThan0(state):
-			if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
-				if activeLeafGreaterThanLeavesTotal(state):
-					state.groupsOfFolds += 1
-				else:
-					state = initializeVariablesToFindGaps(state)
-					while loopUpToDimensionsTotal(state):
-						if dimensionsUnconstrainedCondition(state):
-							state = decrementDimensionsUnconstrained(state)
-						else:
-							state = initializeLeafConnectee(state)
-							while loopingLeavesConnectedToActiveLeaf(state):
-								if thisIsMyTaskIndex(state):
-									state = countGaps(state)
-								state = updateLeafConnectee(state)
-						state = incrementIndexDimension(state)
-					state = initializeIndexMiniGap(state)
-					while loopingToActiveGapCeiling(state):
-						state = filterCommonGaps(state)
-						state = incrementIndexMiniGap(state)
-			while noGapsHere(state):
-				state = backtrack(state)
-			if thereIsAnActiveLeaf(state):
-				state = placeLeaf(state)
-		stateCOMPLETE.foldGroups[state.taskIndex] = state.groupsOfFolds
-	return stateCOMPLETE
+def countParallel(state: ComputationState) -> ComputationState:
+	while activeLeafGreaterThan0(state):
+		if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
+			if activeLeafGreaterThanLeavesTotal(state):
+				state.groupsOfFolds += 1
+			else:
+				state = initializeVariablesToFindGaps(state)
+				while loopUpToDimensionsTotal(state):
+					if dimensionsUnconstrainedCondition(state):
+						state = decrementDimensionsUnconstrained(state)
+					else:
+						state = initializeLeafConnectee(state)
+						while loopingLeavesConnectedToActiveLeaf(state):
+							if thisIsMyTaskIndex(state):
+								state = countGaps(state)
+							state = updateLeafConnectee(state)
+					state = incrementIndexDimension(state)
+				state = initializeIndexMiniGap(state)
+				while loopingToActiveGapCeiling(state):
+					state = filterCommonGaps(state)
+					state = incrementIndexMiniGap(state)
+		while noGapsHere(state):
+			state = backtrack(state)
+		if thereIsAnActiveLeaf(state):
+			state = placeLeaf(state)
+	state.foldGroups[state.taskIndex] = state.groupsOfFolds
+	return state
 
 def countSequential(state: ComputationState) -> ComputationState:
 	while activeLeafGreaterThan0(state):
@@ -203,6 +206,14 @@ def countSequential(state: ComputationState) -> ComputationState:
 def doTheNeedful(state: ComputationState) -> ComputationState:
 	state = countInitialize(state)
 	if state.taskDivisions > 0:
-		return countParallel(state)
+		dictionaryConcurrency: dict[int, concurrent.futures.Future[ComputationState]] = {}
+		with ProcessPoolExecutor(state.concurrencyLimit) as concurrencyManager:
+			for indexSherpa in range(state.taskDivisions):
+				stateParallel = copy.deepcopy(state)
+				stateParallel.taskIndex = indexSherpa
+				dictionaryConcurrency[indexSherpa] = concurrencyManager.submit(countParallel, stateParallel)
+			for indexSherpa in range(state.taskDivisions):
+				state.foldGroups[indexSherpa] = dictionaryConcurrency[indexSherpa].result().foldGroups[indexSherpa]
+		return state
 	else:
 		return countSequential(state)

mapFolding/theSSOT.py

@@ -1,3 +1,4 @@
+from collections.abc import Callable
 from importlib import import_module as importlib_import_module
 from inspect import getfile as inspect_getfile
 from numpy import dtype, int64 as numpy_int64, int16 as numpy_int16, ndarray, signedinteger
@@ -20,7 +21,9 @@ Identifiers: scope and resolution, LEGB (Local, Enclosing, Global, Builtin)
 
 # I _think_, in theSSOT, I have abstracted the flow settings to only these couple of lines:
 packageFlowSynthetic = 'numba'
+# packageFlowSynthetic = 'multiprocessing'
 Z0Z_packageFlow = 'algorithm'
+# https://github.com/hunterhogan/mapFolding/issues/4
 # Z0Z_packageFlow = packageFlowSynthetic
 
 # =============================================================================
@@ -29,23 +32,23 @@ Z0Z_packageFlow = 'algorithm'
 
 sourceAlgorithmPACKAGING: str = 'theDao'
 datatypePackagePACKAGING: Final[str] = 'numpy'
-dispatcherCallableAsStrPACKAGING: str = 'doTheNeedful'
+dispatcherCallablePACKAGING: str = 'doTheNeedful'
 moduleOfSyntheticModulesPACKAGING: Final[str] = 'syntheticModules'
 
-dataclassModuleAsStrPACKAGING: str = 'theSSOT'
-dataclassIdentifierAsStrPACKAGING: str = 'ComputationState'
-dataclassInstanceAsStrPACKAGING: str = 'state'
-dataclassInstance_Pre_ParallelAsStrPACKAGING = dataclassInstanceAsStrPACKAGING + 'PARALLEL'
-dataclassInstance_Post_ParallelAsStrPACKAGING = dataclassInstanceAsStrPACKAGING + 'COMPLETE'
+dataclassModulePACKAGING: str = 'theSSOT'
+dataclassIdentifierPACKAGING: str = 'ComputationState'
+dataclassInstancePACKAGING: str = 'state'
+dataclassInstance_Pre_ParallelPACKAGING = dataclassInstancePACKAGING + 'PARALLEL'
+dataclassInstance_Post_ParallelPACKAGING = dataclassInstancePACKAGING + 'COMPLETE'
 
-Z0Z_initializeCallableAsStrPACKAGING = 'countInitialize'
-Z0Z_sequentialCallableAsStrPACKAGING = 'countSequential'
-Z0Z_parallelCallableAsStrPACKAGING = 'countParallel'
+sourceInitializeCallablePACKAGING = 'countInitialize'
+sourceSequentialCallablePACKAGING = 'countSequential'
+sourceParallelCallablePACKAGING = 'countParallel'
 
 try:
-	thePackageNameIsPACKAGING: str = tomli_load(Path("../pyproject.toml").open('rb'))["project"]["name"]
+	thePackageNamePACKAGING: str = tomli_load(Path("../pyproject.toml").open('rb'))["project"]["name"]
 except Exception:
-	thePackageNameIsPACKAGING: str = "mapFolding"
+	thePackageNamePACKAGING: str = "mapFolding"
 
 # =============================================================================
 # The Wrong Way The Wrong Way The Wrong Way The Wrong Way The Wrong Way
@@ -54,7 +57,7 @@ except Exception:
 fileExtensionINSTALLING: str = '.py'
 
 def getPathPackageINSTALLING() -> Path:
-	pathPackage: Path = Path(inspect_getfile(importlib_import_module(thePackageNameIsPACKAGING)))
+	pathPackage: Path = Path(inspect_getfile(importlib_import_module(thePackageNamePACKAGING)))
 	if pathPackage.is_file():
 		pathPackage = pathPackage.parent
 	return pathPackage
@@ -68,7 +71,7 @@ def getPathPackageINSTALLING() -> Path:
 
 # =====================
 # Create enduring identifiers from the hopefully transient identifiers above.
-thePackageName: Final[str] = thePackageNameIsPACKAGING
+thePackageName: Final[str] = thePackageNamePACKAGING
 thePathPackage: Path = getPathPackageINSTALLING()
 
 """
@@ -81,24 +84,23 @@ NOTE on semiotics: `theIdentifier` vs `identifier`
 """
 
 theSourceAlgorithm: str = sourceAlgorithmPACKAGING
+theSourceInitializeCallable = sourceInitializeCallablePACKAGING
+theSourceSequentialCallable = sourceSequentialCallablePACKAGING
+theSourceParallelCallable = sourceParallelCallablePACKAGING
 theDatatypePackage: Final[str] = datatypePackagePACKAGING
 
-theDispatcherCallableAsStr: str = dispatcherCallableAsStrPACKAGING
+theDispatcherCallable: str = dispatcherCallablePACKAGING
 
-theDataclassModuleAsStr: str = dataclassModuleAsStrPACKAGING
-theDataclassIdentifierAsStr: str = dataclassIdentifierAsStrPACKAGING
-theDataclassInstanceAsStr: str = dataclassInstanceAsStrPACKAGING
-theDataclassInstance_Pre_ParallelAsStr: str = dataclassInstance_Pre_ParallelAsStrPACKAGING
-theDataclassInstance_Post_ParallelAsStr: str = dataclassInstance_Post_ParallelAsStrPACKAGING
+theDataclassModule: str = dataclassModulePACKAGING
+theDataclassIdentifier: str = dataclassIdentifierPACKAGING
+theDataclassInstance: str = dataclassInstancePACKAGING
+theDataclassInstance_Pre_Parallel: str = dataclassInstance_Pre_ParallelPACKAGING
+theDataclassInstance_Post_Parallel: str = dataclassInstance_Post_ParallelPACKAGING
 
 theFileExtension: str = fileExtensionINSTALLING
 
 theModuleOfSyntheticModules: Final[str] = moduleOfSyntheticModulesPACKAGING
 
-Z0Z_initializeCallableAsStr = Z0Z_initializeCallableAsStrPACKAGING
-Z0Z_sequentialCallableAsStr = Z0Z_sequentialCallableAsStrPACKAGING
-Z0Z_parallelCallableAsStr = Z0Z_parallelCallableAsStrPACKAGING
-
 # =============================================================================
 # The right way.
 concurrencyPackage: str = Z0Z_packageFlow
@@ -137,6 +139,7 @@ class ComputationState:
 	mapShape: tuple[DatatypeLeavesTotal, ...]
 	leavesTotal: DatatypeLeavesTotal
 	taskDivisions: DatatypeLeavesTotal
+	concurrencyLimit: DatatypeElephino
 
 	connectionGraph: Array3D = dataclasses.field(init=False, metadata={'description': 'A 3D array representing the connection graph of the map.'})
 	dimensionsTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
@@ -199,16 +202,16 @@ class ComputationState:
 
 theLogicalPathModuleSourceAlgorithm: str = '.'.join([thePackageName, theSourceAlgorithm])
 theLogicalPathModuleDispatcher: str = theLogicalPathModuleSourceAlgorithm
-theLogicalPathModuleDataclass: str = '.'.join([thePackageName, theDataclassModuleAsStr])
+theLogicalPathModuleDataclass: str = '.'.join([thePackageName, theDataclassModule])
 
 def getSourceAlgorithm() -> ModuleType:
 	moduleImported: ModuleType = importlib_import_module(theLogicalPathModuleSourceAlgorithm)
 	return moduleImported
 
+# dynamically set the return type https://github.com/hunterhogan/mapFolding/issues/5
 def getAlgorithmDispatcher():
 	moduleImported: ModuleType = getSourceAlgorithm()
-	# TODO I think I need to use `inspect` to type the return value
-	dispatcherCallable = getattr(moduleImported, theDispatcherCallableAsStr)
+	dispatcherCallable = getattr(moduleImported, theDispatcherCallable)
 	return dispatcherCallable
 
 def getPathSyntheticModules() -> Path:
@@ -241,21 +244,33 @@ class FREAKOUT(Exception): pass
 # Temporary or transient or something; probably still the wrong way
 
 # THIS IS A STUPID SYSTEM BUT I CAN'T FIGURE OUT AN IMPROVEMENT
+# NOTE This section for _default_ values probably has value
+# https://github.com/hunterhogan/mapFolding/issues/4
 theFormatStrModuleSynthetic = "{packageFlow}Count"
 theFormatStrModuleForCallableSynthetic = theFormatStrModuleSynthetic + "_{callableTarget}"
 
-theModuleDispatcherSynthetic: str = theFormatStrModuleForCallableSynthetic.format(packageFlow=packageFlowSynthetic, callableTarget=theDispatcherCallableAsStr)
+theModuleDispatcherSynthetic: str = theFormatStrModuleForCallableSynthetic.format(packageFlow=packageFlowSynthetic, callableTarget=theDispatcherCallable)
 theLogicalPathModuleDispatcherSynthetic: str = '.'.join([thePackageName, theModuleOfSyntheticModules, theModuleDispatcherSynthetic])
 
 # =============================================================================
 # The most right way I know how to implement.
 
+# https://github.com/hunterhogan/mapFolding/issues/4
 if Z0Z_packageFlow == packageFlowSynthetic: # pyright: ignore [reportUnnecessaryComparison]
+	# NOTE this as a default value _might_ have value
 	theLogicalPathModuleDispatcher = theLogicalPathModuleDispatcherSynthetic
 
-def getPackageDispatcher():
-	moduleImported: ModuleType = importlib_import_module(theLogicalPathModuleDispatcher)
-	dispatcherCallable = getattr(moduleImported, theDispatcherCallableAsStr)
+# https://github.com/hunterhogan/mapFolding/issues/4
+# dynamically set the return type https://github.com/hunterhogan/mapFolding/issues/5
+def getPackageDispatcher() -> Callable[[ComputationState], ComputationState]:
+	# NOTE but this part, if the package flow is synthetic, probably needs to be delegated
+	# to the authority for creating _that_ synthetic flow.
+
+	# Automated system
+	# moduleImported: ModuleType = importlib_import_module(theLogicalPathModuleDispatcher)
+	# dispatcherCallable = getattr(moduleImported, theDispatcherCallable)
+
+	# Hardcoded while I am refactoring "someAssemblyRequired"
 	from mapFolding.syntheticModules.numbaCountSequential import flattenData
 	dispatcherCallable = flattenData
 	return dispatcherCallable

{mapfolding-0.7.0.dist-info → mapfolding-0.7.1.dist-info}/METADATA

@@ -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.dist-info → mapfolding-0.7.1.dist-info}/RECORD

@@ -1,12 +1,12 @@
-mapFolding/__init__.py,sha256=dg1pzBxbhIY8FRtS2uphqL7YwUwR5uxZ5epduKhl3Y8,189
-mapFolding/basecamp.py,sha256=H-cZeoDhKftRwZu1Q_Xo66lCweVEtB0ChqJY_GNEfdI,3835
-mapFolding/beDRY.py,sha256=WsXAPbjFfjO0bVFq8GGbEdEP9lmrYTaZxzIWpO9s3ok,8209
-mapFolding/filesystem.py,sha256=TfvvIXnlLU6NNZrrY9T9Wk9cIGksvDjeI-JgsKHdsLY,3767
+mapFolding/__init__.py,sha256=hONqdWnBN1ebgrKZuMIZfI8m-1krSR66L4GTVRwBmw4,203
+mapFolding/basecamp.py,sha256=Ik_oH-MpH8f6k-yBzwm99lfkv3pMDgFFEnSSDyiJjsQ,3861
+mapFolding/beDRY.py,sha256=Icgj8s6Rgd_oIBdvzwr6dovywdvG3sIVELO-n74W-So,9011
+mapFolding/filesystem.py,sha256=KqgsO-jaSWAlYib_9ovoXQY76PcQri09_73u0OqMWC8,4094
 mapFolding/noHomeYet.py,sha256=HjxLP-7BGVkKL66T50q4BWnC0Cg2gHUeCKMFuwR2mEQ,785
 mapFolding/oeis.py,sha256=xqnL_VyhwRBET-Kdpnf59K5W5metGbW0JiufTlVw7g0,11853
 mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mapFolding/theDao.py,sha256=Bcd-VmZfarxdsdyFh40XdURrMPjV2QIO0WoMJ6AS6hw,8054
-mapFolding/theSSOT.py,sha256=1-trVx4JHT2twT5gmKY5cCdZ2gLSKjScMBzE9QiyIXo,12594
+mapFolding/theDao.py,sha256=eQvR6lDMW_dI6qhZmkTqv-Eog79ekfQjap9rg8cavE8,8629
+mapFolding/theSSOT.py,sha256=fWEkYyCoioi_jJzu2Qwi11GBIyXBbjcFfKAf3tlL9Aw,13270
 mapFolding/reference/flattened.py,sha256=S6D9wiFTlbeoetEqaMLOcA-R22BHOzjqPRujffNxxUM,14875
 mapFolding/reference/hunterNumba.py,sha256=jDS0ORHkIhcJ1rzA5hT49sZHKf3rgJOoGesUCcbKFFY,6054
 mapFolding/reference/irvineJavaPort.py,sha256=7GvBU0tnS6wpFgkYad3465do9jBQW-2bYvbCYyABPHM,3341
@@ -16,35 +16,36 @@ mapFolding/reference/lunnanNumpy.py,sha256=rwVP3WIDXimpAuaxhRIuBYU56nVDTKlfGiclw
 mapFolding/reference/lunnanWhile.py,sha256=uRrMT23jTJvoQDlD_FzeIQe_pfMXJG6_bRvs7uhC8z0,3271
 mapFolding/reference/rotatedEntryPoint.py,sha256=USZY3n3zwhSE68ATscUuN66t1qShuEbMI790Gz9JFTw,9352
 mapFolding/reference/total_countPlus1vsPlusN.py,sha256=wpgay-uqPOBd64Z4Pg6tg40j7-4pzWHGMM6v0bnmjhE,6288
-mapFolding/someAssemblyRequired/Z0Z_workbench.py,sha256=wkTqYlzi-okXloPCg4IHpThq97vuyCzrLSn1wsF6-_0,1627
+mapFolding/someAssemblyRequired/Z0Z_workbench.py,sha256=XibNQRbX5gGfrkWVfRsW66kHlqphcqVCPz7TyJFcs90,1505
 mapFolding/someAssemblyRequired/__init__.py,sha256=pYkG-1LM8emzTeQbGtOfiZsAiklm5DU92-WE63qB-9s,602
 mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=sGDzg5HG21Q42M0upRD1NWzOUsd7mZ_9wUKJIQHI13o,1000
 mapFolding/someAssemblyRequired/ingredientsNumba.py,sha256=HnWgo1KwIoevUrE5A1WZh4AVFXKQllt8L6RL46JTXEg,2787
 mapFolding/someAssemblyRequired/synthesizeCountingFunctions.py,sha256=77iNPPsN8BmwHaYKdXcDKCwoZKS1g41CJNenQB0W-eg,252
-mapFolding/someAssemblyRequired/synthesizeDataConverters.py,sha256=qNedUaXxU107x3OBx1AHcSEQPM3bMe5ym-GfpJ9O0bc,6237
+mapFolding/someAssemblyRequired/synthesizeDataConverters.py,sha256=czo6Y0ABlwye01ShumObAFtkTn7PBx4Qsh9Jna5BMUw,6187
 mapFolding/someAssemblyRequired/synthesizeNumba.py,sha256=cKXvp0BxmYayUBMQ2RJLkVoJUSvzPI1S4Wy_APRM5cI,4788
 mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=w7zLUzLrLXf2N6O75jKvXDoyTJemWB8GOdK4ryqSWbs,22700
 mapFolding/someAssemblyRequired/synthesizeNumbaModules.py,sha256=zUclYPmAr6X5qFO3nQK1_HHqdiRq6j3EIBXjeax_b8c,4388
-mapFolding/someAssemblyRequired/transformationTools.py,sha256=FwaZlwMnfzoGvtax5GQSjkyBWr5atMo2VFxPHaBwuNA,21019
-mapFolding/someAssemblyRequired/whatWillBe.py,sha256=ue_NsFN3Z6IxlTgVOaikG8GCiXz9Dk1dvNlypOWMcG0,12188
+mapFolding/someAssemblyRequired/transformationTools.py,sha256=QAheMJgYWI09PBetyhnJqNhJk_hl6Zlu1TBbDjBwFSs,21001
+mapFolding/someAssemblyRequired/whatWillBe.py,sha256=G_r1VD106gTZISyiwhuJosREfRzQd73JLAMpYg8F6O8,14641
 mapFolding/syntheticModules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mapFolding/syntheticModules/dataNamespaceFlattened.py,sha256=vsU4PDEMoEcZ424AzsXOJoXoVlX_bSk-pXSTlDsSN9k,2939
+mapFolding/syntheticModules/multiprocessingCount_doTheNeedful.py,sha256=JwZzvF79mvuo2E0Lfs0NeY1QR6JP8FRuwUaRmENwDs8,8482
 mapFolding/syntheticModules/numbaCount.py,sha256=znFV9RhZ0WqPA-r-DT92WDgZXUyhdQlrsKmnsGySuKc,4561
 mapFolding/syntheticModules/numbaCountExample.py,sha256=Oo0Xeex89sLD15iRt3N76OKRFScKl9qwO84-d5sv6lM,11871
-mapFolding/syntheticModules/numbaCountSequential.py,sha256=iJ-IyzXv0c41uugceJGIHutdzJpkhqbTj0ic_3DqHEM,4326
+mapFolding/syntheticModules/numbaCountSequential.py,sha256=CtSA3UX2JzoN_uSo0SH7E3coKuHBWaTloQZwbExIPBw,4325
 mapFolding/syntheticModules/numbaCount_doTheNeedful.py,sha256=J9wZ9PW5EVduOQWVze7CgpTHkUjRIvBPG8fNuT3IVpA,1145
 mapFolding/syntheticModules/numba_doTheNeedful.py,sha256=8kgV2GGjy_nxVi9o_aAtrZzRSxsYr8HVNsVXesf4Kec,767
 mapFolding/syntheticModules/numba_doTheNeedfulExample.py,sha256=J9wZ9PW5EVduOQWVze7CgpTHkUjRIvBPG8fNuT3IVpA,1145
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/conftest.py,sha256=oPc1IS4RXhLQIBskhuawi4GEWhy6kXbM6D2MdX9kDhw,10833
-tests/test_computations.py,sha256=s4ce78iEa9axlknR83NqwXwluX8Z5HN1GtTJ3RyXuzQ,3240
+tests/test_computations.py,sha256=YhadlskBh_r5RiefHRy0FlrYQ0FelYbqcSNNSkSJMIY,3368
 tests/test_filesystem.py,sha256=7Ova6f4R6lI9rwnnu8SkZgficTYlKEhSzLp-nBRWESM,3183
 tests/test_oeis.py,sha256=uxvwmgbnylSDdsVJfuAT0LuYLbIVFwSgdLxHm-xUGBM,5043
 tests/test_other.py,sha256=CS64h5NACYmXhG3owBpPDcXv3BpYlXNeLqPcqT4quwg,4303
-tests/test_tasks.py,sha256=nsrNuGYk49EnTUslZIQTgqEONwuCSlQaPCpoQTkE08k,2849
-mapfolding-0.7.0.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-mapfolding-0.7.0.dist-info/METADATA,sha256=xR40gKDQ001BELktPxoyqtsdz7b6zFVmqdU8zV2qoRg,7696
-mapfolding-0.7.0.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-mapfolding-0.7.0.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapfolding-0.7.0.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapfolding-0.7.0.dist-info/RECORD,,
+tests/test_tasks.py,sha256=K5WdCtsM8ghFHX_BMmATsNUTvCICoTHtU-K73QBA4gY,3048
+mapfolding-0.7.1.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+mapfolding-0.7.1.dist-info/METADATA,sha256=czJ_D8mDCOZg1ug6kaIvrwMTKJKh2zfk7Q3FWLJcs6U,7696
+mapfolding-0.7.1.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+mapfolding-0.7.1.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapfolding-0.7.1.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapfolding-0.7.1.dist-info/RECORD,,

tests/test_computations.py

@@ -3,16 +3,20 @@ from mapFolding.filesystem import getPathFilenameFoldsTotal
 from mapFolding.noHomeYet import getFoldsTotalKnown
 from mapFolding.oeis import settingsOEIS, oeisIDfor_n
 # from mapFolding.someAssemblyRequired import writeJobNumba
+from pathlib import Path
 from tests.conftest import standardizedEqualToCallableReturn, registrarRecordsTmpObject
+from types import ModuleType
 import importlib.util
+import multiprocessing
 import pytest
-from pathlib import Path
-from types import ModuleType
 
-def test_algorithmSourceParallel(listDimensionsTestParallelization, useAlgorithmSourceDispatcher: None) -> None:
-    standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestParallelization)), countFolds, listDimensionsTestParallelization, None, 'maximum')
+if __name__ == '__main__':
+	multiprocessing.set_start_method('spawn')
+
+def test_algorithmSourceParallel(listDimensionsTestParallelization: list[int], useAlgorithmSourceDispatcher: None) -> None:
+    standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestParallelization)), countFolds, listDimensionsTestParallelization, None, 'maximum', None)
 
-def test_algorithmSourceSequential(listDimensionsTestCountFolds, useAlgorithmSourceDispatcher: None) -> None:
+def test_algorithmSourceSequential(listDimensionsTestCountFolds: tuple[int, ...], useAlgorithmSourceDispatcher: None) -> None:
     standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestCountFolds)), countFolds, listDimensionsTestCountFolds)
 
 def test_aOFn_calculate_value(oeisID: str) -> None:

tests/test_tasks.py

@@ -1,12 +1,18 @@
-from typing import Literal
+from collections.abc import Callable
 from mapFolding.basecamp import countFolds
 from mapFolding.beDRY import getTaskDivisions, setCPUlimit, validateListDimensions, getLeavesTotal
 from mapFolding.noHomeYet import getFoldsTotalKnown
 from tests.conftest import standardizedEqualToCallableReturn
+from typing import Literal
 from Z0Z_tools.pytestForYourUse import PytestFor_defineConcurrencyLimit
-from collections.abc import Callable
+import multiprocessing
 import pytest
 
+# When to use multiprocessing.set_start_method https://github.com/hunterhogan/mapFolding/issues/6
+if __name__ == '__main__':
+	multiprocessing.set_start_method('spawn')
+
+
 # TODO add a test. `C` = number of logical cores available. `n = C + 1`. Ensure that `[2,n]` is computed correctly.
 # Or, probably smarter: limit the number of cores, then run a test with C+1.
 
@@ -14,7 +20,7 @@ def test_countFoldsComputationDivisionsInvalid(mapShapeTestFunctionality: tuple[
 	standardizedEqualToCallableReturn(ValueError, countFolds, mapShapeTestFunctionality, None, {"wrong": "value"})
 
 def test_countFoldsComputationDivisionsMaximum(listDimensionsTestParallelization: list[int]) -> None:
-	standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestParallelization)), countFolds, listDimensionsTestParallelization, None, 'maximum')
+	standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestParallelization)), countFolds, listDimensionsTestParallelization, None, 'maximum', None)
 
 @pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_defineConcurrencyLimit())
 def test_defineConcurrencyLimit(nameOfTest: str, callablePytest: Callable[[], None]) -> None: