mapFolding 0.12.0__py3-none-any.whl → 0.12.2__py3-none-any.whl

mapFolding/someAssemblyRequired/transformationTools.py

@@ -1,45 +1,42 @@
 """
-AST Transformation Tools for Python Code Generation
-
-This module provides tools for manipulating and transforming Python abstract syntax trees
-to generate optimized code. It implements a system that:
-
-1. Extracts functions and classes from existing modules.
-2. Reshapes and transforms them through AST manipulation.
-3. Manages dependencies and imports.
-4. Generates optimized code with specialized implementations.
-
-The module is particularly focused on transforming general-purpose Python code into
-high-performance implementations, especially through dataclass decomposition and
-function inlining for Numba compatibility.
-
-At its core, the module implements a transformation assembly-line where code flows from
-readable, maintainable implementations to highly optimized versions while preserving
-logical structure and correctness.
+Map folding AST transformation system: Core dataclass decomposition and function optimization tools.
+
+This module implements the essential transformation capabilities that form the operational core of
+the map folding AST transformation system. Working with the pattern recognition foundation and
+decomposition containers established in the foundational layers, these tools execute the critical
+transformations that convert dataclass-based functions into optimized implementations suitable
+for Numba just-in-time compilation.
+
+The transformation process addresses the fundamental incompatibility between dataclass-dependent
+map folding algorithms and Numba's compilation requirements. While dataclass instances provide
+clean, maintainable interfaces for complex mathematical state, Numba cannot directly process
+these objects but excels at optimizing operations on primitive values and tuples. The tools
+bridge this architectural gap through systematic function signature transformation and calling
+convention adaptation.
+
+The three-stage transformation pattern implemented here follows a precise sequence: dataclass
+decomposition breaks down dataclass definitions into constituent AST components while extracting
+field definitions and type annotations; function transformation converts functions accepting
+dataclass parameters to functions accepting individual field parameters with updated signatures
+and return types; caller adaptation modifies calling code to unpack dataclass instances, invoke
+transformed functions, and repack results back into dataclass instances.
+
+This approach enables seamless integration between high-level dataclass-based interfaces and
+low-level optimized implementations, maintaining code clarity while achieving performance gains
+through specialized compilation paths essential for computationally intensive map folding research.
 """
 
-from astToolkit import ClassIsAndAttribute
-from mapFolding.someAssemblyRequired import (
-	DeReConstructField2ast,
-	IfThis,
-	ShatteredDataclass,
-)
-from astToolkit import(
-	Be,
-	extractClassDef,
-	IngredientsFunction,
-	Make,
-	NodeChanger,
-	parseLogicalPath2astModule,
-	str_nameDOTname,
-	Then,
+from astToolkit import (
+	Be, ClassIsAndAttribute, extractClassDef, identifierDotAttribute, IngredientsFunction, Make,
+	NodeChanger, parseLogicalPath2astModule, Then,
 )
 from astToolkit.transformationTools import unparseFindReplace
+from mapFolding.someAssemblyRequired import DeReConstructField2ast, IfThis, ShatteredDataclass
 from Z0Z_tools import importLogicalPath2Callable
 import ast
 import dataclasses
 
-def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, dataclass_Identifier: str, instance_Identifier: str) -> ShatteredDataclass:
+def shatter_dataclassesDOTdataclass(logicalPathModule: identifierDotAttribute, dataclassIdentifier: str, instanceIdentifier: str) -> ShatteredDataclass:
 	"""
 	Decompose a dataclass definition into AST components for manipulation and code generation.
 
@@ -59,8 +56,8 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, dataclas
 
 	Parameters:
 		logicalPathModule: The fully qualified module path containing the dataclass definition.
-		dataclass_Identifier: The name of the dataclass to decompose.
-		instance_Identifier: The variable name to use for the dataclass instance in generated code.
+		dataclassIdentifier: The name of the dataclass to decompose.
+		instanceIdentifier: The variable name to use for the dataclass instance in generated code.
 
 	Returns:
 		shatteredDataclass: A ShatteredDataclass containing AST representations of all dataclass components,
@@ -72,20 +69,20 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, dataclas
 	Official_fieldOrder: list[str] = []
 	dictionaryDeReConstruction: dict[str, DeReConstructField2ast] = {}
 
-	dataclassClassDef = extractClassDef(parseLogicalPath2astModule(logicalPathModule), dataclass_Identifier)
-	if not isinstance(dataclassClassDef, ast.ClassDef): raise ValueError(f"I could not find `{dataclass_Identifier = }` in `{logicalPathModule = }`.")
+	dataclassClassDef: ast.ClassDef | None = extractClassDef(parseLogicalPath2astModule(logicalPathModule), dataclassIdentifier)
+	if not isinstance(dataclassClassDef, ast.ClassDef):
+		raise ValueError(f"I could not find `{dataclassIdentifier = }` in `{logicalPathModule = }`.")
 
 	countingVariable = None
-	for aField in dataclasses.fields(importLogicalPath2Callable(logicalPathModule, dataclass_Identifier)): # pyright: ignore [reportArgumentType]
+	for aField in dataclasses.fields(importLogicalPath2Callable(logicalPathModule, dataclassIdentifier)): # pyright: ignore [reportArgumentType]
 		Official_fieldOrder.append(aField.name)
-		dictionaryDeReConstruction[aField.name] = DeReConstructField2ast(logicalPathModule, dataclassClassDef, instance_Identifier, aField)
+		dictionaryDeReConstruction[aField.name] = DeReConstructField2ast(logicalPathModule, dataclassClassDef, instanceIdentifier, aField)
 		if aField.metadata.get('theCountingIdentifier', False):
 			countingVariable = dictionaryDeReConstruction[aField.name].name
-
 	if countingVariable is None:
-		import warnings
-		warnings.warn(message=f"I could not find the counting variable in `{dataclass_Identifier = }` in `{logicalPathModule = }`.", category=UserWarning)
-		raise Exception
+		# import warnings
+		# warnings.warn(message=f"I could not find the counting variable in `{dataclassIdentifier = }` in `{logicalPathModule = }`.", category=UserWarning)
+		raise ValueError(f"I could not find the counting variable in `{dataclassIdentifier = }` in `{logicalPathModule = }`.")
 
 	shatteredDataclass = ShatteredDataclass(
 		countingVariableAnnotation=dictionaryDeReConstruction[countingVariable].astAnnotation,
@@ -100,16 +97,38 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, dataclas
 		map_stateDOTfield2Name={dictionaryDeReConstruction[field].ast_nameDOTname: dictionaryDeReConstruction[field].astName for field in Official_fieldOrder},
 		)
 	shatteredDataclass.fragments4AssignmentOrParameters = Make.Tuple(shatteredDataclass.listName4Parameters, ast.Store())
-	shatteredDataclass.repack = Make.Assign([Make.Name(instance_Identifier)], value=Make.Call(Make.Name(dataclass_Identifier), list_keyword=shatteredDataclass.list_keyword_field__field4init))
+	shatteredDataclass.repack = Make.Assign([Make.Name(instanceIdentifier)], value=Make.Call(Make.Name(dataclassIdentifier), list_keyword=shatteredDataclass.list_keyword_field__field4init))
 	shatteredDataclass.signatureReturnAnnotation = Make.Subscript(Make.Name('tuple'), Make.Tuple(shatteredDataclass.listAnnotations))
 
 	shatteredDataclass.imports.update(*(dictionaryDeReConstruction[field].ledger for field in Official_fieldOrder))
-	shatteredDataclass.imports.addImportFrom_asStr(logicalPathModule, dataclass_Identifier)
+	shatteredDataclass.imports.addImportFrom_asStr(logicalPathModule, dataclassIdentifier)
 
 	return shatteredDataclass
 
 def removeDataclassFromFunction(ingredientsTarget: IngredientsFunction, shatteredDataclass: ShatteredDataclass) -> IngredientsFunction:
-	ingredientsTarget.astFunctionDef.args = Make.arguments(args=shatteredDataclass.list_argAnnotated4ArgumentsSpecification)
+	"""
+	Transform a function that operates on dataclass instances to work with individual field parameters.
+
+	This function performs the core transformation required for Numba compatibility by removing dataclass
+	dependencies from function signatures and implementations. It modifies the target function to:
+
+	1. Replace the single dataclass parameter with individual field parameters.
+	2. Update the return type annotation to return a tuple of field values.
+	3. Transform return statements to return the tuple of fields.
+	4. Replace all dataclass attribute access with direct field variable access.
+
+	This transformation is essential for creating Numba-compatible functions from dataclass-based
+	implementations, as Numba cannot handle dataclass instances directly but can efficiently
+	process individual primitive values and tuples.
+
+	Parameters:
+		ingredientsTarget: The function definition and its dependencies to be transformed.
+		shatteredDataclass: The decomposed dataclass components providing AST mappings and transformations.
+
+	Returns:
+		ingredientsTarget: The modified function ingredients with dataclass dependencies removed.
+	"""
+	ingredientsTarget.astFunctionDef.args = Make.arguments(list_arg=shatteredDataclass.list_argAnnotated4ArgumentsSpecification)
 	ingredientsTarget.astFunctionDef.returns = shatteredDataclass.signatureReturnAnnotation
 	changeReturnCallable = NodeChanger(Be.Return, Then.replaceWith(Make.Return(shatteredDataclass.fragments4AssignmentOrParameters)))
 	changeReturnCallable.visit(ingredientsTarget.astFunctionDef)
@@ -117,10 +136,35 @@ def removeDataclassFromFunction(ingredientsTarget: IngredientsFunction, shattere
 	return ingredientsTarget
 
 def unpackDataclassCallFunctionRepackDataclass(ingredientsCaller: IngredientsFunction, targetCallableIdentifier: str, shatteredDataclass: ShatteredDataclass) -> IngredientsFunction:
+	"""
+	Transform a caller function to interface with a dataclass-free target function.
+
+	This function complements `removeDataclassFromFunction` by modifying calling code to work with
+	the transformed target function. It implements the unpacking and repacking pattern required
+	when a dataclass-based caller needs to invoke a function that has been converted to accept
+	individual field parameters instead of dataclass instances.
+
+	The transformation creates a three-step pattern around the target function call:
+	1. Unpack the dataclass instance into individual field variables.
+	2. Call the target function with the unpacked field values.
+	3. Repack the returned field values back into a dataclass instance.
+
+	This enables seamless integration between dataclass-based high-level code and optimized
+	field-based implementations, maintaining the original interface while enabling performance
+	optimizations in the target function.
+
+	Parameters:
+		ingredientsCaller: The calling function definition and its dependencies to be transformed.
+		targetCallableIdentifier: The name of the target function being called.
+		shatteredDataclass: The decomposed dataclass components providing unpacking and repacking logic.
+
+	Returns:
+		ingredientsCaller: The modified caller function with appropriate unpacking and repacking around the target call.
+	"""
 	astCallTargetCallable = Make.Call(Make.Name(targetCallableIdentifier), shatteredDataclass.listName4Parameters)
-	replaceAssignTargetCallable = NodeChanger(ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCall_Identifier(targetCallableIdentifier)), Then.replaceWith(Make.Assign([shatteredDataclass.fragments4AssignmentOrParameters], value=astCallTargetCallable)))
-	unpack4targetCallable = NodeChanger(ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCall_Identifier(targetCallableIdentifier)), Then.insertThisAbove(shatteredDataclass.listUnpack))
-	repack4targetCallable = NodeChanger(ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCall_Identifier(targetCallableIdentifier)), Then.insertThisBelow([shatteredDataclass.repack]))
+	replaceAssignTargetCallable = NodeChanger(ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCallIdentifier(targetCallableIdentifier)), Then.replaceWith(Make.Assign([shatteredDataclass.fragments4AssignmentOrParameters], value=astCallTargetCallable)))
+	unpack4targetCallable = NodeChanger(ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCallIdentifier(targetCallableIdentifier)), Then.insertThisAbove(shatteredDataclass.listUnpack))
+	repack4targetCallable = NodeChanger(ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCallIdentifier(targetCallableIdentifier)), Then.insertThisBelow([shatteredDataclass.repack]))
 	replaceAssignTargetCallable.visit(ingredientsCaller.astFunctionDef)
 	unpack4targetCallable.visit(ingredientsCaller.astFunctionDef)
 	repack4targetCallable.visit(ingredientsCaller.astFunctionDef)

mapfolding-0.12.2.dist-info/METADATA

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: mapFolding
+Version: 0.12.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
+Project-URL: Donate, https://www.patreon.com/integrated
+Project-URL: Homepage, https://github.com/hunterhogan/mapFolding
+Project-URL: Issues, https://github.com/hunterhogan/mapFolding/issues
+Project-URL: Repository, https://github.com/hunterhogan/mapFolding.git
+Keywords: A000136,A001415,A001416,A001417,A001418,A195646,AST manipulation,Numba optimization,OEIS,algorithmic optimization,code generation,code transformation,combinatorics,computational geometry,dataclass transformation,folding pattern enumeration,just-in-time compilation,map folding,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.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Z0Z_tools
+Requires-Dist: astToolkit>=0.5.0
+Requires-Dist: autoflake
+Requires-Dist: numba
+Requires-Dist: numba_progress
+Requires-Dist: numpy
+Requires-Dist: platformdirs
+Requires-Dist: python_minifier
+Requires-Dist: sympy
+Requires-Dist: tomli
+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"
+Requires-Dist: setuptools-scm; extra == "testing"
+Dynamic: license-file
+
+# mapFolding
+
+[![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/)
+[![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/pythonTests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/pythonTests.yml)
+[![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/)
+
+A computational framework that starts with Lunnon's 1971 algorithm for counting distinct ways to fold maps and improves it. Plus there is a comprehensive AST transformation system for transforming algorithms for optimization and research.
+
+(Yo, the rest is AI generated and I don't have the energy to proofread it. This package helped me compute two previously unknown values: I'm sure others can improve it.)
+
+## The Mathematical Problem
+
+Map folding is a combinatorial problem: given a rectangular grid of unit squares, how many distinct ways can you fold it? "Distinct" means that foldings producing identical final shapes are counted as one. This problem connects to combinatorial geometry, integer sequences, and computational complexity theory.
+
+The calculations extend the Online Encyclopedia of Integer Sequences (OEIS):
+
+- **A001415**: 2×n strips (computed through n=20 for the first time)
+- **A001418**: n×n squares
+- **A001416**: 3×n strips
+- **A001417**: n-dimensional hypercubes
+- **A195646**: 3×3×...×3 hypercubes
+
+```python
+from mapFolding import oeisIDfor_n
+
+# How many ways can you fold a 2×4 strip?
+foldsTotal = oeisIDfor_n('A001415', 4)
+```
+
+## The Computational Challenge
+
+For larger maps, these calculations require hours or days to complete. A 2×20 strip requires processing leaves through billions of recursive operations. The package addresses this through systematic algorithm transformation: converting readable Python implementations into specialized, Numba-optimized modules that achieve order-of-magnitude performance improvements.
+
+## What This Package Provides
+
+### Core Functionality
+
+- **Complete implementation** of Lunnon's recursive algorithm
+- **Mathematical validation** through OEIS integration and caching
+- **Type-safe computational state** management with automatic initialization
+- **Result persistence** for long-running calculations
+
+### Algorithm Transformation System
+
+- **AST manipulation framework** for converting dataclass-based algorithms to optimized implementations
+- **Automatic code generation** that produces standalone, highly optimized computation modules
+- **Dataclass decomposition** to enable Numba compatibility while preserving readable source code
+- **Comprehensive optimization** including dead code elimination, static value embedding, and aggressive compilation settings
+
+### Educational Resources
+
+- **Historical implementations** showing algorithm evolution from 1971 to present
+- **Performance comparison** studies demonstrating optimization techniques
+- **Complete test suite** with patterns for validating custom implementations
+- **Reference documentation** for extending the transformation framework
+
+## Use Cases
+
+**Mathematical Research**: Explore folding pattern properties, extend known sequences, or validate theoretical results against computed values.
+
+**Algorithm Optimization Learning**: Study a complete transformation pipeline that converts high-level algorithms into production-ready optimized code.
+
+**Performance Computing Education**: Examine techniques for achieving maximum Python performance through Numba integration, AST manipulation, and specialized code generation.
+
+**Combinatorial Problem Solving**: Use the framework as a template for optimizing other recursive combinatorial algorithms.
+
+## Example Usage
+
+```python
+from mapFolding import countFolds
+
+# Count folding patterns for a 3×3 square
+result = countFolds([3, 3])
+
+# Access OEIS sequences directly
+from mapFolding import oeisIDfor_n
+strip_foldings = oeisIDfor_n('A001415', 6)  # 2×6 strip
+
+# Generate optimized code for specific dimensions
+from mapFolding.someAssemblyRequired import makeJobTheorem2Numba
+# Creates specialized modules for maximum performance
+```
+
+## Repository Structure
+
+- `mapFolding/`: Core implementation with modular architecture
+- `reference/`: Historical algorithm implementations and performance studies
+- `someAssemblyRequired/`: AST transformation framework
+- `tests/`: Comprehensive validation suite
+- `jobs/`: Generated optimized modules for specific calculations
+
+## Performance Characteristics
+
+- **Pure Python baseline**: Educational implementations for understanding
+- **NumPy optimization**: ~10× improvement through vectorized operations
+- **Numba compilation**: ~100× improvement through native code generation
+- **Specialized modules**: ~1000× improvement through static optimization and embedded constants
+
+Actual performance varies by map dimensions and available hardware.
+
+## 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)
+
+## How to code
+
+Coding One Step at a Time:
+
+0. WRITE CODE.
+1. Don't write stupid code that's hard to revise.
+2. Write good code.
+3. When revising, write better code.
+
+[![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.12.2.dist-info/RECORD

@@ -0,0 +1,53 @@
+mapFolding/__init__.py,sha256=wXJ0dhpZUfiXPvh4RQ11FKDJEzV5OYUs8USKFaEXqQ0,3653
+mapFolding/_theSSOT.py,sha256=JNoyZ86gym5z0DS2kruidDJ3zdYAShuqnCLJ85t2TVM,6168
+mapFolding/basecamp.py,sha256=6jLA_41BB86CJD6E3vLr-SV0BiGEfwzcfeOLgujlyZM,9008
+mapFolding/beDRY.py,sha256=S0HO2bX8afDR6mV0xyIsEGBeG4-pRC3YH9jMAWSHpCM,13891
+mapFolding/daoOfMapFolding.py,sha256=ncTIiBfTsM8SNVx9qefZ0bBcBtviWLSk4iPv3Z9nGiE,5442
+mapFolding/dataBaskets.py,sha256=oO9f0PUf3AdNguaKEYnBpk31VhK8NPFMK5GiBSDVFIw,13101
+mapFolding/datatypes.py,sha256=5BLjUv5S6A_0Q23erRGIN8MMm2WD3BVKnH2gfEdZlcs,5189
+mapFolding/filesystemToolkit.py,sha256=ACiNUE7L5MKjllBbUVvzdgYdILXGiOVyl81fDGPwaNc,10254
+mapFolding/oeis.py,sha256=hf3AgQOiFf2Gs0WbS3JYIVNgfPfVlp0T0ZLDvfvi4Lg,21978
+mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/reference/__init__.py,sha256=GKcSgYE49NcTISx-JZbELXyq-eRkMeTL5g4DXInWFw0,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/lunnonNumpy.py,sha256=mMgrgbrBpe4nmo72ThEI-MGH0OwEHmfMPczSXHp2qKo,4357
+mapFolding/reference/lunnonWhile.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/RecipeJob.py,sha256=kFn27dMWg1k5q5RsU2kw5zXT3TRmUzYHE9EIUdAGvfM,10641
+mapFolding/someAssemblyRequired/__init__.py,sha256=F3MMU6QciBqL8G4cjn_ELCHEnpjytorUQn-vG9t696Q,5769
+mapFolding/someAssemblyRequired/_toolIfThis.py,sha256=mqIZQ_HLkR-5z3_gIghIeQ_WY1XkjVHp9iC1TrPiI9Y,5923
+mapFolding/someAssemblyRequired/_toolkitContainers.py,sha256=ZAwfH6yRunUzSVzl2VZDvJD7lyN7WL6Md7F6Q7suW30,13682
+mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=9RPU6vK_eUg64GtVFI_nZnvUryXw8gfHJs9NyDYHIvg,2745
+mapFolding/someAssemblyRequired/infoBooth.py,sha256=GWiqnHbqk7te_pvVuk4G_gbFa_W2aeSx19w4pakvqfM,2300
+mapFolding/someAssemblyRequired/makeAllModules.py,sha256=RC4FmWyue2reiPttfLEtc7kFGYgp7dR4qBHnOREuYpo,42770
+mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py,sha256=658vw0JZk-9dMIE_18Op8xY1vxwoLc2K-TQaslGtw58,18372
+mapFolding/someAssemblyRequired/toolkitNumba.py,sha256=nHLkGZ9P0p3NJkiqJFTxej9z0H1BvWWvmSN27rTExqU,14563
+mapFolding/someAssemblyRequired/transformationTools.py,sha256=gveR9Gqgo3JJhMXtHIFTyu0RbgwoTkH-5X7dwiA4jpM,11476
+mapFolding/syntheticModules/__init__.py,sha256=evVFqhCGa-WZKDiLcnQWjs-Bj34eRnfSLqz_d7dFYZY,83
+mapFolding/syntheticModules/countParallel.py,sha256=OK_IB9w4yy9MMAiGvkei5ezPm_00v2nYjPrQZ_IlELg,7733
+mapFolding/syntheticModules/daoOfMapFolding.py,sha256=cfWPABtXyCxJ0BwPI7rhfLh_2UYV_XKAL8lJ4GLNXaQ,5896
+mapFolding/syntheticModules/dataPacking.py,sha256=m_eOZ7sMXIQ9jY5EvC3qgitQTY60n6rksy0ACMJOIC8,2292
+mapFolding/syntheticModules/initializeCount.py,sha256=nWSlJMMfIM3DvZxMn6ISQusUJqRYAjKQyLF5hwLEdBQ,3119
+mapFolding/syntheticModules/theorem2.py,sha256=9jrbZNNX4BWYZW1S0JjvRY2k7RU7I1RNUMV7JdCt1ZY,3017
+mapFolding/syntheticModules/theorem2Numba.py,sha256=-cKjNyxgUMFhEyFVs0VJ7hw4LfrV0WSNK5tPYbQ1oNU,3369
+mapFolding/syntheticModules/theorem2Trimmed.py,sha256=DHW3NxBdtABQYBKm2WRvfQ5kzc2_UwGI2h4ePuYEJoM,2685
+mapfolding-0.12.2.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+tests/__init__.py,sha256=5RdiZYAl8nPIM1sxB_D0CsN6J8173LOZ0hpR3geTHAU,1312
+tests/conftest.py,sha256=eBo0IIm98402hl_XW5nT06cUvW25ciItv1_zZdM152E,11126
+tests/test_computations.py,sha256=NDOT1kUdY2w-hbxdGhUsr4N4yFjwJW30AnfrDiYYKM0,5184
+tests/test_filesystem.py,sha256=IXTeyfifXe6vLizCo8BiSn5Yx9DEKYEc_hoJRKhQFNk,3899
+tests/test_oeis.py,sha256=KjG10lH5vVLPG5bicdsVt373QeMrHirFJUpO1BR_sos,6272
+tests/test_other.py,sha256=a42U3KB5IlrQNj63nRyg-KLdvF1QTH2aAsH9JpQnl3Q,4933
+tests/test_tasks.py,sha256=-OrpXAlkPMP4pRCW-wAYPd_olf3L_a9dMsJZCOlSUNE,4041
+mapfolding-0.12.2.dist-info/METADATA,sha256=6URs4ApQHjsH3bN7QniWEvCBioRrz0y0h6q9qI6YI28,7977
+mapfolding-0.12.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mapfolding-0.12.2.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapfolding-0.12.2.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapfolding-0.12.2.dist-info/RECORD,,

{mapfolding-0.12.0.dist-info → mapfolding-0.12.2.dist-info}/WHEEL

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

tests/__init__.py

@@ -1,44 +1,28 @@
-"""
-Map Folding Test Suite and Validation Framework
-
-This test suite provides comprehensive testing capabilities for the mapFolding package
-and its optimization framework. It is specifically designed to enable both package
-maintenance and custom extension testing, making it easy for users to validate their
-own recipe configurations and job implementations.
-
-## Key Testing Capabilities
-
-1. **Algorithm Validation**
-   - Tests core algorithm correctness against known OEIS sequence values
-   - Validates both sequential and parallel execution paths
-   - Ensures consistency across different implementation strategies
-
-2. **Code Generation Testing**
-   - 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
-
-3. **Job-Specific Testing**
-   - Tests specialized job module generation for specific map shapes
-   - Validates execution of the generated modules
-   - Verifies correct output file creation and value storage
-
-## Testing Your Own Implementations
-
-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 assembly lines.
-
-### For Custom Jobs (RecipeJob):
-Copy and adapt the `test_writeJobNumba` function to test specialized job modules
-for specific map shapes with your custom configurations.
-
-The entire test infrastructure is built on fixtures and utilities that handle
-complex setup and validation, allowing you to focus on your implementation details
-while leveraging the existing validation framework.
-
-See the module docstrings in `test_computations.py` and `conftest.py` for detailed
-guidance on adapting these tests for your own purposes.
-"""
+"""Test suite for the mapFolding package.
+
+This test suite provides comprehensive validation of map folding computations,
+file system operations, OEIS integration, task division, and foundational
+utilities. The tests are designed to support multiple audiences and use cases.
+
+Test Module Organization:
+- conftest.py: Testing infrastructure and shared fixtures
+- test_computations.py: Core mathematical validation and algorithm testing
+- test_filesystem.py: File operations and path management
+- test_oeis.py: OEIS sequence integration and caching
+- test_other.py: Foundational utilities and data validation
+- test_tasks.py: Task division and work distribution
+
+For Contributors:
+The test suite follows Domain-Driven Design principles, organizing tests around
+mathematical concepts rather than implementation details. Use the existing
+patterns as templates when adding new functionality.
+
+For Users Adding Custom Modules:
+The test_computations.py module provides the most relevant examples for testing
+custom computational approaches. The standardized testing functions in conftest.py
+ensure consistent error reporting across all tests.
+
+For AI Assistants:
+The testing framework emphasizes readable, predictable patterns that maintain
+mathematical correctness while supporting code evolution and optimization.
+"""