mapFolding 0.9.2__tar.gz → 0.9.3__tar.gz

{mapfolding-0.9.2 → mapfolding-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.9.2
+Version: 0.9.3
 Summary: Map folding algorithm with code transformation framework for optimizing numerical computations
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -8,7 +8,7 @@ Project-URL: Donate, https://www.patreon.com/integrated
 Project-URL: Homepage, https://github.com/hunterhogan/mapFolding
 Project-URL: Repository, https://github.com/hunterhogan/mapFolding.git
 Project-URL: Issues, https://github.com/hunterhogan/mapFolding/issues
-Keywords: A001415,A001416,A001417,A001418,A195646,algorithmic optimization,AST manipulation,code generation,code transformation,combinatorics,computational geometry,dataclass transformation,folding pattern enumeration,just-in-time compilation,map folding,Numba optimization,OEIS,performance optimization,source code analysis,stamp folding
+Keywords: A000136,A001415,A001416,A001417,A001418,A195646,algorithmic optimization,AST manipulation,code generation,code transformation,combinatorics,computational geometry,dataclass transformation,folding pattern enumeration,just-in-time compilation,map folding,Numba optimization,OEIS,performance optimization,source code analysis,stamp folding
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -106,7 +106,7 @@ def countFolds_optimized(shape_param):
 
 ### 2. Code Generation Framework
 
-Study and extend a complete Python code transformation pipeline:
+Study and extend a complete Python code transformation assembly line:
 
 - AST analysis and manipulation
 - Dataclass decomposition ("shattering")

{mapfolding-0.9.2 → mapfolding-0.9.3}/README.md

@@ -53,7 +53,7 @@ def countFolds_optimized(shape_param):
 
 ### 2. Code Generation Framework
 
-Study and extend a complete Python code transformation pipeline:
+Study and extend a complete Python code transformation assembly line:
 
 - AST analysis and manipulation
 - Dataclass decomposition ("shattering")

mapfolding-0.9.3/mapFolding/Z0Z_flowControl.py

@@ -0,0 +1,99 @@
+from collections.abc import Sequence
+from mapFolding import (
+	ComputationState,
+	getPathFilenameFoldsTotal,
+	outfitCountFolds,
+	saveFoldsTotal,
+	saveFoldsTotalFAILearly,
+	setProcessorLimit,
+	The,
+	validateListDimensions,
+)
+from os import PathLike
+from pathlib import PurePath
+
+def countFolds(listDimensions: Sequence[int] | None = None
+				, pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None
+				, computationDivisions: int | str | None = None
+				, CPUlimit: int | float | bool | None = None
+				# , * I need to improve `standardizedEqualToCallableReturn` so it will work with keyword arguments
+				, mapShape: tuple[int, ...] | None = None
+				, oeisID: str | None = None
+				, oeis_n: int | None = None
+				, flow: str | None = None
+				) -> int:
+	"""
+	To select the execution path, I need at least:
+		- mapShape
+		- task division instructions
+		- memorialization instructions
+	"""
+
+	# mapShape =====================================================================
+
+	if mapShape:
+		pass
+	else:
+		if oeisID and oeis_n:
+			from mapFolding.oeis import settingsOEIS
+			try:
+				mapShape = settingsOEIS[oeisID]['getMapShape'](oeis_n)
+			except KeyError:
+				pass
+		if not mapShape and listDimensions:
+			mapShape = validateListDimensions(listDimensions)
+
+	if mapShape is None:
+		raise ValueError(f"""I received these values:
+	`{listDimensions = }`,
+	`{mapShape = }`,
+	`{oeisID = }` and `{oeis_n = }`,
+	but I was unable to select a map for which to count the folds.""")
+
+	# task division instructions ===============================================
+
+	if computationDivisions:
+		# NOTE `The.concurrencyPackage`
+		concurrencyLimit: int = setProcessorLimit(CPUlimit, The.concurrencyPackage)
+		from mapFolding.beDRY import getLeavesTotal, getTaskDivisions
+		leavesTotal: int = getLeavesTotal(mapShape)
+		taskDivisions = getTaskDivisions(computationDivisions, concurrencyLimit, leavesTotal)
+		del leavesTotal
+	else:
+		concurrencyLimit = 1
+		taskDivisions = 0
+
+	# memorialization instructions ===========================================
+
+	if pathLikeWriteFoldsTotal is not None:
+		pathFilenameFoldsTotal = getPathFilenameFoldsTotal(mapShape, pathLikeWriteFoldsTotal)
+		saveFoldsTotalFAILearly(pathFilenameFoldsTotal)
+	else:
+		pathFilenameFoldsTotal = None
+
+	# Flow control until I can figure out a good way ===============================
+
+	if flow == 'theDaoOfMapFolding':
+		from mapFolding.dataBaskets import MapFoldingState
+		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+		from mapFolding.theDaoOfMapFolding import doTheNeedful
+		mapFoldingState = doTheNeedful(mapFoldingState)
+		foldsTotal = mapFoldingState.foldsTotal
+
+	# NOTE treat this as a default?
+	# flow based on `The` and `ComputationState` ====================================
+
+	else:
+		computationStateInitialized: ComputationState = outfitCountFolds(mapShape, computationDivisions, concurrencyLimit)
+		computationStateComplete: ComputationState = The.dispatcher(computationStateInitialized)
+
+		computationStateComplete.getFoldsTotal()
+		foldsTotal = computationStateComplete.foldsTotal
+
+	# Follow memorialization instructions ===========================================
+
+	if pathFilenameFoldsTotal is not None:
+		saveFoldsTotal(pathFilenameFoldsTotal, foldsTotal)
+
+	return foldsTotal

{mapfolding-0.9.2 → mapfolding-0.9.3}/mapFolding/__init__.py

@@ -1,29 +1,27 @@
 """
 Map folding enumeration and counting algorithms with advanced optimization capabilities.
 
-This package implements algorithms to count and enumerate the distinct ways
-a rectangular map can be folded, based on the mathematical problem described
-in Lunnon's 1971 paper. It provides multiple layers of functionality, from
-high-level user interfaces to sophisticated algorithmic optimizations and code
-transformation tools.
+This package implements algorithms to count and enumerate the distinct ways a rectangular map can be folded, based on
+the mathematical problem described in Lunnon's 1971 paper. It provides multiple layers of functionality, from high-level
+user interfaces to sophisticated algorithmic optimizations and code transformation tools.
 
 Core modules:
 - basecamp: Public API with simplified interfaces for end users
 - theDao: Core computational algorithm using a functional state-transformation approach
-- beDRY: Core utility functions implementing consistent data handling, validation, and
-	resource management across the package's computational assembly-line
+- beDRY: Core utility functions implementing consistent data handling, validation, and resource management across the
+	package's computational assembly-line
 - theSSOT: Single Source of Truth for configuration, types, and state management
-- toolboxFilesystem: Cross-platform file management services for storing and retrieving
-	computation results with robust error handling and fallback mechanisms
+- toolboxFilesystem: Cross-platform file management services for storing and retrieving computation results with robust
+	error handling and fallback mechanisms
 - oeis: Interface to the Online Encyclopedia of Integer Sequences for known results
 
 Extended functionality:
-- someAssemblyRequired: Code transformation framework that optimizes the core algorithm
-	through AST manipulation, dataclass transformation, and compilation techniques
-	- The system converts readable code into high-performance implementations through
-	  a systematic analysis and transformation pipeline
-	- Provides tools to "shatter" complex dataclasses into primitive components,
-	  enabling compatibility with Numba and other optimization frameworks
+- someAssemblyRequired: Code transformation framework that optimizes the core algorithm through AST manipulation,
+	dataclass transformation, and compilation techniques
+	- The system converts readable code into high-performance implementations through a systematic analysis and
+		transformation assembly line
+	- Provides tools to "shatter" complex dataclasses into primitive components, enabling compatibility with Numba and
+		other optimization frameworks
 	- Creates specialized implementations tailored for specific input parameters
 
 Testing and extension:
@@ -35,24 +33,22 @@ Testing and extension:
 
 Special directories:
 - .cache/: Stores cached data from external sources like OEIS to improve performance
-- syntheticModules/: Contains dynamically generated, optimized implementations of the
-	core algorithm created by the code transformation framework
+- syntheticModules/: Contains dynamically generated, optimized implementations of the core algorithm created by the code
+transformation framework
 - reference/: Historical implementations and educational resources for algorithm exploration
-	- reference/jobsCompleted/: Contains successful computations for previously unknown values,
-		including first-ever calculations for 2x19 and 2x20 maps (OEIS A001415)
+	- reference/jobsCompleted/: Contains successful computations for previously unknown values, including first-ever
+		calculations for 2x19 and 2x20 maps (OEIS A001415)
 
-This package balances algorithm readability and understandability with
-high-performance computation capabilities, allowing users to compute map folding
-totals for larger dimensions than previously feasible while also providing
-a foundation for exploring advanced code transformation techniques.
+This package balances algorithm readability and understandability with high-performance computation capabilities,
+allowing users to compute map folding totals for larger dimensions than previously feasible while also providing a
+foundation for exploring advanced code transformation techniques.
 """
 
-from mapFolding.theSSOT import (
+from mapFolding.datatypes import (
 	Array1DElephino as Array1DElephino,
 	Array1DFoldsTotal as Array1DFoldsTotal,
 	Array1DLeavesTotal as Array1DLeavesTotal,
 	Array3D as Array3D,
-	ComputationState as ComputationState,
 	DatatypeElephino as DatatypeElephino,
 	DatatypeFoldsTotal as DatatypeFoldsTotal,
 	DatatypeLeavesTotal as DatatypeLeavesTotal,
@@ -60,6 +56,10 @@ from mapFolding.theSSOT import (
 	NumPyFoldsTotal as NumPyFoldsTotal,
 	NumPyIntegerType as NumPyIntegerType,
 	NumPyLeavesTotal as NumPyLeavesTotal,
+)
+
+from mapFolding.theSSOT import (
+	ComputationState as ComputationState,
 	raiseIfNoneGitHubIssueNumber3 as raiseIfNoneGitHubIssueNumber3,
 	The as The,
 )
@@ -70,6 +70,8 @@ from mapFolding.theDao import (
 )
 
 from mapFolding.beDRY import (
+	getLeavesTotal as getLeavesTotal,
+	getTaskDivisions as getTaskDivisions,
 	outfitCountFolds as outfitCountFolds,
 	setProcessorLimit as setProcessorLimit,
 	validateListDimensions as validateListDimensions,
@@ -83,7 +85,7 @@ from mapFolding.toolboxFilesystem import (
 	writeStringToHere as writeStringToHere,
 )
 
-from mapFolding.basecamp import countFolds as countFolds
+from mapFolding.Z0Z_flowControl import countFolds
 
 from mapFolding.oeis import (
 	clearOEIScache as clearOEIScache,

{mapfolding-0.9.2 → mapfolding-0.9.3}/mapFolding/basecamp.py

@@ -63,7 +63,7 @@ def countFolds(listDimensions: Sequence[int]
 
 	Note well
 	---------
-	You probably don't want to divide the computation into tasks.
+	You probably do not want to divide your computation into tasks.
 
 	If you want to compute a large `foldsTotal`, dividing the computation into tasks is usually a bad idea. Dividing the
 	algorithm into tasks is inherently inefficient: efficient division into tasks means there would be no overlap in the

{mapfolding-0.9.2 → mapfolding-0.9.3}/mapFolding/beDRY.py

@@ -29,8 +29,7 @@ def getLeavesTotal(mapShape: tuple[int, ...]) -> int:
 	"""
 	Calculate the total number of leaves in a map with the given dimensions.
 
-	The total number of leaves is the product of all dimensions in the map shape. This value is foundational for
-	initializing the computation state and determining task divisions.
+	The total number of leaves is the product of all dimensions in the map shape.
 
 	Parameters
 	----------

mapfolding-0.9.3/mapFolding/dataBaskets.py

@@ -0,0 +1,49 @@
+from mapFolding.beDRY import getConnectionGraph, getLeavesTotal, makeDataContainer
+from mapFolding.datatypes import Array3D, Array1DElephino, Array1DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
+import dataclasses
+
+@dataclasses.dataclass
+class MapFoldingState:
+	mapShape: tuple[DatatypeLeavesTotal, ...] = dataclasses.field(init=True, metadata={'elementConstructor': 'DatatypeLeavesTotal'})
+
+	groupsOfFolds: DatatypeFoldsTotal = dataclasses.field(default=DatatypeFoldsTotal(0), metadata={'theCountingIdentifier': True})
+
+	gap1ndex: DatatypeElephino = DatatypeElephino(0)
+	gap1ndexCeiling: DatatypeElephino = DatatypeElephino(0)
+	indexDimension: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+	indexLeaf: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+	indexMiniGap: DatatypeElephino = DatatypeElephino(0)
+	leaf1ndex: DatatypeLeavesTotal = DatatypeLeavesTotal(1)
+	leafConnectee: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+
+	dimensionsUnconstrained: DatatypeLeavesTotal = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+
+	countDimensionsGapped: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	gapRangeStart: Array1DElephino = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DElephino.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	gapsWhere: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	leafAbove: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	leafBelow: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+
+	connectionGraph: Array3D = dataclasses.field(init=False, metadata={'dtype': Array3D.__args__[1].__args__[0]}) # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
+	dimensionsTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
+	leavesTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
+
+	@property
+	def foldsTotal(self) -> DatatypeFoldsTotal:
+		_foldsTotal = DatatypeFoldsTotal(self.leavesTotal) * self.groupsOfFolds
+		return _foldsTotal
+
+	def __post_init__(self) -> None:
+		self.dimensionsTotal = DatatypeLeavesTotal(len(self.mapShape))
+		self.leavesTotal = DatatypeLeavesTotal(getLeavesTotal(self.mapShape))
+
+		leavesTotalAsInt = int(self.leavesTotal)
+
+		self.connectionGraph = getConnectionGraph(self.mapShape, leavesTotalAsInt, self.__dataclass_fields__['connectionGraph'].metadata['dtype'])
+
+		if self.dimensionsUnconstrained is None: self.dimensionsUnconstrained = DatatypeLeavesTotal(int(self.dimensionsTotal)) # pyright: ignore[reportUnnecessaryComparison]
+		if self.gapsWhere is None: self.gapsWhere = makeDataContainer(leavesTotalAsInt * leavesTotalAsInt + 1, self.__dataclass_fields__['gapsWhere'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
+		if self.countDimensionsGapped is None: self.countDimensionsGapped = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['countDimensionsGapped'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
+		if self.gapRangeStart is None: self.gapRangeStart = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['gapRangeStart'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
+		if self.leafAbove is None: self.leafAbove = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafAbove'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
+		if self.leafBelow is None: self.leafBelow = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafBelow'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]

mapfolding-0.9.3/mapFolding/datatypes.py

@@ -0,0 +1,21 @@
+from numpy import dtype, int64 as numpy_int64, integer, ndarray
+from typing import Any, TypeAlias, TypeVar
+
+# =============================================================================
+# Flexible Data Structure System Needs Enhanced Paradigm https://github.com/hunterhogan/mapFolding/issues/9
+
+NumPyIntegerType = TypeVar('NumPyIntegerType', bound=integer[Any], covariant=True)
+
+DatatypeLeavesTotal: TypeAlias = int
+NumPyLeavesTotal: TypeAlias = numpy_int64
+
+DatatypeElephino: TypeAlias = int
+NumPyElephino: TypeAlias = numpy_int64
+
+DatatypeFoldsTotal: TypeAlias = int
+NumPyFoldsTotal: TypeAlias = numpy_int64
+
+Array3D: TypeAlias = ndarray[tuple[int, int, int], dtype[NumPyLeavesTotal]]
+Array1DLeavesTotal: TypeAlias = ndarray[tuple[int], dtype[NumPyLeavesTotal]]
+Array1DElephino: TypeAlias = ndarray[tuple[int], dtype[NumPyElephino]]
+Array1DFoldsTotal: TypeAlias = ndarray[tuple[int], dtype[NumPyFoldsTotal]]

{mapfolding-0.9.2 → mapfolding-0.9.3}/mapFolding/oeis.py

@@ -20,7 +20,7 @@ mathematical definition in OEIS and the computational implementation in the pack
 from collections.abc import Callable
 from datetime import datetime, timedelta
 from functools import cache
-from mapFolding import writeStringToHere, The
+from mapFolding import countFolds, The, writeStringToHere
 from pathlib import Path
 from typing import Any, Final, TYPE_CHECKING
 import argparse
@@ -401,7 +401,6 @@ def oeisIDfor_n(oeisID: str, n: int | Any) -> int:
 			raise ArithmeticError(f"OEIS sequence {oeisID} is not defined at {n = }.")
 		foldsTotal: int = settingsOEIS[oeisID]['valuesKnown'][n]
 		return foldsTotal
-	from mapFolding.basecamp import countFolds
 	return countFolds(mapShape)
 
 def OEIS_for_n() -> None:

{mapfolding-0.9.2 → mapfolding-0.9.3}/mapFolding/someAssemblyRequired/__init__.py

@@ -22,7 +22,7 @@ functional implementations into highly-optimized variants with verified correctn
    - Recipe configuration for generating optimized code (RecipeSynthesizeFlow)
    - Dataclass decomposition for compatibility (ShatteredDataclass)
 
-3. **Optimization Pipelines**
+3. **Optimization assembly lines**
    - General-purpose Numba acceleration (makeNumbaFlow)
    - Job-specific optimization for concrete parameters (makeJobNumba)
    - Specialized component transformation (decorateCallableWithNumba)

{mapfolding-0.9.2 → mapfolding-0.9.3}/mapFolding/someAssemblyRequired/_theTypes.py

@@ -15,7 +15,7 @@ else:
 
 class ImaCallToName(ast.Call):
 	func: ast.Name # pyright: ignore[reportIncompatibleVariableOverride]
-	# assert isinstance(ast.Call.func, ast.Name), "brinksmanship"
+	# assert isinstance(ast.Call.func, ast.Name), "brinkmanship"
 	# func: ast.Name
 
 astClassHasDOTtargetAttributeNameSubscript: typing_TypeAlias = ast.AnnAssign | ast.AugAssign

{mapfolding-0.9.2 → mapfolding-0.9.3}/mapFolding/someAssemblyRequired/_toolboxContainers.py

@@ -1,23 +1,21 @@
 """
 AST Container Classes for Python Code Generation and Transformation
 
-This module provides specialized container classes that organize AST nodes, imports,
-and program structure for code generation and transformation. These classes form
-the organizational backbone of the code generation system, enabling:
-
-1. Tracking and managing imports with LedgerOfImports
-2. Packaging function definitions with their dependencies via IngredientsFunction
-3. Structuring complete modules with IngredientsModule
-4. Configuring code synthesis with RecipeSynthesizeFlow
-5. Organizing decomposed dataclass representations with ShatteredDataclass
-
-Together, these container classes implement a component-based architecture for
-programmatic generation of high-performance code. They maintain a clean separation
-between structure and content, allowing transformations to be applied systematically
-while preserving relationships between code elements.
-
-The containers work in conjunction with transformation tools that manipulate the
-contained AST nodes to implement specific optimizations and transformations.
+This module provides specialized container classes that organize AST nodes, imports, and program structure for code
+generation and transformation. These classes form the organizational backbone of the code generation system, enabling:
+
+1. Tracking and managing imports with LedgerOfImports.
+2. Packaging function definitions with their dependencies via IngredientsFunction.
+3. Structuring complete modules with IngredientsModule.
+4. Configuring code synthesis with RecipeSynthesizeFlow.
+5. Organizing decomposed dataclass representations with ShatteredDataclass.
+
+Together, these container classes implement a component-based architecture for programmatic generation of
+high-performance code. They maintain a clean separation between structure and content, allowing transformations to be
+applied systematically while preserving relationships between code elements.
+
+The containers work in conjunction with transformation tools that manipulate the contained AST nodes to implement
+specific optimizations and transformations.
 """
 
 from collections import defaultdict
@@ -33,30 +31,31 @@ class LedgerOfImports:
 	"""
 	Track and manage import statements for programmatically generated code.
 
-	LedgerOfImports acts as a registry for import statements, maintaining a clean
-	separation between the logical structure of imports and their textual representation.
+	LedgerOfImports acts as a registry for import statements, maintaining a clean separation between the logical
+	structure of imports and their textual representation.
 	It enables:
 
-	1. Tracking regular imports and import-from statements
-	2. Adding imports programmatically during code transformation
-	3. Merging imports from multiple sources
-	4. Removing unnecessary or conflicting imports
-	5. Generating optimized AST import nodes for the final code
+	1. Tracking regular imports and import-from statements.
+	2. Adding imports programmatically during code transformation.
+	3. Merging imports from multiple sources.
+	4. Removing unnecessary or conflicting imports.
+	5. Generating optimized AST import nodes for the final code.
 
-	This class forms the foundation of dependency management in generated code,
-	ensuring that all required libraries are available without duplication or
-	conflict.
+	This class forms the foundation of dependency management in generated code, ensuring that all required libraries are
+	available without duplication or conflict.
 	"""
 	# TODO When resolving the ledger of imports, remove self-referential imports
-	# TODO add TypeIgnore tracking to the ledger of imports
 
-	def __init__(self, startWith: ast.AST | None = None) -> None:
+	type_ignores: list[ast.TypeIgnore]
+
+	def __init__(self, startWith: ast.AST | None = None, type_ignores: list[ast.TypeIgnore] | None = None) -> None:
 		self.dictionaryImportFrom: dict[str_nameDOTname, list[tuple[ast_Identifier, ast_Identifier | None]]] = defaultdict(list)
 		self.listImport: list[str_nameDOTname] = []
+		self.type_ignores = [] if type_ignores is None else list(type_ignores)
 		if startWith:
 			self.walkThis(startWith)
 
-	def addAst(self, astImport____: ast.Import | ast.ImportFrom) -> None:
+	def addAst(self, astImport____: ast.Import | ast.ImportFrom, type_ignores: list[ast.TypeIgnore] | None = None) -> None:
 		match astImport____:
 			case ast.Import():
 				for alias in astImport____.names:
@@ -69,14 +68,20 @@ class LedgerOfImports:
 					self.dictionaryImportFrom[astImport____.module].append((alias.name, alias.asname))
 			case _:
 				raise ValueError(f"I received {type(astImport____) = }, but I can only accept {ast.Import} and {ast.ImportFrom}.")
+		if type_ignores:
+			self.type_ignores.extend(type_ignores)
 
-	def addImport_asStr(self, moduleWithLogicalPath: str_nameDOTname) -> None:
+	def addImport_asStr(self, moduleWithLogicalPath: str_nameDOTname, type_ignores: list[ast.TypeIgnore] | None = None) -> None:
 		self.listImport.append(moduleWithLogicalPath)
+		if type_ignores:
+			self.type_ignores.extend(type_ignores)
 
-	def addImportFrom_asStr(self, moduleWithLogicalPath: str_nameDOTname, name: ast_Identifier, asname: ast_Identifier | None = None) -> None:
+	def addImportFrom_asStr(self, moduleWithLogicalPath: str_nameDOTname, name: ast_Identifier, asname: ast_Identifier | None = None, type_ignores: list[ast.TypeIgnore] | None = None) -> None:
 		if moduleWithLogicalPath not in self.dictionaryImportFrom:
 			self.dictionaryImportFrom[moduleWithLogicalPath] = []
 		self.dictionaryImportFrom[moduleWithLogicalPath].append((name, asname))
+		if type_ignores:
+			self.type_ignores.extend(type_ignores)
 
 	def removeImportFromModule(self, moduleWithLogicalPath: str_nameDOTname) -> None:
 		"""Remove all imports from a specific module."""
@@ -129,11 +134,14 @@ class LedgerOfImports:
 		self.dictionaryImportFrom = updateExtendPolishDictionaryLists(self.dictionaryImportFrom, *(ledger.dictionaryImportFrom for ledger in fromLedger), destroyDuplicates=True, reorderLists=True)
 		for ledger in fromLedger:
 			self.listImport.extend(ledger.listImport)
+			self.type_ignores.extend(ledger.type_ignores)
 
-	def walkThis(self, walkThis: ast.AST) -> None:
+	def walkThis(self, walkThis: ast.AST, type_ignores: list[ast.TypeIgnore] | None = None) -> None:
 		for nodeBuffalo in ast.walk(walkThis):
 			if isinstance(nodeBuffalo, (ast.Import, ast.ImportFrom)):
 				self.addAst(nodeBuffalo)
+		if type_ignores:
+			self.type_ignores.extend(type_ignores)
 
 # Consolidate settings classes through inheritance https://github.com/hunterhogan/mapFolding/issues/15
 @dataclasses.dataclass
@@ -141,17 +149,16 @@ class IngredientsFunction:
 	"""
 	Package a function definition with its import dependencies for code generation.
 
-	IngredientsFunction encapsulates an AST function definition along with all the
-	imports required for that function to operate correctly. This creates a modular,
-	portable unit that can be:
+	IngredientsFunction encapsulates an AST function definition along with all the imports required for that function to
+	operate correctly. This creates a modular, portable unit that can be:
 
-	1. Transformed independently (e.g., by applying Numba decorators)
-	2. Transplanted between modules while maintaining dependencies
-	3. Combined with other functions to form complete modules
-	4. Analyzed for optimization opportunities
+	1. Transformed independently (e.g., by applying Numba decorators).
+	2. Transplanted between modules while maintaining dependencies.
+	3. Combined with other functions to form complete modules.
+	4. Analyzed for optimization opportunities.
 
-	This class forms the primary unit of function manipulation in the code generation
-	system, enabling targeted transformations while preserving function dependencies.
+	This class forms the primary unit of function manipulation in the code generation system, enabling targeted
+	transformations while preserving function dependencies.
 
 	Parameters:
 		astFunctionDef: The AST representation of the function definition
@@ -266,15 +273,18 @@ class IngredientsModule:
 		for ingredientsFunction in self.listIngredientsFunctions:
 			ingredientsFunction.imports.removeImportFrom(moduleWithLogicalPath, name, asname)
 
-	@property
-	def list_astImportImportFrom(self) -> list[ast.Import | ast.ImportFrom]:
-		"""List of `ast.Import` and `ast.ImportFrom` statements."""
+	def _consolidatedLedger(self) -> LedgerOfImports:
+		"""Consolidate all ledgers of imports."""
 		sherpaLedger = LedgerOfImports()
 		listLedgers: list[LedgerOfImports] = [self.imports]
 		for ingredientsFunction in self.listIngredientsFunctions:
 			listLedgers.append(ingredientsFunction.imports)
 		sherpaLedger.update(*listLedgers)
-		return sherpaLedger.makeList_ast()
+		return sherpaLedger
+
+	@property
+	def list_astImportImportFrom(self) -> list[ast.Import | ast.ImportFrom]:
+		return self._consolidatedLedger().makeList_ast()
 
 	@property
 	def body(self) -> list[ast.stmt]:
@@ -291,7 +301,7 @@ class IngredientsModule:
 	@property
 	def type_ignores(self) -> list[ast.TypeIgnore]:
 		listTypeIgnore: list[ast.TypeIgnore] = self.supplemental_type_ignores
-		# listTypeIgnore.extend(self.imports.makeListAst())
+		listTypeIgnore.extend(self._consolidatedLedger().type_ignores)
 		listTypeIgnore.extend(self.prologue.type_ignores)
 		for ingredientsFunction in self.listIngredientsFunctions:
 			listTypeIgnore.extend(ingredientsFunction.type_ignores)
@@ -316,7 +326,7 @@ class RecipeSynthesizeFlow:
 
 	This configuration class serves as a single source of truth for the code generation
 	process, ensuring consistency across all generated artifacts while enabling
-	customization of the transformation pipeline.
+	customization of the transformation assembly line.
 
 	The transformation process uses this configuration to extract functions from the
 	source module, transform them according to optimization rules, and output

{mapfolding-0.9.2 → mapfolding-0.9.3}/mapFolding/someAssemblyRequired/synthesizeNumbaJob.py

@@ -6,7 +6,7 @@ for specific map folding calculation jobs. Unlike the general-purpose transforma
 in toolboxNumba.py, this module creates standalone Python modules optimized for a
 single map shape with statically-encoded parameters.
 
-The code generation pipeline focuses on:
+The code generation assembly line focuses on:
 
 1. Converting function parameters to initialized variables with concrete values.
 2. Replacing dynamic computations with statically-known values.
@@ -175,7 +175,7 @@ def makeJobNumba(job: RecipeJob, spices: SpicesJobNumba) -> None:
 	"""
 	Generate a highly-optimized, single-purpose Numba module for a specific map shape.
 
-	This function implements the complete transformation pipeline for creating a
+	This function implements the complete transformation assembly line for creating a
 	standalone, specialized implementation for calculating map folding solutions for
 	a specific shape. The process includes:
 
@@ -245,9 +245,9 @@ if __name__ == '__main__':
 		Z0Z_asname: ast_Identifier | None = None
 
 	listDatatypeConfigs = [
-		DatatypeConfig(fml='DatatypeLeavesTotal', Z0Z_module='numba', Z0Z_type_name='uint16'),
+		DatatypeConfig(fml='DatatypeLeavesTotal', Z0Z_module='numba', Z0Z_type_name='uint8'),
 		DatatypeConfig(fml='DatatypeElephino', Z0Z_module='numba', Z0Z_type_name='uint16'),
-		DatatypeConfig(fml='DatatypeFoldsTotal', Z0Z_module='numba', Z0Z_type_name='int64'),
+		DatatypeConfig(fml='DatatypeFoldsTotal', Z0Z_module='numba', Z0Z_type_name='uint64'),
 	]
 
 	for datatypeConfig in listDatatypeConfigs:
@@ -261,9 +261,9 @@ if __name__ == '__main__':
 	ingredientsCount.imports.removeImportFromModule('mapFolding.theSSOT')
 
 	listNumPyTypeConfigs = [
-		DatatypeConfig(fml='Array1DLeavesTotal', Z0Z_module='numpy', Z0Z_type_name='uint16', Z0Z_asname='Array1DLeavesTotal'),
+		DatatypeConfig(fml='Array1DLeavesTotal', Z0Z_module='numpy', Z0Z_type_name='uint8', Z0Z_asname='Array1DLeavesTotal'),
 		DatatypeConfig(fml='Array1DElephino', Z0Z_module='numpy', Z0Z_type_name='uint16', Z0Z_asname='Array1DElephino'),
-		DatatypeConfig(fml='Array3D', Z0Z_module='numpy', Z0Z_type_name='uint16', Z0Z_asname='Array3D'),
+		DatatypeConfig(fml='Array3D', Z0Z_module='numpy', Z0Z_type_name='uint8', Z0Z_asname='Array3D'),
 	]
 
 	for typeConfig in listNumPyTypeConfigs:
@@ -299,7 +299,7 @@ if __name__ == '__main__':
 	"""
 
 if __name__ == '__main__':
-	mapShape = (2,2,2,2,2,2,2,2)
+	mapShape = (2,21)
 	state = makeInitializedComputationState(mapShape)
 	# foldsTotalEstimated = getFoldsTotalKnown(state.mapShape) // state.leavesTotal
 	foldsTotalEstimated = dictionaryEstimates[state.mapShape] // state.leavesTotal

{mapfolding-0.9.2 → mapfolding-0.9.3}/mapFolding/someAssemblyRequired/toolboxNumba.py

@@ -158,7 +158,7 @@ def makeNumbaFlow(numbaFlow: RecipeSynthesizeFlow) -> None:
 	"""
 	Transform standard Python algorithm code into optimized Numba implementations.
 
-	This function implements the complete transformation pipeline that converts
+	This function implements the complete transformation assembly line that converts
 	a conventional Python implementation into a high-performance Numba-accelerated
 	version. The process includes:
 

{mapfolding-0.9.2 → mapfolding-0.9.3}/mapFolding/someAssemblyRequired/transformationTools.py

@@ -424,7 +424,7 @@ def write_astModule(ingredients: IngredientsModule, pathFilename: PathLike[Any]
 	4. Optimizes imports using autoflake
 	5. Writes the final source code to the specified file location
 
-	This is typically the final step in the code generation pipeline,
+	This is typically the final step in the code generation assembly line,
 	producing optimized Python modules ready for execution.
 
 	Parameters:

mapfolding-0.9.3/mapFolding/theDaoOfMapFolding.py

@@ -0,0 +1,142 @@
+from mapFolding.dataBaskets import MapFoldingState
+
+def activeLeafGreaterThan0(state: MapFoldingState) -> bool:
+	return state.leaf1ndex > 0
+
+def activeLeafGreaterThanLeavesTotal(state: MapFoldingState) -> bool:
+	return state.leaf1ndex > state.leavesTotal
+
+def activeLeafIsTheFirstLeaf(state: MapFoldingState) -> bool:
+	return state.leaf1ndex <= 1
+
+def activeLeafIsUnconstrainedInAllDimensions(state: MapFoldingState) -> bool:
+	return not state.dimensionsUnconstrained
+
+def activeLeafUnconstrainedInThisDimension(state: MapFoldingState) -> MapFoldingState:
+	state.dimensionsUnconstrained -= 1
+	return state
+
+def filterCommonGaps(state: MapFoldingState) -> MapFoldingState:
+	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 gapAvailable(state: MapFoldingState) -> bool:
+	return state.leaf1ndex > 0
+
+def incrementActiveGap(state: MapFoldingState) -> MapFoldingState:
+	state.gap1ndex += 1
+	return state
+
+def incrementGap1ndexCeiling(state: MapFoldingState) -> MapFoldingState:
+	state.gap1ndexCeiling += 1
+	return state
+
+def incrementIndexMiniGap(state: MapFoldingState) -> MapFoldingState:
+	state.indexMiniGap += 1
+	return state
+
+def initializeIndexMiniGap(state: MapFoldingState) -> MapFoldingState:
+	state.indexMiniGap = state.gap1ndex
+	return state
+
+def initializeVariablesToFindGaps(state: MapFoldingState) -> MapFoldingState:
+	state.dimensionsUnconstrained = state.dimensionsTotal
+	state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
+	state.indexDimension = 0
+	return state
+
+def insertActiveLeaf(state: MapFoldingState) -> MapFoldingState:
+	state.indexLeaf = 0
+	while state.indexLeaf < state.leaf1ndex:
+		state.gapsWhere[state.gap1ndexCeiling] = state.indexLeaf
+		state.gap1ndexCeiling += 1
+		state.indexLeaf += 1
+	return state
+
+def insertActiveLeafAtGap(state: MapFoldingState) -> MapFoldingState:
+	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 leafBelowSentinelIs1(state: MapFoldingState) -> bool:
+	return state.leafBelow[0] == 1
+
+def leafConnecteeIsActiveLeaf(state: MapFoldingState) -> bool:
+	return state.leafConnectee == state.leaf1ndex
+
+def lookForGaps(state: MapFoldingState) -> MapFoldingState:
+	state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
+	if state.countDimensionsGapped[state.leafConnectee] == 0:
+		state = incrementGap1ndexCeiling(state)
+	state.countDimensionsGapped[state.leafConnectee] += 1
+	return state
+
+def lookupLeafConnecteeInConnectionGraph(state: MapFoldingState) -> MapFoldingState:
+	state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
+	return state
+
+def loopingLeavesConnectedToActiveLeaf(state: MapFoldingState) -> bool:
+	return state.leafConnectee != state.leaf1ndex
+
+def loopingThroughTheDimensions(state: MapFoldingState) -> bool:
+	return state.indexDimension < state.dimensionsTotal
+
+def loopingToActiveGapCeiling(state: MapFoldingState) -> bool:
+	return state.indexMiniGap < state.gap1ndexCeiling
+
+def noGapsHere(state: MapFoldingState) -> bool:
+	return (state.leaf1ndex > 0) and (state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1])
+
+def tryAnotherLeafConnectee(state: MapFoldingState) -> MapFoldingState:
+	state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
+	return state
+
+def tryNextDimension(state: MapFoldingState) -> MapFoldingState:
+	state.indexDimension += 1
+	return state
+
+def undoLastLeafPlacement(state: MapFoldingState) -> MapFoldingState:
+	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 count(state: MapFoldingState) -> MapFoldingState:
+	while activeLeafGreaterThan0(state):
+		if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
+			if activeLeafGreaterThanLeavesTotal(state):
+				state.groupsOfFolds += 1
+			else:
+				state = initializeVariablesToFindGaps(state)
+				while loopingThroughTheDimensions(state):
+					state = lookupLeafConnecteeInConnectionGraph(state)
+					if leafConnecteeIsActiveLeaf(state):
+						state = activeLeafUnconstrainedInThisDimension(state)
+					else:
+						while loopingLeavesConnectedToActiveLeaf(state):
+							state = lookForGaps(state)
+							state = tryAnotherLeafConnectee(state)
+					state = tryNextDimension(state)
+				if activeLeafIsUnconstrainedInAllDimensions(state):
+					state = insertActiveLeaf(state)
+				state = initializeIndexMiniGap(state)
+				while loopingToActiveGapCeiling(state):
+					state = filterCommonGaps(state)
+					state = incrementIndexMiniGap(state)
+		while noGapsHere(state):
+			state = undoLastLeafPlacement(state)
+		if gapAvailable(state):
+			state = insertActiveLeafAtGap(state)
+	return state
+
+def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
+	state = count(state)
+	return state

{mapfolding-0.9.2 → mapfolding-0.9.3}/mapFolding/theSSOT.py

@@ -19,12 +19,23 @@ collisions when transforming algorithms.
 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, integer, ndarray
 from pathlib import Path
 from tomli import load as tomli_load
 from types import ModuleType
-from typing import Any, TypeAlias, TypeVar
 import dataclasses
+from mapFolding.datatypes import (
+	Array1DElephino as Array1DElephino,
+	Array1DFoldsTotal as Array1DFoldsTotal,
+	Array1DLeavesTotal as Array1DLeavesTotal,
+	Array3D as Array3D,
+	DatatypeElephino as DatatypeElephino,
+	DatatypeFoldsTotal as DatatypeFoldsTotal,
+	DatatypeLeavesTotal as DatatypeLeavesTotal,
+	NumPyElephino as NumPyElephino,
+	NumPyFoldsTotal as NumPyFoldsTotal,
+	NumPyIntegerType as NumPyIntegerType,
+	NumPyLeavesTotal as NumPyLeavesTotal,
+)
 
 # Evaluate When Packaging https://github.com/hunterhogan/mapFolding/issues/18
 try:
@@ -144,25 +155,6 @@ class PackageSettings:
 
 The = PackageSettings(logicalPathModuleDispatcher=logicalPathModuleDispatcherHARDCODED, callableDispatcher=callableDispatcherHARDCODED, concurrencyPackage=concurrencyPackageHARDCODED)
 
-# =============================================================================
-# Flexible Data Structure System Needs Enhanced Paradigm https://github.com/hunterhogan/mapFolding/issues/9
-
-NumPyIntegerType = TypeVar('NumPyIntegerType', bound=integer[Any], covariant=True)
-
-DatatypeLeavesTotal: TypeAlias = int
-NumPyLeavesTotal: TypeAlias = numpy_int64
-
-DatatypeElephino: TypeAlias = int
-NumPyElephino: TypeAlias = numpy_int64
-
-DatatypeFoldsTotal: TypeAlias = int
-NumPyFoldsTotal: TypeAlias = numpy_int64
-
-Array3D: TypeAlias = ndarray[tuple[int, int, int], dtype[NumPyLeavesTotal]]
-Array1DLeavesTotal: TypeAlias = ndarray[tuple[int], dtype[NumPyLeavesTotal]]
-Array1DElephino: TypeAlias = ndarray[tuple[int], dtype[NumPyElephino]]
-Array1DFoldsTotal: TypeAlias = ndarray[tuple[int], dtype[NumPyFoldsTotal]]
-
 @dataclasses.dataclass
 class ComputationState:
 	"""

{mapfolding-0.9.2 → mapfolding-0.9.3}/mapFolding.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.9.2
+Version: 0.9.3
 Summary: Map folding algorithm with code transformation framework for optimizing numerical computations
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -8,7 +8,7 @@ Project-URL: Donate, https://www.patreon.com/integrated
 Project-URL: Homepage, https://github.com/hunterhogan/mapFolding
 Project-URL: Repository, https://github.com/hunterhogan/mapFolding.git
 Project-URL: Issues, https://github.com/hunterhogan/mapFolding/issues
-Keywords: A001415,A001416,A001417,A001418,A195646,algorithmic optimization,AST manipulation,code generation,code transformation,combinatorics,computational geometry,dataclass transformation,folding pattern enumeration,just-in-time compilation,map folding,Numba optimization,OEIS,performance optimization,source code analysis,stamp folding
+Keywords: A000136,A001415,A001416,A001417,A001418,A195646,algorithmic optimization,AST manipulation,code generation,code transformation,combinatorics,computational geometry,dataclass transformation,folding pattern enumeration,just-in-time compilation,map folding,Numba optimization,OEIS,performance optimization,source code analysis,stamp folding
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -106,7 +106,7 @@ def countFolds_optimized(shape_param):
 
 ### 2. Code Generation Framework
 
-Study and extend a complete Python code transformation pipeline:
+Study and extend a complete Python code transformation assembly line:
 
 - AST analysis and manipulation
 - Dataclass decomposition ("shattering")

{mapfolding-0.9.2 → mapfolding-0.9.3}/mapFolding.egg-info/SOURCES.txt

@@ -1,12 +1,16 @@
 LICENSE
 README.md
 pyproject.toml
+mapFolding/Z0Z_flowControl.py
 mapFolding/__init__.py
 mapFolding/basecamp.py
 mapFolding/beDRY.py
+mapFolding/dataBaskets.py
+mapFolding/datatypes.py
 mapFolding/oeis.py
 mapFolding/py.typed
 mapFolding/theDao.py
+mapFolding/theDaoOfMapFolding.py
 mapFolding/theSSOT.py
 mapFolding/toolboxFilesystem.py
 mapFolding.egg-info/PKG-INFO

{mapfolding-0.9.2 → mapfolding-0.9.3}/pyproject.toml

@@ -37,6 +37,7 @@ dependencies = [
 	"Z0Z_tools",]
 description = "Map folding algorithm with code transformation framework for optimizing numerical computations"
 keywords = [
+	"A000136",
 	"A001415",
 	"A001416",
 	"A001417",
@@ -71,7 +72,7 @@ readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"
 scripts = { getOEISids = "mapFolding.oeis:getOEISids", clearOEIScache = "mapFolding.oeis:clearOEIScache", OEIS_for_n = "mapFolding.oeis:OEIS_for_n" }
 urls = { Donate = "https://www.patreon.com/integrated", Homepage = "https://github.com/hunterhogan/mapFolding", Repository = "https://github.com/hunterhogan/mapFolding.git", Issues = "https://github.com/hunterhogan/mapFolding/issues"}
-version = "0.9.2"
+version = "0.9.3"
 
 [tool.coverage]
 report = { exclude_lines = [

{mapfolding-0.9.2 → mapfolding-0.9.3}/tests/__init__.py

@@ -14,7 +14,7 @@ own recipe configurations and job implementations.
    - Ensures consistency across different implementation strategies
 
 2. **Code Generation Testing**
-   - Tests the AST transformation pipeline from source to optimized implementations
+   - Tests the AST transformation assembly line from source to optimized implementations
    - Validates that generated Numba-accelerated modules produce correct results
    - Ensures robust code generation across different parameter sets
 
@@ -29,7 +29,7 @@ This suite is designed to make it easy to test your custom recipes and jobs:
 
 ### For Custom Recipes (RecipeSynthesizeFlow):
 Copy and adapt the `syntheticDispatcherFixture` and associated tests from
-`test_computations.py` to validate your customized code transformation pipelines.
+`test_computations.py` to validate your customized code transformation assembly lines.
 
 ### For Custom Jobs (RecipeJob):
 Copy and adapt the `test_writeJobNumba` function to test specialized job modules

{mapfolding-0.9.2 → mapfolding-0.9.3}/tests/conftest.py

@@ -56,7 +56,7 @@ See the examples in `test_computations.py` for guidance on adapting these fixtur
 """
 
 from collections.abc import Callable, Generator, Sequence
-from mapFolding import ComputationState, The
+from mapFolding import The
 from mapFolding.beDRY import getLeavesTotal, validateListDimensions, makeDataContainer
 from mapFolding.oeis import oeisIDsImplemented, settingsOEIS
 from mapFolding.someAssemblyRequired import importLogicalPath2Callable, RecipeSynthesizeFlow
@@ -171,7 +171,7 @@ def oneTestCuzTestsOverwritingTests(oeisID_1random: str) -> tuple[int, ...]:
 			pass
 
 @pytest.fixture
-def listDimensionsTestCountFolds(oeisID: str) -> tuple[int, ...]:
+def mapShapeTestCountFolds(oeisID: str) -> tuple[int, ...]:
 	"""For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestValidation`
 	if `validateListDimensions` approves. Each `listDimensions` is suitable for testing counts."""
 	while True:
@@ -202,10 +202,10 @@ def mapShapeTestFunctionality(oeisID_1random: str) -> tuple[int, ...]:
 			pass
 
 @pytest.fixture
-def listDimensionsTestParallelization(oeisID: str) -> list[int]:
+def mapShapeTestParallelization(oeisID: str) -> tuple[int, ...]:
 	"""For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestParallelization`"""
 	n = random.choice(settingsOEIS[oeisID]['valuesTestParallelization'])
-	return list(settingsOEIS[oeisID]['getMapShape'](n))
+	return settingsOEIS[oeisID]['getMapShape'](n)
 
 @pytest.fixture
 def mockBenchmarkTimer() -> Generator[unittest.mock.MagicMock | unittest.mock.AsyncMock, Any, None]:
@@ -255,8 +255,8 @@ def useThisDispatcher() -> Generator[Callable[..., None], Any, None]:
 	def patchDispatcher(callableTarget: Callable[..., Any]) -> None:
 		"""Patch the dispatcher property to return the target callable."""
 		# Create a new property that returns the target callable
-		def patched_dispatcher(self: theSSOT.PackageSettings) -> Callable[['ComputationState'], 'ComputationState']:
-			def wrapper(state: 'ComputationState') -> 'ComputationState':
+		def patched_dispatcher(self: theSSOT.PackageSettings) -> Callable[..., Any]:
+			def wrapper(state: Any) -> Any:
 				return callableTarget(state)
 			return wrapper
 
@@ -268,7 +268,7 @@ def useThisDispatcher() -> Generator[Callable[..., None], Any, None]:
 	# Restore the original property
 	theSSOT.PackageSettings.dispatcher = original_dispatcher_property # type: ignore
 
-def getAlgorithmDispatcher() -> Callable[[ComputationState], ComputationState]:
+def getAlgorithmDispatcher() -> Callable[..., Any]:
 	moduleImported: ModuleType = importlib.import_module(The.logicalPathModuleSourceAlgorithm)
 	dispatcherCallable = getattr(moduleImported, The.sourceCallableDispatcher)
 	return dispatcherCallable

{mapfolding-0.9.2 → mapfolding-0.9.3}/tests/test_computations.py

@@ -85,7 +85,7 @@ All tests leverage standardized utilities like `standardizedEqualToCallableRetur
 that provide consistent, informative error messages and simplify test validation.
 """
 
-from mapFolding import countFolds, getFoldsTotalKnown, oeisIDfor_n, validateListDimensions
+from mapFolding import countFolds, getFoldsTotalKnown, oeisIDfor_n
 from mapFolding.oeis import settingsOEIS
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJob
 from mapFolding.someAssemblyRequired.transformationTools import makeInitializedComputationState
@@ -98,28 +98,30 @@ import pytest
 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_algorithmSourceParallel(mapShapeTestParallelization: tuple[int, ...], useAlgorithmSourceDispatcher: None) -> None:
+	standardizedEqualToCallableReturn(getFoldsTotalKnown(mapShapeTestParallelization), countFolds, mapShapeTestParallelization, None, 'maximum', None)
 
-def test_algorithmSourceSequential(listDimensionsTestCountFolds: tuple[int, ...], useAlgorithmSourceDispatcher: None) -> None:
-	standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestCountFolds)), countFolds, listDimensionsTestCountFolds)
+def test_theDaoOfMapFolding(mapShapeTestCountFolds: tuple[int, ...]) -> None:
+	standardizedEqualToCallableReturn(getFoldsTotalKnown(mapShapeTestCountFolds), countFolds, None, None, None, None, mapShapeTestCountFolds, None, None, 'theDaoOfMapFolding')
+
+def test_algorithmSourceSequential(mapShapeTestCountFolds: tuple[int, ...], useAlgorithmSourceDispatcher: None) -> None:
+	standardizedEqualToCallableReturn(getFoldsTotalKnown(mapShapeTestCountFolds), countFolds, mapShapeTestCountFolds)
 
 def test_aOFn_calculate_value(oeisID: str) -> None:
 	for n in settingsOEIS[oeisID]['valuesTestValidation']:
 		standardizedEqualToCallableReturn(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
 
-def test_syntheticParallel(syntheticDispatcherFixture: None, listDimensionsTestParallelization: list[int]) -> None:
-	standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestParallelization)), countFolds, listDimensionsTestParallelization, None, 'maximum')
+def test_syntheticParallel(syntheticDispatcherFixture: None, mapShapeTestParallelization: tuple[int, ...]) -> None:
+	standardizedEqualToCallableReturn(getFoldsTotalKnown(mapShapeTestParallelization), countFolds, mapShapeTestParallelization, None, 'maximum')
 
-def test_syntheticSequential(syntheticDispatcherFixture: None, listDimensionsTestCountFolds: list[int]) -> None:
-	standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestCountFolds)), countFolds, listDimensionsTestCountFolds)
+def test_syntheticSequential(syntheticDispatcherFixture: None, mapShapeTestCountFolds: tuple[int, ...]) -> None:
+	standardizedEqualToCallableReturn(getFoldsTotalKnown(mapShapeTestCountFolds), countFolds, mapShapeTestCountFolds)
 
 @pytest.mark.parametrize('pathFilenameTmpTesting', ['.py'], indirect=True)
-def test_writeJobNumba(oneTestCuzTestsOverwritingTests: list[int], pathFilenameTmpTesting: Path) -> None:
+def test_writeJobNumba(oneTestCuzTestsOverwritingTests: tuple[int, ...], pathFilenameTmpTesting: Path) -> None:
 	from mapFolding.someAssemblyRequired.toolboxNumba import SpicesJobNumba
 	from mapFolding.someAssemblyRequired.synthesizeNumbaJob import makeJobNumba
-	mapShape = validateListDimensions(oneTestCuzTestsOverwritingTests)
-	state = makeInitializedComputationState(mapShape)
+	state = makeInitializedComputationState(oneTestCuzTestsOverwritingTests)
 
 	pathFilenameModule = pathFilenameTmpTesting.absolute()
 	pathFilenameFoldsTotal = pathFilenameModule.with_suffix('.foldsTotalTesting')
@@ -142,4 +144,4 @@ def test_writeJobNumba(oneTestCuzTestsOverwritingTests: list[int], pathFilenameT
 	module.__name__ = "__main__"
 	Don_Lapre_Road_to_Self_Improvement.loader.exec_module(module)
 
-	standardizedEqualToCallableReturn(str(getFoldsTotalKnown(mapShape)), pathFilenameFoldsTotal.read_text().strip)
+	standardizedEqualToCallableReturn(str(getFoldsTotalKnown(oneTestCuzTestsOverwritingTests)), pathFilenameFoldsTotal.read_text().strip)

{mapfolding-0.9.2 → mapfolding-0.9.3}/tests/test_tasks.py

@@ -15,8 +15,8 @@ if __name__ == '__main__':
 def test_countFoldsComputationDivisionsInvalid(mapShapeTestFunctionality: tuple[int, ...]) -> None:
 	standardizedEqualToCallableReturn(ValueError, countFolds, mapShapeTestFunctionality, None, {"wrong": "value"})
 
-def test_countFoldsComputationDivisionsMaximum(listDimensionsTestParallelization: list[int]) -> None:
-	standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestParallelization)), countFolds, listDimensionsTestParallelization, None, 'maximum', None)
+def test_countFoldsComputationDivisionsMaximum(mapShapeTestParallelization: list[int]) -> None:
+	standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(mapShapeTestParallelization)), countFolds, mapShapeTestParallelization, None, 'maximum', None)
 
 @pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_defineConcurrencyLimit())
 def test_defineConcurrencyLimit(nameOfTest: str, callablePytest: Callable[[], None]) -> None: