mapFolding 0.8.1__py3-none-any.whl → 0.8.2__py3-none-any.whl

mapFolding/theSSOT.py

@@ -19,114 +19,85 @@ to avoid namespace 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, int16 as numpy_int16, ndarray, signedinteger
+from numpy import dtype, int64 as numpy_int64, int16 as numpy_int16, ndarray
 from pathlib import Path
 from sys import modules as sysModules
 from tomli import load as tomli_load
 from types import ModuleType
-from typing import Any, Final, TypeAlias
+from typing import TypeAlias
 import dataclasses
 
-"""
-2025 March 11
-Note to self: fundamental concept in Python:
-Identifiers: scope and resolution, LEGB (Local, Enclosing, Global, Builtin)
-- Local: Inside the function
-- Enclosing: Inside enclosing functions
-- Global: At the uppermost level
-- Builtin: Python's built-in names
-"""
-
-# I _think_, in theSSOT, I have abstracted the flow settings to only these couple of lines:
 # Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
+# I _think_, in theSSOT, I have abstracted the flow settings to only these couple of lines:
 packageFlowSynthetic = 'numba'
 # Z0Z_packageFlow = 'algorithm'
 Z0Z_packageFlow = packageFlowSynthetic
 Z0Z_concurrencyPackage = 'multiprocessing'
-# =============================================================================
-# The Wrong Way The Wrong Way The Wrong Way The Wrong Way The Wrong Way
-# Evaluate When Packaging Evaluate When Packaging Evaluate When Packaging
-
-sourceAlgorithmPACKAGING: str = 'theDao'
-datatypePackagePACKAGING: Final[str] = 'numpy'
-dispatcherCallablePACKAGING: str = 'doTheNeedful'
-moduleOfSyntheticModulesPACKAGING: Final[str] = 'syntheticModules'
 
-dataclassModulePACKAGING: str = 'theSSOT'
-dataclassIdentifierPACKAGING: str = 'ComputationState'
-dataclassInstancePACKAGING: str = 'state'
-dataclassInstanceTaskDistributionPACKAGING = dataclassInstancePACKAGING + 'Parallel'
-
-sourceInitializeCallablePACKAGING = 'countInitialize'
-sourceSequentialCallablePACKAGING = 'countSequential'
-sourceParallelCallablePACKAGING = 'countParallel'
+# =============================================================================
+# The Wrong Way: Evaluate When Packaging
 
 try:
-	thePackageNamePACKAGING: str = tomli_load(Path("../pyproject.toml").open('rb'))["project"]["name"]
+	packageNamePACKAGING: str = tomli_load(Path("../pyproject.toml").open('rb'))["project"]["name"]
 except Exception:
-	thePackageNamePACKAGING = "mapFolding"
-
-# =============================================================================
-# The Wrong Way The Wrong Way The Wrong Way The Wrong Way The Wrong Way
-# Evaluate When Installing Evaluate When Installing Evaluate When Installing
+	packageNamePACKAGING = "mapFolding"
 
-fileExtensionINSTALLING: str = '.py'
+# The Wrong Way: Evaluate When Installing
 
 def getPathPackageINSTALLING() -> Path:
-	pathPackage: Path = Path(inspect_getfile(importlib_import_module(thePackageNamePACKAGING)))
+	pathPackage: Path = Path(inspect_getfile(importlib_import_module(packageNamePACKAGING)))
 	if pathPackage.is_file():
 		pathPackage = pathPackage.parent
 	return pathPackage
 
-# =============================================================================
-# The right way, perhaps.
-
-# Create enduring identifiers from the hopefully transient identifiers above.
-thePackageName: Final[str] = thePackageNamePACKAGING
-thePathPackage: Path = getPathPackageINSTALLING()
-
-"""
-NOTE on semiotics: `theIdentifier` vs `identifier`
-
-- This package has a typical, "hardcoded" algorithm for counting map folds.
-- This package has logic for transforming that algorithm into other forms.
-- The transformation logic can transform other algorithms if 1) they are similar enough to the "hardcoded" algorithm and 2) I have written the transformation logic well enough to handle the differences.
-- To avoid confusion and namespace collisions, I differentiate between, for example, `theSourceAlgorithm` of the package and any other `sourceAlgorithm` being transformed by the package.
-"""
-
-theSourceAlgorithm: str = sourceAlgorithmPACKAGING
-theSourceInitializeCallable = sourceInitializeCallablePACKAGING
-theSourceSequentialCallable = sourceSequentialCallablePACKAGING
-theSourceParallelCallable = sourceParallelCallablePACKAGING
-theDatatypePackage: Final[str] = datatypePackagePACKAGING
-
-theDispatcherCallable: str = dispatcherCallablePACKAGING
-
-theDataclassModule: str = dataclassModulePACKAGING
-theDataclassIdentifier: str = dataclassIdentifierPACKAGING
-theDataclassInstance: str = dataclassInstancePACKAGING
-theDataclassInstanceTaskDistribution: str = dataclassInstanceTaskDistributionPACKAGING
-
-theFileExtension: str = fileExtensionINSTALLING
-
-theModuleOfSyntheticModules: Final[str] = moduleOfSyntheticModulesPACKAGING
+# The following is an improvement, but it is not the full solution.
+# I hope that the standardized markers, `metadata={'evaluateWhen': 'packaging'}` will help to automate
+# whatever needs to happen so that the following is well implemented.
+@dataclasses.dataclass(frozen=True)
+class PackageSettings:
+	concurrencyPackage = Z0Z_concurrencyPackage
+	dataclassIdentifier: str = dataclasses.field(default='ComputationState', metadata={'evaluateWhen': 'packaging'})
+	dataclassInstance: str = dataclasses.field(default='state', metadata={'evaluateWhen': 'packaging'})
+	dataclassInstanceTaskDistributionSuffix: str = dataclasses.field(default='Parallel', metadata={'evaluateWhen': 'packaging'})
+	dataclassModule: str = dataclasses.field(default='theSSOT', metadata={'evaluateWhen': 'packaging'})
+	datatypePackage: str = dataclasses.field(default='numpy', metadata={'evaluateWhen': 'packaging'})
+	dispatcherCallable: str = dataclasses.field(default='doTheNeedful', metadata={'evaluateWhen': 'packaging'})
+	fileExtension: str = dataclasses.field(default='.py', metadata={'evaluateWhen': 'installing'})
+	moduleOfSyntheticModules: str = dataclasses.field(default='syntheticModules', metadata={'evaluateWhen': 'packaging'})
+	packageName: str = dataclasses.field(default = packageNamePACKAGING, metadata={'evaluateWhen': 'packaging'})
+	pathPackage: Path = dataclasses.field(default_factory=getPathPackageINSTALLING, init=False, metadata={'evaluateWhen': 'installing'})
+	sourceAlgorithm: str = dataclasses.field(default='theDao', metadata={'evaluateWhen': 'packaging'})
+	sourceConcurrencyManagerIdentifier: str = dataclasses.field(default='submit', metadata={'evaluateWhen': 'packaging'})
+	sourceConcurrencyManagerNamespace: str = dataclasses.field(default='concurrencyManager', metadata={'evaluateWhen': 'packaging'})
+	sourceInitializeCallable: str = dataclasses.field(default='countInitialize', metadata={'evaluateWhen': 'packaging'})
+	sourceParallelCallable: str = dataclasses.field(default='countParallel', metadata={'evaluateWhen': 'packaging'})
+	sourceSequentialCallable: str = dataclasses.field(default='countSequential', metadata={'evaluateWhen': 'packaging'})
+
+	@property # These are not fields, and that annoys me.
+	def dataclassInstanceTaskDistribution(self) -> str:
+		""" Compute the task distribution identifier by concatenating dataclassInstance and dataclassInstanceTaskDistributionSuffix. """
+		# it follows that `metadata={'evaluateWhen': 'packaging'}`
+		return self.dataclassInstance + self.dataclassInstanceTaskDistributionSuffix
+
+	@property # These are not fields, and that annoys me.
+	def logicalPathModuleSourceAlgorithm(self) -> str:
+		""" Compute the logical path module for the source algorithm by joining packageName and sourceAlgorithm. """
+		# it follows that `metadata={'evaluateWhen': 'packaging'}`
+		return '.'.join([self.packageName, self.sourceAlgorithm])
+
+	@property # These are not fields, and that annoys me.
+	def logicalPathModuleDataclass(self) -> str:
+		""" Compute the logical path module for the dataclass by joining packageName and dataclassModule. """
+		# it follows that `metadata={'evaluateWhen': 'packaging'}`
+		return '.'.join([self.packageName, self.dataclassModule])
+
+The = PackageSettings()
 
 # =============================================================================
-
-# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
-concurrencyPackage: str = Z0Z_packageFlow
-concurrencyPackage = Z0Z_concurrencyPackage
-
-# =============================================================================
-# The relatively flexible type system needs a different paradigm, but I don't
-# know what it should be. The system needs to 1) help optimize computation, 2)
-# make it possible to change the basic type of the package (e.g., from numpy
-# to superTypePy), 3) make it possible to synthesize the optimized flow of used
-# by the package, and 4) make it possible to synthesize arbitrary modules with
-# different type systems.
+# Flexible Data Structure System Needs Enhanced Paradigm https://github.com/hunterhogan/mapFolding/issues/9
 
 DatatypeLeavesTotal: TypeAlias = int
-# this would be uint8, but mapShape (2,2,2,2, 2,2,2,2) has 256 leaves, so generic containers accommodate
+# this would be uint8, but mapShape (2,2,2,2, 2,2,2,2) has 256 leaves, so generic containers must accommodate at least 256 leaves
 numpyLeavesTotal: TypeAlias = numpy_int16
 
 DatatypeElephino: TypeAlias = int
@@ -134,18 +105,12 @@ numpyElephino: TypeAlias = numpy_int16
 
 DatatypeFoldsTotal: TypeAlias = int
 numpyFoldsTotal: TypeAlias = numpy_int64
-numpyDtypeDefault = numpyFoldsTotal
 
 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]]
 
-# =============================================================================
-# The right way.
-# (The dataclass, not the typing of the dataclass.)
-# (Also, my noobplementation of the dataclass certainly needs improvement.)
-
 @dataclasses.dataclass
 class ComputationState:
 	mapShape: tuple[DatatypeLeavesTotal, ...]
@@ -191,9 +156,9 @@ class ComputationState:
 		leavesTotalAsInt = int(self.leavesTotal)
 
 		if self.countDimensionsGapped is None:
-			self.countDimensionsGapped = makeDataContainer(leavesTotalAsInt + 1, numpyElephino)
+			self.countDimensionsGapped = makeDataContainer(leavesTotalAsInt + 1, numpyLeavesTotal)
 		if self.gapRangeStart is None:
-			self.gapRangeStart = makeDataContainer(leavesTotalAsInt + 1, numpyLeavesTotal)
+			self.gapRangeStart = makeDataContainer(leavesTotalAsInt + 1, numpyElephino)
 		if self.gapsWhere is None:
 			self.gapsWhere = makeDataContainer(leavesTotalAsInt * leavesTotalAsInt + 1, numpyLeavesTotal)
 		if self.leafAbove is None:
@@ -205,75 +170,50 @@ class ComputationState:
 		self.foldsTotal = DatatypeFoldsTotal(self.foldGroups[0:-1].sum() * self.leavesTotal)
 
 # =============================================================================
-# The most right way I know how to implement.
-
-theLogicalPathModuleSourceAlgorithm: str = '.'.join([thePackageName, theSourceAlgorithm])
-theLogicalPathModuleDispatcher: str = theLogicalPathModuleSourceAlgorithm
-theLogicalPathModuleDataclass: str = '.'.join([thePackageName, theDataclassModule])
-
-def getSourceAlgorithm() -> ModuleType:
-	moduleImported: ModuleType = importlib_import_module(theLogicalPathModuleSourceAlgorithm)
-	return moduleImported
-
-def getAlgorithmDispatcher() -> Callable[[ComputationState], ComputationState]:
-	moduleImported: ModuleType = getSourceAlgorithm()
-	dispatcherCallable = getattr(moduleImported, theDispatcherCallable)
-	return dispatcherCallable
-
-def getPathSyntheticModules() -> Path:
-	return thePathPackage / theModuleOfSyntheticModules
 
 # TODO learn how to see this from the user's perspective
 def getPathJobRootDEFAULT() -> Path:
 	if 'google.colab' in sysModules:
 		pathJobDEFAULT: Path = Path("/content/drive/MyDrive") / "jobs"
 	else:
-		pathJobDEFAULT = thePathPackage / "jobs"
+		pathJobDEFAULT = The.pathPackage / "jobs"
 	return pathJobDEFAULT
 
 _datatypePackage: str = ''
 def getDatatypePackage() -> str:
 	global _datatypePackage
 	if not _datatypePackage:
-		_datatypePackage = theDatatypePackage
+		_datatypePackage = The.datatypePackage
 	return _datatypePackage
 
-def getNumpyDtypeDefault() -> type[signedinteger[Any]]:
-	return numpyDtypeDefault
-
 # =============================================================================
 # The coping way.
 
 class raiseIfNoneGitHubIssueNumber3(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=theDispatcherCallable)
-theLogicalPathModuleDispatcherSynthetic: str = '.'.join([thePackageName, theModuleOfSyntheticModules, theModuleDispatcherSynthetic])
+theLogicalPathModuleDispatcher: str = The.logicalPathModuleSourceAlgorithm
 
-# =============================================================================
-# The most right way I know how to implement.
+theModuleDispatcherSynthetic: str = theFormatStrModuleForCallableSynthetic.format(packageFlow=packageFlowSynthetic, callableTarget=The.dispatcherCallable)
+theLogicalPathModuleDispatcherSynthetic: str = '.'.join([The.packageName, The.moduleOfSyntheticModules, theModuleDispatcherSynthetic])
 
-# 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
 
-# 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.
 
 	moduleImported: ModuleType = importlib_import_module(theLogicalPathModuleDispatcher)
-	dispatcherCallable = getattr(moduleImported, theDispatcherCallable)
+	dispatcherCallable = getattr(moduleImported, The.dispatcherCallable)
 	return dispatcherCallable
 
 """Technical concepts I am likely using and likely want to use more effectively:
@@ -288,4 +228,13 @@ theSSOT and yourSSOT
 ----
 delay realization/instantiation until a concrete value is desired
 moment of truth: when the value is needed, not when the value is defined
+
+----
+2025 March 11
+Note to self: fundamental concept in Python:
+Identifiers: scope and resolution, LEGB (Local, Enclosing, Global, Builtin)
+- Local: Inside the function
+- Enclosing: Inside enclosing functions
+- Global: At the uppermost level
+- Builtin: Python's built-in names
 """

{mapfolding-0.8.1.dist-info → mapfolding-0.8.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.8.1
+Version: 0.8.2
 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
@@ -99,51 +99,75 @@ Available OEIS sequences:
   A195646: Number of ways of folding a 3 X 3 X ... X 3 n-dimensional map.
 ```
 
-### 2. **Algorithm Zoo** 🦒
+### 2. **Algorithm Zoo: A Historical and Performance Journey** 🦒
 
-- **Lunnon's 1971 Algorithm**: A painstakingly debugged version of [the original typo-riddled code](https://github.com/hunterhogan/mapFolding/blob/mapFolding/reference/foldings.txt)
-- The /reference directory.
-- **Numba-JIT Accelerated**: Up to 1000× faster than pure Python ([benchmarks](https://github.com/hunterhogan/mapFolding/blob/mapFolding/notes/Speed%20highlights.md))
+This package offers a comprehensive collection of map folding algorithm implementations that showcase its evolution from historical origins to high-performance computation:
 
-### 3. **For Researchers and Power Users** 🔬
+- **Historical Implementations**:
+  - Carefully restored versions of Lunnon's 1971 original [algorithm](https://github.com/hunterhogan/mapFolding/blob/mapFolding/reference/foldings.txt) with corrections
+  - Atlas Autocode reconstruction in the `reference/foldings.AA` file
 
-This package provides a sophisticated code transformation framework that can turn readable algorithm implementations into highly-optimized computational engines:
+- **Direct Translations**:
+  - Python translations following the original control flow (`lunnanWhile.py`)
+  - NumPy-based vectorized implementations (`lunnanNumpy.py`)
 
-- **Algorithmic Exploration**: Study the core algorithm in `theDao.py`, which uses a functional state-transformation approach with clear, isolated functions
-- **Performance Optimization**: Generate specialized implementations with the `someAssemblyRequired` transformation pipeline:
-  - AST-based code analysis and manipulation
-  - Dataclass "shattering" to decompose complex state objects into primitive components
-  - Just-in-time compilation with Numba and various optimization profiles
-  - LLVM IR extraction for low-level algorithmic analysis
+- **Modern Implementations**:
+  - Java port adaptations (`irvineJavaPort.py`) providing cleaner procedural implementations
+  - Experimental JAX version (`jaxCount.py`) exploring GPU acceleration potential
+  - Semantically decomposed version (`flattened.py`) with clear function boundaries
 
-- **Extensible Design**: The transformation framework is abstract and generic, enabling:
-  - Creation of new optimization targets beyond the included Numba implementation
-  - Customization of compilation parameters and optimization levels
-  - Development of specialized algorithms for specific map dimensions
+- **Performance Optimized**:
+  - Numba-JIT accelerated implementations up to 1000× faster than pure Python (see [benchmarks](https://github.com/hunterhogan/mapFolding/blob/mapFolding/notes/Speed%20highlights.md))
+  - Algorithmic optimizations showcasing subtle yet powerful performance differences (`total_countPlus1vsPlusN.py`)
 
-### 4. **Customization and Extension Guide**
+The `reference` directory serves as both a historical archive and an educational resource for understanding algorithm evolution.
 
-The package architecture supports multiple levels of customization:
+### 3. **Algorithmic Transformation: From Readability to Speed** 🔬
 
-- **Basic Usage**: Work with the high-level API in `basecamp.py` for standard computations
-- **Algorithm Modification**:
+The package provides a sophisticated transformation framework that bridges the gap between human-readable algorithms and high-performance computation:
+
+- **Core Algorithm Understanding**:
+  - Study the functional state-transformation approach in `theDao.py` with clear, isolated functions
+  - Explore the semantic decomposition in `reference/flattened.py` to understand algorithm sections
+
+- **Code Transformation Pipeline**:
+  - **AST Manipulation**: Analyzes and transforms the algorithm's abstract syntax tree
+  - **Dataclass "Shattering"**: Decomposes complex state objects into primitive components
+  - **Optimization Applications**: Applies domain-specific optimizations for numerical computation
+  - **LLVM Integration**: Extracts LLVM IR for low-level algorithmic analysis
+
+- **Performance Breakthroughs**:
+  - Learn why nearly identical algorithms can have dramatically different performance (`total_countPlus1vsPlusN.py`)
+  - See how memory layout and increment strategy impact computation speed
+  - Understand the batching technique that yields order-of-magnitude improvements
+
+### 4. **Multi-Level Architecture: From Simple API to Full Customization**
+
+The package's architecture supports multiple levels of engagement:
+
+- **Basic Usage**:
+  - Work with the high-level API in `basecamp.py` for standard computations
+  - Access OEIS sequence calculations with minimal code
+
+- **Algorithm Exploration**:
+  - Compare different implementations in the `reference` directory to understand trade-offs
   - Modify the core algorithm in `theDao.py` while preserving its functional approach
   - Configure system-wide settings in `theSSOT.py` to adjust data types and performance characteristics
-  - Use utility functions in `beDRY.py` for common operations
 
 - **Advanced Transformation**:
-  - The `someAssemblyRequired` package provides tools to transform code at the AST level:
-    - `transformationTools.py` contains utilities for AST manipulation and code generation
-    - `transformDataStructures.py` handles complex data structure transformations
-    - `ingredientsNumba.py` provides Numba-specific configuration profiles
-    - `synthesizeNumbaFlow.py` orchestrates the transformation process
+  - Use the `someAssemblyRequired` package to transform algorithms at the AST level
+  - Create optimized variants with different compilation settings using:
+    - `transformationTools.py` for AST manipulation
+    - `transformDataStructures.py` for complex data structure transformations
+    - `ingredientsNumba.py` for Numba-specific optimization profiles
+    - `synthesizeNumbaFlow.py` to orchestrate the transformation process
 
 - **Custom Deployment**:
   - Generate specialized implementations for specific dimensions
-  - Create optimized modules that can be executed as standalone scripts
-  - Extract LLVM IR for further analysis or optimization
+  - Create optimized standalone modules for production use
+  - Extract LLVM IR for further analysis and optimization
 
-The package's multi-level design allows you to start with simple API calls and progressively delve deeper into optimization as your computational needs grow.
+The package's multi-level design allows you to start with simple API calls and progressively explore deeper optimization techniques as your computational needs grow.
 
 ## Map-folding Video
 

mapfolding-0.8.2.dist-info/RECORD

@@ -0,0 +1,39 @@
+mapFolding/__init__.py,sha256=hYxPUBU6A1_XCbKEseSDamooTsb1mzN_XHqaRLPvpGk,1701
+mapFolding/basecamp.py,sha256=uPwbb_fi8zqqBbVjb355qanSNUqqJ9aefcf_nrvA7qI,4510
+mapFolding/beDRY.py,sha256=UhH52BryHQNRjphf_PirtMkV45rhdemdC9PmnpACq7I,9397
+mapFolding/filesystem.py,sha256=-pYpWugd0p3TrAz7xf9YIJW-pn1X-iRCGtJgEAF9Rns,5923
+mapFolding/noHomeYet.py,sha256=UKZeWlyn0SKlF9dhYoud7E6gWXpiSEekZOOoJp88WeI,1362
+mapFolding/oeis.py,sha256=TbY8KtAGbQlT6eEsa_7HVMF7bMLN-aBFKclyTMHfqHk,12615
+mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/theDao.py,sha256=Blzm5j24x1BE2nvgXjdzHEeuc2na6kAH9b_eP6PcwlI,9836
+mapFolding/theSSOT.py,sha256=HIU9UVKP0dXlxIO791z_tl1R7r5LiEcKnA5AI7H9SmU,12414
+mapFolding/reference/__init__.py,sha256=7NYyWXyYYSdia2Q8SFJTcD0KvoUBLvvfuvTsaqcvchM,1777
+mapFolding/reference/flattened.py,sha256=QK1xG9SllqCoi68e86Hyl9d9ATUAAFNpTQI-3zmcp5I,16072
+mapFolding/reference/hunterNumba.py,sha256=espFiX92EPZ1Ub1YQVoBnNYvh2kFg1HR6Qa4djx8Ixg,7253
+mapFolding/reference/irvineJavaPort.py,sha256=UEfIX4QbPLl5jnyfYIyX5YRR3_rYvPUikK8jLehsFko,4076
+mapFolding/reference/jaxCount.py,sha256=TuDNKOnyhQfuixKmIxO9Algv7dvy7KMGhgsV3h96FGE,14853
+mapFolding/reference/lunnanNumpy.py,sha256=mMgrgbrBpe4nmo72ThEI-MGH0OwEHmfMPczSXHp2qKo,4357
+mapFolding/reference/lunnanWhile.py,sha256=ZL8GAQtPs5nJZSgoDl5USrLSS_zs03y98y1Z9E4jOmQ,3799
+mapFolding/reference/rotatedEntryPoint.py,sha256=5ughpKUT2JQhoAKgoDUdYNjgWQYPGV8v-7dWEAdDmfE,10274
+mapFolding/reference/total_countPlus1vsPlusN.py,sha256=yJZAVLVdoXqHag2_N6_6CT-Q6HXBgRro-eny93-Rlpw,9307
+mapFolding/someAssemblyRequired/__init__.py,sha256=xA5a-nZjXIwcqEOig5PEZSxde4_m3JJ5Pb0CN4aiRjw,2488
+mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=bGI8RZY-RnyR9TNF0r0OXwA6fm4TYH2cHy7WzhsnddQ,1895
+mapFolding/someAssemblyRequired/ingredientsNumba.py,sha256=g6Z7t35NpoDskzm0OLwTQhHw5CYiYktVYxI2NhCQHww,8435
+mapFolding/someAssemblyRequired/synthesizeNumbaFlow.py,sha256=0179DMPoGJGP6AHs-nIac_aSfVBgpDyuaeCBVKlPRe8,10691
+mapFolding/someAssemblyRequired/synthesizeNumbaJobVESTIGIAL.py,sha256=RBSrtr7US2P7mkY-EA-b2WIOxjs2b0WJaCln1ERxOcI,22314
+mapFolding/someAssemblyRequired/transformDataStructures.py,sha256=Uth-WLzCTJTQkU15lsrBGf1ld7nqgLK42DUYM6-Q-n8,8605
+mapFolding/someAssemblyRequired/transformationTools.py,sha256=n_lH9B7E871htRRRVJIDqGuT4WTmGiIgBb3ZjsY7ZjA,40689
+mapFolding/syntheticModules/numbaCount_doTheNeedful.py,sha256=52RuwJVH2fROvWU2dT8wYcQvLgRuvkNZPq01kujCC_U,15725
+mapfolding-0.8.2.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/conftest.py,sha256=hTpUTW7MtYGP5aeQnnoZMKgTEGCKdLJ8Fnmnv9d4NJw,11115
+tests/test_computations.py,sha256=RHHByyuC8w-qbaag4Iqo_QNYm_7A-9BslbstMOdbZbU,3329
+tests/test_filesystem.py,sha256=Kou0gj5T72oISao6umYfU6L_W5Hi7QS9_IxTv2hU0Pw,3147
+tests/test_oeis.py,sha256=uxvwmgbnylSDdsVJfuAT0LuYLbIVFwSgdLxHm-xUGBM,5043
+tests/test_other.py,sha256=4iF6JJ192BtDZUEZ0avbVRprCwfCUSOUC8GfCPrGS8M,4232
+tests/test_tasks.py,sha256=hkZygihT8bCEO2zc-2VcxReQrZJBwgLNbYx0YP4lTDg,2853
+mapfolding-0.8.2.dist-info/METADATA,sha256=8tSQtHxSLzIjIINZCw4EExiSeQV_wpLQXvf4gQ4xFNo,9143
+mapfolding-0.8.2.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+mapfolding-0.8.2.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapfolding-0.8.2.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapfolding-0.8.2.dist-info/RECORD,,

{mapfolding-0.8.1.dist-info → mapfolding-0.8.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (77.0.1)
+Generator: setuptools (77.0.3)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tests/conftest.py

@@ -1,8 +1,14 @@
+from importlib import import_module as importlib_import_module
 from collections.abc import Callable, Generator, Sequence
-from mapFolding.theSSOT import getAlgorithmDispatcher, getSourceAlgorithm, getPackageDispatcher, theModuleOfSyntheticModules, raiseIfNoneGitHubIssueNumber3
+from types import ModuleType
+
+import numpy
+from mapFolding.theSSOT import ComputationState, The, getPackageDispatcher
 from mapFolding.beDRY import getLeavesTotal, validateListDimensions, makeDataContainer
 from mapFolding.oeis import oeisIDsImplemented, settingsOEIS
-from pathlib import Path
+from mapFolding.someAssemblyRequired import RecipeSynthesizeFlow
+from mapFolding.someAssemblyRequired.synthesizeNumbaFlow import makeNumbaFlow
+from pathlib import Path, PurePosixPath
 from typing import Any, ContextManager
 import importlib.util
 import pytest
@@ -13,7 +19,6 @@ import uuid
 
 # SSOT for test data paths and filenames
 pathDataSamples = Path("tests/dataSamples")
-# NOTE `tmp` is not a diminutive form of temporary: it signals a technical term. And "temp" is strongly disfavored.
 pathTmpRoot: Path = pathDataSamples / "tmp"
 
 # The registrar maintains the register of temp files
@@ -142,7 +147,7 @@ def mockBenchmarkTimer() -> Generator[unittest.mock.MagicMock | unittest.mock.As
 def mockFoldingFunction() -> Callable[..., Callable[..., None]]:
 	"""Creates a mock function that simulates _countFolds behavior."""
 	def make_mock(foldsValue: int, listDimensions: list[int]) -> Callable[..., None]:
-		mock_array = makeDataContainer(2)
+		mock_array = makeDataContainer(2, numpy.int32)
 		mock_array[0] = foldsValue
 		mapShape = validateListDimensions(listDimensions)
 		mock_array[-1] = getLeavesTotal(mapShape)
@@ -192,6 +197,11 @@ def useThisDispatcher() -> Generator[Callable[..., None], Any, None]:
 	yield patchDispatcher
 	basecamp.getPackageDispatcher = dispatcherOriginal
 
+def getAlgorithmDispatcher() -> Callable[[ComputationState], ComputationState]:
+	moduleImported: ModuleType = importlib_import_module(The.logicalPathModuleSourceAlgorithm)
+	dispatcherCallable = getattr(moduleImported, The.dispatcherCallable)
+	return dispatcherCallable
+
 @pytest.fixture
 def useAlgorithmSourceDispatcher(useThisDispatcher: Callable[..., Any]) -> Generator[None, None, None]:
 	"""Temporarily patches getDispatcherCallable to return the algorithm dispatcher."""
@@ -199,35 +209,35 @@ def useAlgorithmSourceDispatcher(useThisDispatcher: Callable[..., Any]) -> Gener
 	yield
 
 @pytest.fixture
-def syntheticDispatcherFixture(useThisDispatcher: Callable[..., Any]) -> Callable[..., Any]:
-	listCallablesInline = listNumbaCallableDispatchees
-	callableDispatcher = True
-	algorithmSource = getSourceAlgorithm()
-	relativePathWrite = theModuleOfSyntheticModules
-	filenameModuleWrite = 'pytestCount.py'
-	formatFilenameWrite = "pytest_{callableTarget}.py"
-	listSynthesizedModules: list[YouOughtaKnow] = makeFlowNumbaOptimized(listCallablesInline, callableDispatcher, algorithmSource, relativePathWrite, filenameModuleWrite, formatFilenameWrite)
-	dispatcherSynthetic: YouOughtaKnow | None = None
-	for stuff in listSynthesizedModules:
-		registrarRecordsTmpObject(stuff.pathFilenameForMe)
-		if stuff.callableSynthesized not in listCallablesInline:
-			dispatcherSynthetic = stuff
-
-	if dispatcherSynthetic is None:
-		raise raiseIfNoneGitHubIssueNumber3
-
-	dispatcherSpec = importlib.util.spec_from_file_location(dispatcherSynthetic.callableSynthesized, dispatcherSynthetic.pathFilenameForMe)
-	if dispatcherSpec is None:
-		raise ImportError(f"{dispatcherSynthetic.pathFilenameForMe=}")
-	if dispatcherSpec.loader is None:
-		raise ImportError(f"Failed to get loader for module {dispatcherSynthetic.pathFilenameForMe}")
-
-	dispatcherModule = importlib.util.module_from_spec(dispatcherSpec)
-	dispatcherSpec.loader.exec_module(dispatcherModule)
-	callableDispatcherSynthetic = getattr(dispatcherModule, dispatcherSynthetic.callableSynthesized)
-
-	useThisDispatcher(callableDispatcherSynthetic)
-	return callableDispatcherSynthetic
+def syntheticDispatcherFixture(useThisDispatcher: Callable[..., Any], pathTmpTesting: Path) -> Callable[..., Any]:
+    """Generate synthetic Numba-optimized dispatcher module and patch the dispatcher"""
+    # Configure synthesis flow to use test directory
+    recipeFlow = RecipeSynthesizeFlow(
+        pathPackage=PurePosixPath(pathTmpTesting.absolute()),
+        Z0Z_flowLogicalPathRoot=None,
+        moduleDispatcher="test_dispatcher",
+# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
+        # dispatcherCallable="dispatcherSynthetic",
+    )
+
+    # Generate optimized module in test directory
+    makeNumbaFlow(recipeFlow)
+
+    # Import synthesized dispatcher
+    importlibSpecificationDispatcher = importlib.util.spec_from_file_location(
+        recipeFlow.moduleDispatcher,
+        Path(recipeFlow.pathFilenameDispatcher),
+    )
+    if importlibSpecificationDispatcher is None or importlibSpecificationDispatcher.loader is None:
+        raise ImportError("Failed to load synthetic dispatcher module")
+
+    moduleSpecificationDispatcher = importlib.util.module_from_spec(importlibSpecificationDispatcher)
+    importlibSpecificationDispatcher.loader.exec_module(moduleSpecificationDispatcher)
+    callableDispatcherSynthetic = getattr(moduleSpecificationDispatcher, recipeFlow.dispatcherCallable)
+
+    # Patch dispatcher and return callable
+    useThisDispatcher(callableDispatcherSynthetic)
+    return callableDispatcherSynthetic
 
 def uniformTestMessage(expected: Any, actual: Any, functionName: str, *arguments: Any) -> str:
 	"""Format assertion message for any test comparison."""

tests/test_computations.py

@@ -23,6 +23,12 @@ 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]):
+    standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestParallelization)), countFolds, listDimensionsTestParallelization, None, 'maximum')
+
+def test_syntheticSequential(syntheticDispatcherFixture: None, listDimensionsTestCountFolds: list[int]) -> None:
+    standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestCountFolds)), countFolds, listDimensionsTestCountFolds)
+
 # @pytest.mark.parametrize('pathFilenameTmpTesting', ['.py'], indirect=True)
 # def test_writeJobNumba(listDimensionsTestCountFolds: list[int], pathFilenameTmpTesting: Path) -> None:
 #     from mapFolding.syntheticModules import numbaCount
@@ -44,10 +50,4 @@ def test_aOFn_calculate_value(oeisID: str) -> None:
 
 #     pathFilenameFoldsTotal = getPathFilenameFoldsTotal(listDimensionsTestCountFolds)
 #     registrarRecordsTmpObject(pathFilenameFoldsTotal)
-#     standardizedEqualTo(str(foldsTotalKnown[tuple(listDimensionsTestCountFolds)]), pathFilenameFoldsTotal.read_text().strip)
-
-# def test_syntheticParallel(syntheticDispatcherFixture: None, listDimensionsTestParallelization: list[int], foldsTotalKnown: dict[tuple[int, ...], int]):
-#     standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
-
-# def test_syntheticSequential(syntheticDispatcherFixture: None, listDimensionsTestCountFolds: list[int], foldsTotalKnown: dict[tuple[int, ...], int]):
-#     standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestCountFolds)], countFolds, listDimensionsTestCountFolds)
+#     standardizedEqualToCallableReturn(str(getFoldsTotalKnown(tuple(listDimensionsTestCountFolds))), pathFilenameFoldsTotal.read_text().strip)

tests/test_other.py

@@ -1,5 +1,6 @@
 from collections.abc import Callable
 from mapFolding.beDRY import getLeavesTotal, setCPUlimit, validateListDimensions
+from mapFolding.theSSOT import The
 from tests.conftest import standardizedEqualToCallableReturn
 from typing import Any, Literal
 from Z0Z_tools import intInnit
@@ -78,6 +79,5 @@ def testOopsieKwargsie(nameOfTest: str, callablePytest: Callable[[], None]) -> N
 	(1, 1),
 ])
 def test_setCPUlimit(CPUlimit: None | float | bool | Literal[4] | Literal[-2] | Literal[0] | Literal[1], expectedLimit: Any | int) -> None:
-	from mapFolding.theSSOT import concurrencyPackage
-	if concurrencyPackage == 'numba':
+	if The.concurrencyPackage == 'numba':
 		standardizedEqualToCallableReturn(expectedLimit, setCPUlimit, CPUlimit)