mapFolding 0.9.1__py3-none-any.whl → 0.9.3__py3-none-any.whl

mapFolding/theSSOT.py

@@ -1,31 +1,41 @@
 """
 Single Source of Truth module for configuration, types, and computational state management.
 
-This module defines the core data structures, type definitions, and configuration settings
-used throughout the mapFolding package. It implements the Single Source of Truth (SSOT)
-principle to ensure consistency across the package's components.
+This module defines the core data structures, type definitions, and configuration settings used throughout the
+mapFolding package. It implements the Single Source of Truth (SSOT) principle to ensure consistency across the package's
+components.
 
 Key features:
-1. The ComputationState dataclass, which encapsulates the state of the folding computation
-2. Unified type definitions for integers and arrays used in the computation
-3. Configuration settings for synthetic module generation and dispatching
-4. Path resolution and management for package resources and job output
-5. Dynamic dispatch functionality for algorithm implementations
-
-The module differentiates between "the" identifiers (package defaults) and other identifiers
-to avoid namespace collisions when transforming algorithms.
+1. The `ComputationState` dataclass, which encapsulates the state of the folding computation.
+2. Unified type definitions for integers and arrays used in the computation.
+3. Configuration settings for synthetic module generation and dispatching.
+4. Path resolution and management for package resources and job output.
+5. Dynamic dispatch functionality for algorithm implementations.
+
+The module differentiates between "the" identifiers (package defaults) and other identifiers 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, integer, ndarray, uint8 as numpy_uint8
 from pathlib import Path
 from tomli import load as tomli_load
 from types import ModuleType
-from typing import Any, TypeAlias, TypeVar
 import dataclasses
-from numba import int64, uint8
+from mapFolding.datatypes import (
+	Array1DElephino as Array1DElephino,
+	Array1DFoldsTotal as Array1DFoldsTotal,
+	Array1DLeavesTotal as Array1DLeavesTotal,
+	Array3D as Array3D,
+	DatatypeElephino as DatatypeElephino,
+	DatatypeFoldsTotal as DatatypeFoldsTotal,
+	DatatypeLeavesTotal as DatatypeLeavesTotal,
+	NumPyElephino as NumPyElephino,
+	NumPyFoldsTotal as NumPyFoldsTotal,
+	NumPyIntegerType as NumPyIntegerType,
+	NumPyLeavesTotal as NumPyLeavesTotal,
+)
 
 # Evaluate When Packaging https://github.com/hunterhogan/mapFolding/issues/18
 try:
@@ -54,10 +64,9 @@ class PackageSettings:
 	"""
 	Centralized configuration settings for the mapFolding package.
 
-	This class implements the Single Source of Truth (SSOT) principle for package
-	configuration, providing a consistent interface for accessing package settings,
-	paths, and dispatch functions. The primary instance of this class, named `The`,
-	is imported and used throughout the package to retrieve configuration values.
+	This class implements the Single Source of Truth (SSOT) principle for package configuration, providing a consistent
+	interface for accessing package settings, paths, and dispatch functions. The primary instance of this class, named
+	`The`, is imported and used throughout the package to retrieve configuration values.
 	"""
 
 	logicalPathModuleDispatcher: str | None = None
@@ -146,48 +155,20 @@ class PackageSettings:
 
 The = PackageSettings(logicalPathModuleDispatcher=logicalPathModuleDispatcherHARDCODED, callableDispatcher=callableDispatcherHARDCODED, concurrencyPackage=concurrencyPackageHARDCODED)
 
-# =============================================================================
-# Flexible Data Structure System Needs Enhanced Paradigm https://github.com/hunterhogan/mapFolding/issues/9
-
-NumPyIntegerType = TypeVar('NumPyIntegerType', bound=integer[Any], covariant=True)
-
-# DatatypeLeavesTotal: TypeAlias = int
-NumPyLeavesTotal: TypeAlias = numpy_uint8
-# NumPyLeavesTotal: TypeAlias = numpy_int16 # 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
-
-# DatatypeElephino: TypeAlias = int
-NumPyElephino: TypeAlias = numpy_uint8
-# NumPyElephino: TypeAlias = numpy_int16
-
-# DatatypeFoldsTotal: TypeAlias = int
-NumPyFoldsTotal: TypeAlias = numpy_int64
-
-DatatypeLeavesTotal = uint8
-DatatypeElephino = uint8
-DatatypeFoldsTotal = int64
-
-Array3D: TypeAlias = ndarray[tuple[int, int, int], dtype[NumPyLeavesTotal]]
-Array1DLeavesTotal: TypeAlias = ndarray[tuple[int], dtype[NumPyLeavesTotal]]
-Array1DElephino: TypeAlias = ndarray[tuple[int], dtype[NumPyElephino]]
-Array1DFoldsTotal: TypeAlias = ndarray[tuple[int], dtype[NumPyFoldsTotal]]
-
 @dataclasses.dataclass
 class ComputationState:
 	"""
 	Represents the complete state of a map folding computation.
 
-	This dataclass encapsulates all the information required to compute the number of
-	possible ways to fold a map, including the map dimensions, leaf connections,
-	computation progress, and fold counting. It serves as the central data structure
-	that flows through the entire computational algorithm.
+	This dataclass encapsulates all the information required to compute the number of possible ways to fold a map,
+	including the map dimensions, leaf connections, computation progress, and fold counting. It serves as the central
+	data structure that flows through the entire computational algorithm.
 
 	Fields are categorized into:
-	1. Input parameters (mapShape, leavesTotal, etc.)
-	2. Core computational structures (connectionGraph, etc.)
-	3. Tracking variables for the folding algorithm state
-	4. Result accumulation fields (foldsTotal, groupsOfFolds)
-
-	The data structures and algorithms are based on Lunnon's 1971 paper on map folding.
+	1. Input parameters (`mapShape`, `leavesTotal`, etc.).
+	2. Core computational structures (`connectionGraph`, etc.).
+	3. Tracking variables for the folding algorithm state.
+	4. Result accumulation fields (`foldsTotal`, `groupsOfFolds`).
 	"""
 	# NOTE Python is anti-DRY, again, `DatatypeLeavesTotal` metadata needs to match the type
 	mapShape: tuple[DatatypeLeavesTotal, ...] = dataclasses.field(init=True, metadata={'elementConstructor': 'DatatypeLeavesTotal'})
@@ -233,7 +214,7 @@ class ComputationState:
 	foldsTotal: DatatypeFoldsTotal = DatatypeFoldsTotal(0)
 	"""The final computed total number of distinct folding patterns."""
 
-	gap1ndex: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+	gap1ndex: DatatypeElephino = DatatypeElephino(0)
 	"""Current index into gaps array during algorithm execution."""
 
 	gap1ndexCeiling: DatatypeElephino = DatatypeElephino(0)
@@ -254,16 +235,13 @@ class ComputationState:
 	leaf1ndex: DatatypeLeavesTotal = DatatypeLeavesTotal(1)
 	"""Active leaf being processed in the folding algorithm. Starts at 1, not 0."""
 
-	leafConnectee: DatatypeElephino = DatatypeElephino(0)
+	leafConnectee: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
 	"""Leaf that is being connected to the active leaf."""
 
-	# leafSequence: list[DatatypeLeavesTotal] = dataclasses.field(default_factory=list, metadata={'elementConstructor': 'DatatypeLeavesTotal'})
-
 	taskIndex: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
 	"""Index of the current parallel task when using task divisions."""
 
 	def __post_init__(self) -> None:
-		# self.leafSequence = [self.leaf1ndex]
 		from mapFolding.beDRY import getConnectionGraph, makeDataContainer
 		self.dimensionsTotal = DatatypeLeavesTotal(len(self.mapShape))
 		leavesTotalAsInt = int(self.leavesTotal)

mapFolding/toolboxFilesystem.py

@@ -1,20 +1,19 @@
 """
 Filesystem utilities for managing map folding computation results.
 
-This module provides functions for standardized handling of files related to the mapFolding
-package, with a focus on saving, retrieving, and naming computation results. It implements
-consistent naming conventions and path resolution strategies to ensure that:
+This module provides functions for standardized handling of files related to the mapFolding package, with a focus on
+saving, retrieving, and naming computation results. It implements consistent naming conventions and path resolution
+strategies to ensure that:
 
 1. Computation results are stored in a predictable location.
 2. Filenames follow a consistent pattern based on map dimensions.
 3. Results can be reliably retrieved for future reference.
 4. The system handles file operations safely with appropriate error handling.
 
-The module serves as the standardized interface between the computational components
-of the package and the filesystem, abstracting away the details of file operations
-and path management. It provides robust fallback mechanisms to preserve computation
-results even in the face of filesystem errors, which is critical for long-running
-computations that may take days to complete.
+The module serves as the standardized interface between the computational components of the package and the filesystem,
+abstracting away the details of file operations and path management. It provides robust fallback mechanisms to preserve
+computation results even in the face of filesystem errors, which is critical for long-running computations that may take
+days to complete.
 
 The functions here adhere to a consistent approach to path handling:
 - Cross-platform compatibility through the use of `pathlib`.
@@ -33,9 +32,9 @@ def getFilenameFoldsTotal(mapShape: tuple[int, ...]) -> str:
 	"""
 	Create a standardized filename for a computed `foldsTotal` value.
 
-	This function generates a consistent, filesystem-safe filename based on map dimensions.
-	Standardizing filenames ensures that results can be reliably stored and retrieved,
-	avoiding potential filesystem incompatibilities or Python naming restrictions.
+	This function generates a consistent, filesystem-safe filename based on map dimensions. Standardizing filenames
+	ensures that results can be reliably stored and retrieved, avoiding potential filesystem incompatibilities or Python
+	naming restrictions.
 
 	Parameters:
 		mapShape: A sequence of integers representing the dimensions of the map.
@@ -49,7 +48,7 @@ def getFilenameFoldsTotal(mapShape: tuple[int, ...]) -> str:
 		- Safe filesystem characters
 		- Unique extension (.foldsTotal)
 		- Python-safe strings (no starting with numbers, no reserved words)
-		- The 'p' prefix comes from Lunnan's original code.
+		- The 'p' prefix comes from Lunnon's original code.
 	"""
 	return 'p' + 'x'.join(str(dimension) for dimension in sorted(mapShape)) + '.foldsTotal'
 
@@ -57,14 +56,13 @@ def getPathFilenameFoldsTotal(mapShape: tuple[int, ...], pathLikeWriteFoldsTotal
 	"""
 	Get a standardized path and filename for the computed `foldsTotal` value.
 
-	This function resolves paths for storing computation results, handling different
-	input types including directories, absolute paths, or relative paths. It ensures
-	that all parent directories exist in the resulting path.
+	This function resolves paths for storing computation results, handling different input types including directories,
+	absolute paths, or relative paths. It ensures that all parent directories exist in the resulting path.
 
 	Parameters:
 		mapShape: List of dimensions for the map folding problem.
-		pathLikeWriteFoldsTotal (getPathJobRootDEFAULT): Path, filename, or relative path and filename.
-			If None, uses default path. If a directory, appends standardized filename.
+		pathLikeWriteFoldsTotal (getPathJobRootDEFAULT): Path, filename, or relative path and filename. If None, uses
+			default path. If a directory, appends standardized filename.
 
 	Returns:
 		pathFilenameFoldsTotal: Absolute path and filename for storing the `foldsTotal` value.
@@ -91,10 +89,9 @@ def getPathRootJobDEFAULT() -> Path:
 	"""
 	Get the default root directory for map folding computation jobs.
 
-	This function determines the appropriate default directory for storing computation
-	results based on the current runtime environment. It uses platform-specific
-	directories for normal environments and adapts to special environments like
-	Google Colab.
+	This function determines the appropriate default directory for storing computation results based on the current
+	runtime environment. It uses platform-specific directories for normal environments and adapts to special
+	environments like Google Colab.
 
 	Returns:
 		pathJobDEFAULT: Path to the default directory for storing computation results
@@ -112,10 +109,7 @@ def getPathRootJobDEFAULT() -> Path:
 
 def _saveFoldsTotal(pathFilename: PathLike[str] | PurePath, foldsTotal: int) -> None:
 	"""
-	Internal helper function to save a `foldsTotal` value to a file.
-
-	This is a low-level function used by the public `saveFoldsTotal` function.
-	It handles the basic file operation without extensive error handling.
+	Standardized function to save a `foldsTotal` value to a file.
 
 	Parameters:
 		pathFilename: Path where the `foldsTotal` value should be saved
@@ -129,9 +123,8 @@ def saveFoldsTotal(pathFilename: PathLike[str] | PurePath, foldsTotal: int) -> N
 	"""
 	Save `foldsTotal` value to disk with multiple fallback mechanisms.
 
-	This function attempts to save the computed `foldsTotal` value to the specified
-	location, with backup strategies in case the primary save attempt fails.
-	The robustness is critical since these computations may take days to complete.
+	This function attempts to save the computed `foldsTotal` value to the specified location, with backup strategies in
+	case the primary save attempt fails. The robustness is critical since these computations may take days to complete.
 
 	Parameters:
 		pathFilename: Target save location for the `foldsTotal` value
@@ -165,9 +158,8 @@ def saveFoldsTotalFAILearly(pathFilename: PathLike[str] | PurePath) -> None:
 	"""
 	Preemptively test file write capabilities before beginning computation.
 
-	This function performs validation checks on the target file location before
-	a potentially long-running computation begins. It tests several critical
-	aspects of filesystem functionality to ensure results can be saved:
+	This function performs validation checks on the target file location before a potentially long-running computation
+	begins. It tests several critical aspects of filesystem functionality to ensure results can be saved:
 
 	1. Checks if the file already exists to prevent accidental overwrites.
 	2. Verifies that parent directories exist.
@@ -182,8 +174,8 @@ def saveFoldsTotalFAILearly(pathFilename: PathLike[str] | PurePath) -> None:
 		FileNotFoundError: If parent directories don't exist or if write tests fail.
 
 	Notes:
-		This function helps prevent a situation where a computation runs for
-		hours or days only to discover at the end that results cannot be saved.
+		This function helps prevent a situation where a computation runs for hours or days only to discover at the end
+		that results cannot be saved.
 	"""
 	if Path(pathFilename).exists():
 		raise FileExistsError(f"`{pathFilename = }` exists: a battle of overwriting might cause tears.")
@@ -201,17 +193,16 @@ def writeStringToHere(this: str, pathFilename: PathLike[str] | PurePath) -> None
 	"""
 	Write a string to a file, creating parent directories if needed.
 
-	This utility function provides a consistent interface for writing string content
-	to files across the package. It handles path creation and ensures proper
-	string conversion.
+	This utility function provides a consistent interface for writing string content to files across the package. It
+	handles path creation and ensures proper string conversion.
 
 	Parameters:
 		this: The string content to write to the file.
 		pathFilename: The target file path where the string should be written.
 
 	Notes:
-		This function creates all parent directories in the path if they don't exist,
-		making it safe to use with newly created directory structures.
+		This function creates all parent directories in the path if they don't exist, making it safe to use with newly
+		created directory structures.
 	"""
 	pathFilename = Path(pathFilename)
 	pathFilename.parent.mkdir(parents=True, exist_ok=True)

{mapfolding-0.9.1.dist-info → mapfolding-0.9.3.dist-info}/METADATA

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

mapfolding-0.9.3.dist-info/RECORD

@@ -0,0 +1,51 @@
+mapFolding/Z0Z_flowControl.py,sha256=thYz1WA7v0PCigvZcNMcKhNnJoIjLJkVgD4wUTXveGY,3272
+mapFolding/__init__.py,sha256=XbCu7IEPzmIuPRy5iUFKbRbhqTRsie3RemnKVUdACCU,4360
+mapFolding/basecamp.py,sha256=zKqG2lfhaUEicpXjResOrU8zIq3_-3KAFW-DLXATlpc,4749
+mapFolding/beDRY.py,sha256=sTqg_xq3_c4Djer8HRg41ERhDulcl1ZgU4_RMksuv6c,15975
+mapFolding/dataBaskets.py,sha256=CrSEMfAr63l6zFA2v2YGygwSD8YeLb-3ZCKlpbp3Mho,4325
+mapFolding/datatypes.py,sha256=LbDYemnIVLFqMIHPKWutEWId1iPMw6P7XCDm7Uw4it4,912
+mapFolding/oeis.py,sha256=u9xiBrRXVJSFCC8FgLLuvZAsmX852UyjYqREXiulys8,17106
+mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/theDao.py,sha256=kc3rzTX3yts0PxgPCXFbgWvaqsBexsiU5ib2pzpvID0,10019
+mapFolding/theDaoOfMapFolding.py,sha256=ncTIiBfTsM8SNVx9qefZ0bBcBtviWLSk4iPv3Z9nGiE,5442
+mapFolding/theSSOT.py,sha256=rbv8esQeBG6uLWpFZu_ncMA4zIuQG3lj4FZNzC_6JGI,16138
+mapFolding/toolboxFilesystem.py,sha256=kVZoU-NBvfYSvI4R8mEpMXRUZee-1JV0fjtMFWPhk8Y,9818
+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=JL5Xkmp8ritVMhL1pGhX7eEw5fde3FVD8-9-vZOZwWI,5399
+mapFolding/someAssemblyRequired/__init__.py,sha256=W2RdYl78-Z17TiXY8dDOKZIEMeowfhSzMTwfGjwR2k4,4111
+mapFolding/someAssemblyRequired/_theTypes.py,sha256=MS_M4fHLxsHA1JzrPxC2YPnXu--_XAsc_j8VAkyCe5Y,4341
+mapFolding/someAssemblyRequired/_tool_Make.py,sha256=0TGZtCUt6uu8h47N833qZ9IIjbn_yhoPFsBDEotQp9A,7222
+mapFolding/someAssemblyRequired/_tool_Then.py,sha256=0Xb-MfKJhXjoVBTC7CSjpgCxxilL_WquL4WzKQWMR5A,4464
+mapFolding/someAssemblyRequired/_toolboxAntecedents.py,sha256=6m80_ThGF47WWIkYweEdc3LRq96fHklys7IpoFSqN7A,13288
+mapFolding/someAssemblyRequired/_toolboxContainers.py,sha256=qDvmr9GYc5rPYQ5A-lbqqGFBUy3UrA0HOAnfULDE_n0,24303
+mapFolding/someAssemblyRequired/_toolboxPython.py,sha256=TuRC5CD_6tTjjLuvGgPbnqCSvIP3Vp2k2r592Dcpff4,7642
+mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=9RPU6vK_eUg64GtVFI_nZnvUryXw8gfHJs9NyDYHIvg,2745
+mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=yFAGTtKSgv7L87PjPjQMS4wz7Bgs37B1_qqZO8cntQ0,15568
+mapFolding/someAssemblyRequired/toolboxNumba.py,sha256=f2spS6SSobGdDNlpS2ELO7ejurqbMVITS2QZLIXDivk,10759
+mapFolding/someAssemblyRequired/transformationTools.py,sha256=1_qIlrK5a9e5vjRW5vru-v50mkuCmFMaV7lU01cq-ss,35838
+mapFolding/syntheticModules/__init__.py,sha256=evVFqhCGa-WZKDiLcnQWjs-Bj34eRnfSLqz_d7dFYZY,83
+mapFolding/syntheticModules/numbaCount.py,sha256=zM-bp07c9tEDdvidwzZ_bJTd0JC0VUkYEEiHG--P1tQ,15525
+mapfolding-0.9.3.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+tests/__init__.py,sha256=5VhHf0JJ2_DSh58zJ0rR5UkpoCon-0IkdljspTCzZ04,1950
+tests/conftest.py,sha256=x8zMZQyTss3sn0GwHm_TSRwD9_LVlR8l_qF8r43Vxl4,14178
+tests/test_computations.py,sha256=H7AlEAGdl4klAGyeF9z0Gzy2SBtN49xWt4rdftqusnU,6335
+tests/test_filesystem.py,sha256=T2DkjBoI3lW6tCxd5BilPmUFrVukNKLjOOZVZxLM560,3004
+tests/test_oeis.py,sha256=uxvwmgbnylSDdsVJfuAT0LuYLbIVFwSgdLxHm-xUGBM,5043
+tests/test_other.py,sha256=UMlK4JPInalpOZuPvTnUrgXWCJOxAw-OsPs6CxMR254,3753
+tests/test_tasks.py,sha256=tOQc4uomKXGwWnENfbcThaVa1XofwXNCkGZbg4yS6VI,2833
+mapfolding-0.9.3.dist-info/METADATA,sha256=Jv9oPprJ2nb4ECje2fC3-tcRO3FAL0EAi7gZqKeMLzU,7479
+mapfolding-0.9.3.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+mapfolding-0.9.3.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapfolding-0.9.3.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapfolding-0.9.3.dist-info/RECORD,,

{mapfolding-0.9.1.dist-info → mapfolding-0.9.3.dist-info}/WHEEL

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

tests/__init__.py

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

tests/conftest.py

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

tests/test_computations.py

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

tests/test_other.py

@@ -14,20 +14,15 @@ import sys
 	(['a'], ValueError, ValueError),  # string
 	([-4, 2], [-4, 2], ValueError),  # negative
 	([-3], [-3], ValueError),  # negative
-	([0, 0], [0, 0], NotImplementedError),  # no positive dimensions
-	([0, 5, 6], [0, 5, 6], (5, 6)),  # zeros ignored
-	([0], [0], NotImplementedError),  # edge case
 	([1, 2, 3, 4, 5], [1, 2, 3, 4, 5], (1, 2, 3, 4, 5)),  # sequential
 	([1, sys.maxsize], [1, sys.maxsize], (1, sys.maxsize)),  # maxint
 	([7.5], ValueError, ValueError),  # float
 	([1] * 1000, [1] * 1000, (1,) * 1000),  # long list
 	([11], [11], NotImplementedError),  # single dimension
-	([13, 0, 17], [13, 0, 17], (13, 17)),  # zeros handled
 	([2, 2, 2, 2], [2, 2, 2, 2], (2, 2, 2, 2)),  # repeated dimensions
 	([2, 3, 4], [2, 3, 4], (2, 3, 4)),
 	([2, 3], [2, 3], (2, 3)),
 	([2] * 11, [2] * 11, (2,) * 11),  # power of 2
-	([3, 2], [3, 2], (2, 3)),  # return value is sorted
 	([3] * 5, [3] * 5, (3,) * 5),  # power of 3
 	([None], TypeError, TypeError),  # None
 	([True], TypeError, TypeError),  # bool
@@ -36,8 +31,6 @@ import sys
 	([complex(1,1)], ValueError, ValueError),  # complex number
 	([float('inf')], ValueError, ValueError),  # infinity
 	([float('nan')], ValueError, ValueError),  # NaN
-	([sys.maxsize - 1, 1], [sys.maxsize - 1, 1], (1, sys.maxsize - 1)),  # near maxint
-	([sys.maxsize // 2, sys.maxsize // 2, 2], [sys.maxsize // 2, sys.maxsize // 2, 2], (2, sys.maxsize // 2, sys.maxsize // 2)),  # overflow protection
 	([sys.maxsize, sys.maxsize], [sys.maxsize, sys.maxsize], (sys.maxsize, sys.maxsize)),  # overflow protection
 	(range(3, 7), [3, 4, 5, 6], (3, 4, 5, 6)),  # range sequence type
 	(tuple([3, 5, 7]), [3, 5, 7], (3, 5, 7)),  # tuple sequence type

tests/test_tasks.py

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

mapfolding-0.9.1.dist-info/RECORD

@@ -1,47 +0,0 @@
-mapFolding/__init__.py,sha256=TXCWanI9snueVZMTtjLNpvG4um7vyPXmJeIvvrBuJCA,3887
-mapFolding/basecamp.py,sha256=L0eduDE8-5SnEYpnI-GHs-am4ico9kEn75SuOUgibZ8,4770
-mapFolding/beDRY.py,sha256=6E7fLwBK5E7vnI4mHJK6EmxU2Vmxk5d8yBip45uuuyw,15213
-mapFolding/oeis.py,sha256=kVBIYUx4AvGGCqKBvtvSZvq1B6oLPw24wCHNZIOtiTc,17170
-mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mapFolding/theDao.py,sha256=oj-NKxFVsfMUTQomQDK6Xh6GmKbE9gLqMWEyPStzIj0,10022
-mapFolding/theSSOT.py,sha256=fG0WuZrCx77qgJmjZSFLmY03_oQzhh1Xr70-0pNLRe4,17223
-mapFolding/toolboxFilesystem.py,sha256=5RZ9CshZwgjejH_sMG4_Kk4JX3QJLkK30OqFeL5jFWg,9974
-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/RecipeJob.py,sha256=JL5Xkmp8ritVMhL1pGhX7eEw5fde3FVD8-9-vZOZwWI,5399
-mapFolding/someAssemblyRequired/__init__.py,sha256=JLccUsx6FnBn1W2XbaBfVD3KNGmfw0HoO0NwxbzF3uA,4036
-mapFolding/someAssemblyRequired/_theTypes.py,sha256=YFiQI6zsrFNruvqGDXHJVH0OWXsOj9EwDrt4G59OVHA,3995
-mapFolding/someAssemblyRequired/_tool_Make.py,sha256=GQDt6LXGJ1QLVQTGdEu-GJH7y4I2rO60sIBVS5p2Rjk,7384
-mapFolding/someAssemblyRequired/_tool_Then.py,sha256=uc1of9ZPCp5Vrh5Qg80giatGHwT9wRzW3dWaKxGYQsg,4125
-mapFolding/someAssemblyRequired/_toolboxAntecedents.py,sha256=9RWpbKkf90ApmUPckLqJLhjK6Iasq8Txsa9IOYwTbgw,10909
-mapFolding/someAssemblyRequired/_toolboxContainers.py,sha256=-ImBTd0IlgmHwL9VrUarykOeSmmdLOrRiISoel5vizA,23794
-mapFolding/someAssemblyRequired/_toolboxPython.py,sha256=TuRC5CD_6tTjjLuvGgPbnqCSvIP3Vp2k2r592Dcpff4,7642
-mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=9RPU6vK_eUg64GtVFI_nZnvUryXw8gfHJs9NyDYHIvg,2745
-mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=N5rl_YbiK0YTRv3V27tRrrwVxpEbSe6sxZJBMtLNlco,15587
-mapFolding/someAssemblyRequired/toolboxNumba.py,sha256=3Saast4QvugNwluc4CLMfelZG2sKdZO74z_8p2LkG_k,10972
-mapFolding/someAssemblyRequired/transformationTools.py,sha256=M5cDR1_jPOs92XoPd8Mbcxc5fTWW2YwaG4HGcSJQUeY,34238
-mapFolding/syntheticModules/__init__.py,sha256=evVFqhCGa-WZKDiLcnQWjs-Bj34eRnfSLqz_d7dFYZY,83
-mapFolding/syntheticModules/numbaCount.py,sha256=hQPPLKZi99Sayny1Gp3Y9Jv_XLSwozIiUmOrHVaaQ2Q,15768
-mapfolding-0.9.1.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-tests/__init__.py,sha256=UIvSWWz_anRXBELKPOdhfRoZ4hArHQTvghHrRquDHHw,1940
-tests/conftest.py,sha256=G8vhDSTdTbYZUFBUKLFOUOzDL1Ja6NVZmICCh4biZas,14298
-tests/test_computations.py,sha256=MbnK9kRRwH3UI7aVMreNuEbzNVC2hP0Gq2mR-xjuxrI,6205
-tests/test_filesystem.py,sha256=T2DkjBoI3lW6tCxd5BilPmUFrVukNKLjOOZVZxLM560,3004
-tests/test_oeis.py,sha256=uxvwmgbnylSDdsVJfuAT0LuYLbIVFwSgdLxHm-xUGBM,5043
-tests/test_other.py,sha256=zZmSZpcNsk4oeD4EHNLMNtmiz9hnwwoV62DFSQrLKwo,4258
-tests/test_tasks.py,sha256=yrExYvFP23TEA3ta0IotMNmi59rwQ3Y9hA3fwvIhxTE,2851
-mapfolding-0.9.1.dist-info/METADATA,sha256=UQmPj1bF5CjCNrNSwfemNPHz80PPRqKr63EbE5rdMzI,7445
-mapfolding-0.9.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-mapfolding-0.9.1.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapfolding-0.9.1.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapfolding-0.9.1.dist-info/RECORD,,