mapFolding 0.8.5__py3-none-any.whl → 0.9.0__py3-none-any.whl

tests/conftest.py

@@ -1,8 +1,65 @@
+"""
+Test Configuration and Shared Fixtures
+
+This module provides the foundation for the mapFolding test suite, offering fixtures and
+utilities that enable consistent, reliable testing across the package. It's particularly
+valuable for users who want to test their own customizations.
+
+## Key Testing Facilities
+
+### File System Management
+
+The module implements a robust temporary file system management approach:
+- Creates a registry of temporary files and directories
+- Ensures proper cleanup after tests
+- Provides fixtures that automatically handle cleanup
+
+### Test-Specific Fixtures
+
+Several fixtures enable specialized testing scenarios:
+
+1. **Dispatcher Fixtures**:
+   - `useThisDispatcher`: Core fixture for patching the algorithm dispatcher
+   - `useAlgorithmSourceDispatcher`: Tests with the source algorithm implementation
+   - `syntheticDispatcherFixture`: Tests with generated Numba-optimized implementation
+
+2. **Test Data Fixtures**:
+   - `oeisID`, `oeisID_1random`: Provide OEIS sequence identifiers for testing
+   - `listDimensionsTestCountFolds`: Provides dimensions suitable for algorithm testing
+   - `listDimensionsTestParallelization`: Provides dimensions suitable for parallel testing
+   - `mapShapeTestFunctionality`: Provides map shapes suitable for functional testing
+
+3. **Path Fixtures**:
+   - `pathTmpTesting`: Creates a temporary directory for test-specific files
+   - `pathFilenameTmpTesting`: Creates a temporary file with appropriate extension
+   - `pathCacheTesting`: Creates a temporary OEIS cache directory
+
+### Standardized Test Utilities
+
+The module provides utilities that create consistent test outputs:
+
+- `standardizedEqualToCallableReturn`: Core utility that handles testing function return values
+  or exceptions with uniform error messages
+- `standardizedSystemExit`: Tests code that should exit the program with specific status codes
+- `uniformTestMessage`: Creates consistent error messages for test failures
+
+## Using These Fixtures for Custom Tests
+
+The most important fixtures for testing custom implementations are:
+
+1. `syntheticDispatcherFixture`: Creates and patches a Numba-optimized module from a recipe
+2. `pathTmpTesting`: Provides a clean temporary directory for test files
+3. `standardizedEqualToCallableReturn`: Simplifies test assertions with clear error messages
+
+These can be adapted by copying and modifying them to test custom recipes and jobs.
+See the examples in `test_computations.py` for guidance on adapting these fixtures.
+"""
+
 from collections.abc import Callable, Generator, Sequence
+from mapFolding import ComputationState, The
 from mapFolding.beDRY import getLeavesTotal, validateListDimensions, makeDataContainer
 from mapFolding.oeis import oeisIDsImplemented, settingsOEIS
 from mapFolding.someAssemblyRequired import importLogicalPath2Callable, RecipeSynthesizeFlow
-from mapFolding.theSSOT import ComputationState, The, getPackageDispatcher
 from pathlib import Path, PurePosixPath
 from types import ModuleType
 from typing import Any
@@ -189,16 +246,27 @@ def useThisDispatcher() -> Generator[Callable[..., None], Any, None]:
 	Returns
 		A context manager for patching the dispatcher
 	"""
-	import mapFolding.basecamp as basecamp
-	dispatcherOriginal = basecamp.getPackageDispatcher
+	import mapFolding.theSSOT as theSSOT
+	from mapFolding.theSSOT import The
+
+	# Store original property method
+	original_dispatcher_property = theSSOT.PackageSettings.dispatcher
 
 	def patchDispatcher(callableTarget: Callable[..., Any]) -> None:
-		def callableParameterized(*arguments: Any, **keywordArguments: Any) -> Callable[..., Any]:
-			return callableTarget
-		basecamp.getPackageDispatcher = callableParameterized
+		"""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':
+				return callableTarget(state)
+			return wrapper
+
+		# Replace the property with our patched version
+		theSSOT.PackageSettings.dispatcher = property(patched_dispatcher) # type: ignore
 
 	yield patchDispatcher
-	basecamp.getPackageDispatcher = dispatcherOriginal
+
+	# Restore the original property
+	theSSOT.PackageSettings.dispatcher = original_dispatcher_property # type: ignore
 
 def getAlgorithmDispatcher() -> Callable[[ComputationState], ComputationState]:
 	moduleImported: ModuleType = importlib.import_module(The.logicalPathModuleSourceAlgorithm)

tests/test_computations.py

@@ -1,16 +1,97 @@
-from mapFolding.basecamp import countFolds
-from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal
-from mapFolding.beDRY import validateListDimensions
-from mapFolding.noHomeYet import getFoldsTotalKnown
-from mapFolding.oeis import settingsOEIS, oeisIDfor_n
+"""
+Core Algorithm and Module Generation Testing
+
+This module provides tests for validating algorithm correctness and testing
+code generation functionality. It's designed not only to test the package's
+functionality but also to serve as a template for users testing their own
+custom implementations.
+
+## Key Testing Categories
+
+1. Algorithm Validation Tests
+   - `test_algorithmSourceParallel` - Tests the source algorithm in parallel mode
+   - `test_algorithmSourceSequential` - Tests the source algorithm in sequential mode
+   - `test_aOFn_calculate_value` - Tests OEIS sequence value calculations
+
+2. Synthetic Module Tests
+   - `test_syntheticParallel` - Tests generated Numba-optimized code in parallel mode
+   - `test_syntheticSequential` - Tests generated Numba-optimized code in sequential mode
+
+3. Job Testing
+   - `test_writeJobNumba` - Tests job-specific module generation and execution
+
+## How to Test Your Custom Implementations
+
+### Testing Custom Recipes (RecipeSynthesizeFlow):
+
+1. Copy the `syntheticDispatcherFixture` from conftest.py
+2. Modify it to use your custom recipe configuration
+3. Copy and adapt `test_syntheticParallel` and `test_syntheticSequential`
+
+Example:
+
+```python
+@pytest.fixture
+def myCustomRecipeFixture(useThisDispatcher, pathTmpTesting):
+    # Create your custom recipe configuration
+    myRecipe = RecipeSynthesizeFlow(
+        pathPackage=PurePosixPath(pathTmpTesting.absolute()),
+        # Add your custom configuration
+    )
+
+    # Generate the module
+    makeNumbaFlow(myRecipe)
+
+    # Import and patch the dispatcher
+    # ... (similar to syntheticDispatcherFixture)
+
+    return customDispatcher
+
+def test_myCustomRecipeParallel(myCustomRecipeFixture, listDimensionsTestParallelization):
+    # Test with the standardized validation utility
+    standardizedEqualToCallableReturn(
+        getFoldsTotalKnown(tuple(listDimensionsTestParallelization)),
+        countFolds,
+        listDimensionsTestParallelization,
+        None,
+        'maximum'
+    )
+```
+
+### Testing Custom Jobs (RecipeJob):
+
+1. Copy and adapt `test_writeJobNumba`
+2. Modify it to use your custom job configuration
+
+Example:
+
+```python
+def test_myCustomJob(oneTestCuzTestsOverwritingTests, pathFilenameTmpTesting):
+    # Create your custom job configuration
+    myJob = RecipeJob(
+        state=makeInitializedComputationState(validateListDimensions(oneTestCuzTestsOverwritingTests)),
+        # Add your custom configuration
+    )
+
+    spices = SpicesJobNumba()
+    # Customize spices if needed
+
+    # Generate and test the job
+    makeJobNumba(myJob, spices)
+    # Test execution similar to test_writeJobNumba
+```
+
+All tests leverage standardized utilities like `standardizedEqualToCallableReturn`
+that provide consistent, informative error messages and simplify test validation.
+"""
+
+from mapFolding import countFolds, getFoldsTotalKnown, oeisIDfor_n, validateListDimensions
+from mapFolding.oeis import settingsOEIS
 from mapFolding.someAssemblyRequired.transformationTools import makeInitializedComputationState
 from pathlib import Path, PurePosixPath
 from tests.conftest import standardizedEqualToCallableReturn, registrarRecordsTmpObject
-from types import ModuleType
 import importlib.util
 import multiprocessing
-import threading
-from copy import deepcopy
 import pytest
 
 if __name__ == '__main__':
@@ -26,7 +107,7 @@ 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]):
+def test_syntheticParallel(syntheticDispatcherFixture: None, listDimensionsTestParallelization: list[int]) -> None:
 	standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestParallelization)), countFolds, listDimensionsTestParallelization, None, 'maximum')
 
 def test_syntheticSequential(syntheticDispatcherFixture: None, listDimensionsTestCountFolds: list[int]) -> None:

tests/test_filesystem.py

@@ -1,50 +1,49 @@
 from contextlib import redirect_stdout
-from mapFolding.toolboxFilesystem import getFilenameFoldsTotal, getPathFilenameFoldsTotal, saveFoldsTotal
-from mapFolding.beDRY import validateListDimensions
-from mapFolding.toolboxFilesystem import getPathRootJobDEFAULT
+from mapFolding import validateListDimensions, getPathRootJobDEFAULT, getPathFilenameFoldsTotal, saveFoldsTotal
+from mapFolding.toolboxFilesystem import getFilenameFoldsTotal
 from pathlib import Path
 import io
 import pytest
 import unittest.mock
 
 def test_saveFoldsTotal_fallback(pathTmpTesting: Path) -> None:
-    foldsTotal = 123
-    pathFilename = pathTmpTesting / "foldsTotal.txt"
-    with unittest.mock.patch("pathlib.Path.write_text", side_effect=OSError("Simulated write failure")):
-        with unittest.mock.patch("os.getcwd", return_value=str(pathTmpTesting)):
-            capturedOutput = io.StringIO()
-            with redirect_stdout(capturedOutput):
-                saveFoldsTotal(pathFilename, foldsTotal)
-    fallbackFiles = list(pathTmpTesting.glob("foldsTotalYO_*.txt"))
-    assert len(fallbackFiles) == 1, "Fallback file was not created upon write failure."
+	foldsTotal = 123
+	pathFilename = pathTmpTesting / "foldsTotal.txt"
+	with unittest.mock.patch("pathlib.Path.write_text", side_effect=OSError("Simulated write failure")):
+		with unittest.mock.patch("os.getcwd", return_value=str(pathTmpTesting)):
+			capturedOutput = io.StringIO()
+			with redirect_stdout(capturedOutput):
+				saveFoldsTotal(pathFilename, foldsTotal)
+	fallbackFiles = list(pathTmpTesting.glob("foldsTotalYO_*.txt"))
+	assert len(fallbackFiles) == 1, "Fallback file was not created upon write failure."
 
 @pytest.mark.parametrize("listDimensions, expectedFilename", [
-    ([11, 13], "p11x13.foldsTotal"),
-    ([17, 13, 11], "p11x13x17.foldsTotal"),
+	([11, 13], "p11x13.foldsTotal"),
+	([17, 13, 11], "p11x13x17.foldsTotal"),
 ])
 def test_getFilenameFoldsTotal(listDimensions: list[int], expectedFilename: str) -> None:
-    """Test that getFilenameFoldsTotal generates correct filenames with dimensions sorted."""
-    mapShape = validateListDimensions(listDimensions)
-    filenameActual = getFilenameFoldsTotal(mapShape)
-    assert filenameActual == expectedFilename, f"Expected filename {expectedFilename} but got {filenameActual}"
+	"""Test that getFilenameFoldsTotal generates correct filenames with dimensions sorted."""
+	mapShape = validateListDimensions(listDimensions)
+	filenameActual = getFilenameFoldsTotal(mapShape)
+	assert filenameActual == expectedFilename, f"Expected filename {expectedFilename} but got {filenameActual}"
 
 def test_getPathFilenameFoldsTotal_defaultPath(mapShapeTestFunctionality: tuple[int, ...]) -> None:
-    """Test getPathFilenameFoldsTotal with default path."""
-    pathFilenameFoldsTotal = getPathFilenameFoldsTotal(mapShapeTestFunctionality)
-    assert pathFilenameFoldsTotal.is_absolute(), "Path should be absolute"
-    assert pathFilenameFoldsTotal.name == getFilenameFoldsTotal(mapShapeTestFunctionality), "Filename should match getFilenameFoldsTotal output"
-    assert pathFilenameFoldsTotal.parent == getPathRootJobDEFAULT(), "Parent directory should match default job root"
+	"""Test getPathFilenameFoldsTotal with default path."""
+	pathFilenameFoldsTotal = getPathFilenameFoldsTotal(mapShapeTestFunctionality)
+	assert pathFilenameFoldsTotal.is_absolute(), "Path should be absolute"
+	assert pathFilenameFoldsTotal.name == getFilenameFoldsTotal(mapShapeTestFunctionality), "Filename should match getFilenameFoldsTotal output"
+	assert pathFilenameFoldsTotal.parent == getPathRootJobDEFAULT(), "Parent directory should match default job root"
 
 def test_getPathFilenameFoldsTotal_relativeFilename(mapShapeTestFunctionality: tuple[int, ...]) -> None:
-    """Test getPathFilenameFoldsTotal with relative filename."""
-    relativeFilename = Path("custom/path/test.foldsTotal")
-    pathFilenameFoldsTotal = getPathFilenameFoldsTotal(mapShapeTestFunctionality, relativeFilename)
-    assert pathFilenameFoldsTotal.is_absolute(), "Path should be absolute"
-    assert pathFilenameFoldsTotal == getPathRootJobDEFAULT() / relativeFilename, "Relative path should be appended to default job root"
+	"""Test getPathFilenameFoldsTotal with relative filename."""
+	relativeFilename = Path("custom/path/test.foldsTotal")
+	pathFilenameFoldsTotal = getPathFilenameFoldsTotal(mapShapeTestFunctionality, relativeFilename)
+	assert pathFilenameFoldsTotal.is_absolute(), "Path should be absolute"
+	assert pathFilenameFoldsTotal == getPathRootJobDEFAULT() / relativeFilename, "Relative path should be appended to default job root"
 
 def test_getPathFilenameFoldsTotal_createsDirs(pathTmpTesting: Path, mapShapeTestFunctionality: tuple[int, ...]) -> None:
-    """Test that getPathFilenameFoldsTotal creates necessary directories."""
-    nestedPath = pathTmpTesting / "deep/nested/structure"
-    pathFilenameFoldsTotal = getPathFilenameFoldsTotal(mapShapeTestFunctionality, nestedPath)
-    assert pathFilenameFoldsTotal.parent.exists(), "Parent directories should be created"
-    assert pathFilenameFoldsTotal.parent.is_dir(), "Created path should be a directory"
+	"""Test that getPathFilenameFoldsTotal creates necessary directories."""
+	nestedPath = pathTmpTesting / "deep/nested/structure"
+	pathFilenameFoldsTotal = getPathFilenameFoldsTotal(mapShapeTestFunctionality, nestedPath)
+	assert pathFilenameFoldsTotal.parent.exists(), "Parent directories should be created"
+	assert pathFilenameFoldsTotal.parent.is_dir(), "Created path should be a directory"

tests/test_other.py

@@ -1,6 +1,5 @@
 from collections.abc import Callable
 from mapFolding.beDRY import getLeavesTotal, setProcessorLimit, validateListDimensions
-from mapFolding.theSSOT import The
 from tests.conftest import standardizedEqualToCallableReturn
 from typing import Any, Literal
 from Z0Z_tools import intInnit

tests/test_tasks.py

@@ -1,7 +1,7 @@
 from collections.abc import Callable
-from mapFolding.basecamp import countFolds
+from mapFolding import countFolds
 from mapFolding.beDRY import getTaskDivisions, setProcessorLimit, validateListDimensions, getLeavesTotal
-from mapFolding.noHomeYet import getFoldsTotalKnown
+from mapFolding.oeis import getFoldsTotalKnown
 from tests.conftest import standardizedEqualToCallableReturn
 from typing import Literal
 from Z0Z_tools.pytestForYourUse import PytestFor_defineConcurrencyLimit

mapFolding/noHomeYet.py

@@ -1,32 +0,0 @@
-"""
-Interface for retrieving known map folding totals from OEIS (Online Encyclopedia of Integer Sequences).
-
-This module provides utilities for accessing pre-computed map folding totals that are known
-from mathematical literature and stored in the OEIS. The functions cache results for
-performance and provide lookups based on map dimensions.
-
-The main functions are:
-- makeDictionaryFoldsTotalKnown: Creates a dictionary of known folding totals indexed by map dimensions
-- getFoldsTotalKnown: Retrieves the folding total for a specific map shape, returning -1 if unknown
-"""
-
-from functools import cache
-from mapFolding.oeis import settingsOEIS
-
-@cache
-def makeDictionaryFoldsTotalKnown() -> dict[tuple[int, ...], int]:
-	"""Returns a dictionary mapping dimension tuples to their known folding totals."""
-	dictionaryMapDimensionsToFoldsTotalKnown: dict[tuple[int, ...], int] = {}
-
-	for settings in settingsOEIS.values():
-		sequence = settings['valuesKnown']
-
-		for n, foldingsTotal in sequence.items():
-			mapShape = settings['getMapShape'](n)
-			mapShape = tuple(sorted(mapShape))
-			dictionaryMapDimensionsToFoldsTotalKnown[mapShape] = foldingsTotal
-	return dictionaryMapDimensionsToFoldsTotalKnown
-
-def getFoldsTotalKnown(mapShape: tuple[int, ...]) -> int:
-	lookupFoldsTotal = makeDictionaryFoldsTotalKnown()
-	return lookupFoldsTotal.get(tuple(mapShape), -1)

mapFolding/someAssemblyRequired/newInliner.py

@@ -1,22 +0,0 @@
-from collections.abc import Callable
-from copy import deepcopy
-from mapFolding.someAssemblyRequired import ast_Identifier, RecipeSynthesizeFlow, Then, be, ifThis, DOT, 又, NodeChanger
-from mapFolding.someAssemblyRequired.transformationTools import makeDictionary4InliningFunction, makeDictionaryFunctionDef
-from typing import cast
-import ast
-
-def inlineFunctionDef(astFunctionDef: ast.FunctionDef, dictionary4Inlining: dict[ast_Identifier, ast.FunctionDef]) -> ast.FunctionDef:
-
-	return astFunctionDef
-
-# Test code
-testFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()
-dictionary4Inlining: dict[ast_Identifier, ast.FunctionDef] = makeDictionary4InliningFunction(
-	testFlow.sourceCallableSequential,
-	(dictionaryFunctionDef := makeDictionaryFunctionDef(testFlow.source_astModule)))
-
-astFunctionDef = dictionaryFunctionDef[testFlow.sourceCallableSequential]
-
-astFunctionDefTransformed = inlineFunctionDef(
-	astFunctionDef,
-	dictionary4Inlining)

mapfolding-0.8.5.dist-info/METADATA

@@ -1,190 +0,0 @@
-Metadata-Version: 2.4
-Name: mapFolding
-Version: 0.8.5
-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
-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
-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
-Classifier: Development Status :: 4 - Beta
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Education
-Classifier: Intended Audience :: Science/Research
-Classifier: Natural Language :: English
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Scientific/Engineering :: Mathematics
-Classifier: Topic :: Scientific/Engineering :: Information Analysis
-Classifier: Topic :: Software Development :: Code Generators
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Software Development :: Compilers
-Classifier: Typing :: Typed
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: autoflake
-Requires-Dist: more_itertools
-Requires-Dist: numba_progress
-Requires-Dist: numba
-Requires-Dist: numpy
-Requires-Dist: platformdirs
-Requires-Dist: python_minifier
-Requires-Dist: tomli
-Requires-Dist: Z0Z_tools
-Provides-Extra: testing
-Requires-Dist: mypy; extra == "testing"
-Requires-Dist: pytest; extra == "testing"
-Requires-Dist: pytest-cov; extra == "testing"
-Requires-Dist: pytest-env; extra == "testing"
-Requires-Dist: pytest-xdist; extra == "testing"
-Requires-Dist: pyupgrade; extra == "testing"
-Requires-Dist: ruff; extra == "testing"
-Dynamic: license-file
-
-# mapFolding: Algorithms for enumerating distinct map/stamp folding patterns 🗺️
-
-[![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/)
-[![Static Badge](https://img.shields.io/badge/stinkin'%20badges-don't%20need-b98e5e)](https://youtu.be/g6f_miE91mk&t=4)
-[![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/pythonTests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/pythonTests.yml)
-![Static Badge](https://img.shields.io/badge/issues-I%20have%20them-brightgreen)
-[![License: CC-BY-NC-4.0](https://img.shields.io/badge/License-CC_BY--NC_4.0-3b434b)](https://creativecommons.org/licenses/by-nc/4.0/)
-
----
-
-## Quick start
-
-```sh
-pip install mapFolding
-```
-
-`OEIS_for_n` will run a computation from the command line.
-
-```cmd
-(mapFolding) C:\apps\mapFolding> OEIS_for_n A001418 5
-186086600 distinct folding patterns.
-Time elapsed: 1.605 seconds
-```
-
-Use `mapFolding.oeisIDfor_n()` to compute a(n) for an OEIS ID.
-
-```python
-from mapFolding import oeisIDfor_n
-foldsTotal = oeisIDfor_n( 'A001418', 4 )
-```
-
----
-
-## Features
-
-### 1. Simple, easy usage based on OEIS IDs
-
-`mapFolding` directly implements some IDs from [_The On-Line Encyclopedia of Integer Sequences_](https://oeis.org/) ([BibTex](https://github.com/hunterhogan/mapFolding/blob/main/citations/oeis.bibtex) citation).
-
-Use `getOEISids` to get the most up-to-date list of available OEIS IDs.
-
-```cmd
-(mapFolding) C:\apps\mapFolding> getOEISids
-
-Available OEIS sequences:
-  A001415: Number of ways of folding a 2 X n strip of stamps. (Now extended to n=20!)
-  A001416: Number of ways of folding a 3 X n strip of stamps.
-  A001417: Number of ways of folding a 2 X 2 X ... X 2 n-dimensional map.
-  A001418: Number of ways of folding an n X n sheet of stamps.
-  A195646: Number of ways of folding a 3 X 3 X ... X 3 n-dimensional map.
-```
-
-### 2. **Algorithm Zoo: A Historical and Performance Journey** 🦒
-
-This package offers a comprehensive collection of map folding algorithm implementations that showcase its evolution from historical origins to high-performance computation:
-
-- **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
-
-- **Direct Translations**:
-  - Python translations following the original control flow (`lunnanWhile.py`)
-  - NumPy-based vectorized implementations (`lunnanNumpy.py`)
-
-- **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
-
-- **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`)
-  - **New Computations**: First-ever calculations for 2×19 and 2×20 maps in the `reference/jobsCompleted/` directory
-
-The `reference` directory serves as both a historical archive and an educational resource for understanding algorithm evolution.
-
-### 3. **Algorithmic Transformation: From Readability to Speed** 🔬
-
-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 Assembly-line**:
-  - **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
-
-- **Advanced Transformation**:
-  - 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 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 explore deeper optimization techniques as your computational needs grow.
-
-## Map-folding Video
-
-~~This caused my neurosis:~~ I enjoyed the following video, which is what introduced me to map folding.
-
-"How Many Ways Can You Fold a Map?" by Physics for the Birds, 2024 November 13 ([BibTex](https://github.com/hunterhogan/mapFolding/blob/main/citations/Physics_for_the_Birds.bibtex) citation)
-
-[![How Many Ways Can You Fold a Map?](https://i.ytimg.com/vi/sfH9uIY3ln4/hq720.jpg)](https://www.youtube.com/watch?v=sfH9uIY3ln4)
-
----
-
-## My recovery
-
-[![Static Badge](https://img.shields.io/badge/2011_August-Homeless_since-blue?style=flat)](https://HunterThinks.com/support)
-[![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UC3Gx7kz61009NbhpRtPP7tw)](https://www.youtube.com/@HunterHogan)
-
-[![CC-BY-NC-4.0](https://github.com/hunterhogan/mapFolding/blob/main/CC-BY-NC-4.0.svg)](https://creativecommons.org/licenses/by-nc/4.0/)

mapfolding-0.8.5.dist-info/RECORD

@@ -1,48 +0,0 @@
-mapFolding/__init__.py,sha256=LBgk-iW95pzqkFGY8PbcnU0oHy0AXwJGo18mM0g8wEw,2227
-mapFolding/basecamp.py,sha256=-__EJ2to84ssS4Fm0CAuQjRnghI9VA4cXZoWGYud1r0,4782
-mapFolding/beDRY.py,sha256=2GPO4A8XcxoEJXB_3sro4ZFQ5gcU7ywc1-c8HLEvEv0,15280
-mapFolding/noHomeYet.py,sha256=UKZeWlyn0SKlF9dhYoud7E6gWXpiSEekZOOoJp88WeI,1362
-mapFolding/oeis.py,sha256=EzEnbRi_4qt8Na2tiMcvL23FXpcJEkXTwuXDYDFH_XI,12631
-mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mapFolding/theDao.py,sha256=MVopt1LzhdIQYA97SEoq9bdzct6hbK0lEyPxBAAlVTc,9934
-mapFolding/theSSOT.py,sha256=i3R_G702U7VQOil61ky60JGGsSEOk_x1555rg8yI0Tc,11978
-mapFolding/toolboxFilesystem.py,sha256=WoqRjXqTXy5GYNmbfzWtzv1uufm7vYcgT4zJ9ffhRYY,9982
-mapFolding/reference/__init__.py,sha256=UIEU8BJR_YDzjFQcLel3XtHzOCJiOUGlGiWzOzbvhik,2206
-mapFolding/reference/flattened.py,sha256=QK1xG9SllqCoi68e86Hyl9d9ATUAAFNpTQI-3zmcp5I,16072
-mapFolding/reference/hunterNumba.py,sha256=iLfyqwGdAh6c5GbapnKsWhAsNsR3O-fyGGHAdohluLw,7258
-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/reference/jobsCompleted/__init__.py,sha256=TU93ZGUW1xEkT6d9mQFn_rp5DvRy0ZslEB2Q6MF5ZDc,2596
-mapFolding/reference/jobsCompleted/[2x19]/p2x19.py,sha256=_tvYtfzMWVo2VtUbIAieoscb4N8FFflgTdW4-ljBUuA,19626
-mapFolding/reference/jobsCompleted/p2x19/p2x19.py,sha256=eZEw4Me4ocTt6VXoK2-Sbd5SowZtxRIbN9dZmc7OCVg,6395
-mapFolding/someAssemblyRequired/__init__.py,sha256=c2GFI2HSId2_R_aoJWBID-P9AMF3zoHJzOc10XS6DHc,2669
-mapFolding/someAssemblyRequired/_theTypes.py,sha256=SG82WTtQy83BmInlHZHY8Nh3Kp161NcEFSA6-UU5wuE,4623
-mapFolding/someAssemblyRequired/_tool_Make.py,sha256=8ezrMDAdUY6m1raFp-G8vNXrHEr8IGfnZJ-aMVKzGf0,7092
-mapFolding/someAssemblyRequired/_tool_Then.py,sha256=QxuoBqj4iOeKWITjV3DcV8c25fLx3Q6mhUORD7-mCzc,2758
-mapFolding/someAssemblyRequired/_toolboxAntecedents.py,sha256=GEAuniYRj6yOtrJO_6sGZMzsVARdejts8NXhR_0np_c,21914
-mapFolding/someAssemblyRequired/_toolboxContainers.py,sha256=iPLZbFcGB6dKtX3WkopnM-2OtMcVuxXQT46iFhzpdfY,17815
-mapFolding/someAssemblyRequired/_toolboxPython.py,sha256=za30092eT00tj5ctqUCRrEuq5DGeJZN-vV9T4Dro-1w,3483
-mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=9RPU6vK_eUg64GtVFI_nZnvUryXw8gfHJs9NyDYHIvg,2745
-mapFolding/someAssemblyRequired/newInliner.py,sha256=Tm9PSzt66oIXPVrN9VdQwEYBba2iEOF5X3aEsOOF-FE,946
-mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=0L5ccqBusof6MzKatKnpUmFUNkAtbapzl_Fxmofi4DE,8684
-mapFolding/someAssemblyRequired/toolboxNumba.py,sha256=rluEmsSJOQCl2L6LlJzIc3AfeRxU6cp-sCf-rQFW-og,22613
-mapFolding/someAssemblyRequired/transformationTools.py,sha256=iIvRxSL45qTyl0d0ztHa9BP1MrOikfXE4HBqLlNMENc,20081
-mapFolding/syntheticModules/__init__.py,sha256=evVFqhCGa-WZKDiLcnQWjs-Bj34eRnfSLqz_d7dFYZY,83
-mapFolding/syntheticModules/numbaCount_doTheNeedful.py,sha256=3thXThbv2Xo0t_cRGzMbHPFXTBmLClmKejR_Ibu_jOo,15697
-mapfolding-0.8.5.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/conftest.py,sha256=LfogHLu7PULSECwhLQgGCgqSvDMBc5b9RGWBls3YBrM,11364
-tests/test_computations.py,sha256=XjCej6M6lesfKB_ulWq3O-ryXBsJuuwnJ6_XjKOvgDY,3552
-tests/test_filesystem.py,sha256=YEHNU6tUCTj9C65cKs3ETgt3OZTGVnNjxgu4aH6C9uU,3164
-tests/test_oeis.py,sha256=uxvwmgbnylSDdsVJfuAT0LuYLbIVFwSgdLxHm-xUGBM,5043
-tests/test_other.py,sha256=O05PFAK70Skf-k99Wcg4ASLpMpBH-WkELtk6MnynDx0,4293
-tests/test_tasks.py,sha256=S-6PNfM__Npw0zVojgzn5M-6ODBKDyRH5ccMTqQF9C4,2865
-mapfolding-0.8.5.dist-info/METADATA,sha256=vrusTb9uu8FQ3UksfFkVZ3txtYPNufYa3db-Rk6H1y0,9359
-mapfolding-0.8.5.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-mapfolding-0.8.5.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapfolding-0.8.5.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapfolding-0.8.5.dist-info/RECORD,,