mapFolding 0.11.2__py3-none-any.whl → 0.11.3__py3-none-any.whl

{mapfolding-0.11.2.dist-info → mapfolding-0.11.3.dist-info}/RECORD

@@ -1,15 +1,13 @@
-mapFolding/__init__.py,sha256=COcJ0Fmrh_d2cDpDjsjEJTAI7kFOxuf2Sw3n5ozADD0,2288
-mapFolding/basecamp.py,sha256=77Bg9W2rRAuYxBKKVvKBw5Ea1HYrPetroSwj4kPT7Wg,8253
-mapFolding/beDRY.py,sha256=J4JFNvJdTz1J1P578DdniOOo5fewpxb5WERuNu19n24,22920
+mapFolding/__init__.py,sha256=5aecz_WZCLtBsArV68h30OEQxrylPPm0oVfQMt0N94A,1948
+mapFolding/basecamp.py,sha256=3MMWSN8eW4W_dZe_q7Vs5yqmazNFoml0VpcJNY2feho,8243
+mapFolding/beDRY.py,sha256=kQrgBhJkXEy-J-Zyu4RHILK6gRm72a7cON7a1LewgwI,14004
 mapFolding/daoOfMapFolding.py,sha256=ncTIiBfTsM8SNVx9qefZ0bBcBtviWLSk4iPv3Z9nGiE,5442
 mapFolding/dataBaskets.py,sha256=crfmmYJGeJ7QLCzuYi4rtVOtzCDRoOiTNfPfHbc6Foo,5620
-mapFolding/datatypes.py,sha256=-TdXqAlEWEwUP_VUb9-X5pvaBBedbZOQbBuu5j1ZoTA,962
+mapFolding/datatypes.py,sha256=dqOAa2RbiGcsRl9X4qo4tdMamgOoZVnewrMjY4mHXS4,773
 mapFolding/filesystemToolkit.py,sha256=O9VQ0tSXlrGUhU3qN7uWxOTAZfuQb3fcRkTrfRZrGXo,9854
-mapFolding/infoBooth.py,sha256=IPEzgb90p30i2mmPsdZ1VHYGmf-xPg_bpoKJDdDEn-k,5586
-mapFolding/oeis.py,sha256=5vNuZSq--Q-rFXtDvLMuoNhh5yLqFZugvXNxy4fs02U,17064
+mapFolding/oeis.py,sha256=ifs9Uu4uqgKCd46aHuCqhyXt2JXLMcPmmWRFuXIBACg,16926
 mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mapFolding/theDao.py,sha256=P-a4xIGwI_40fMWp_ypHRWa6JIFchK59tdTrXiYqTHk,10017
-mapFolding/theSSOT.py,sha256=BVqgXki5qY-d1Kf-AnO2-KeMbMZx805Y0hh8qM7BcxE,1297
+mapFolding/theSSOT.py,sha256=7CyB3FnDWyNovTuUPRvSIfF7GxQc3aZoIsIwF1-4OyE,1456
 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
@@ -22,35 +20,34 @@ mapFolding/reference/total_countPlus1vsPlusN.py,sha256=yJZAVLVdoXqHag2_N6_6CT-Q6
 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=niqbnxgtHk-eR-ph7FBw2S74uEQmx6Xmsh8CPx09q4o,10130
-mapFolding/someAssemblyRequired/Z0Z_makeSomeModules.py,sha256=8OauVDHmS05kYSMgBgvtxlq85nhXhFEtsFN2j1HLhZA,29786
-mapFolding/someAssemblyRequired/__init__.py,sha256=l9KaHEuPwL5WKWHhvaF8LiJshyYcu-3LZTVvWTX804U,3591
-mapFolding/someAssemblyRequired/_toolIfThis.py,sha256=0S0t-BEuFPLw0LDvFIRF3-5yvjgJxkBRTrbOgjSlwrk,3165
-mapFolding/someAssemblyRequired/_toolkitContainers.py,sha256=SSS5kieMgm-vSHRGfUOvxcAWaWGytN9uzaBb0AvF-SM,16086
+mapFolding/someAssemblyRequired/RecipeJob.py,sha256=H53d1pIxh6kvEsh9Nmj7bD8agMBbpHziY2XrN808eGc,4432
+mapFolding/someAssemblyRequired/Z0Z_makeAllModules.py,sha256=7REamiISEiZQ_goseQB2BJW4kMb4wRhoJnqhIRdX_zI,30262
+mapFolding/someAssemblyRequired/__init__.py,sha256=Wq8rrFJzZsQV4oYQmDXSlDtAlU4TRgMc5o0EKJedvGE,2705
+mapFolding/someAssemblyRequired/_toolIfThis.py,sha256=nq7brHOA4JOK9P-RWyOFae6QxzX40nV46DNDrNmkLYo,3122
+mapFolding/someAssemblyRequired/_toolkitContainers.py,sha256=C-GkXSYoneWmcJWULPa5bgLidjjcIFbrEtEpnrK1m_Y,9784
 mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=9RPU6vK_eUg64GtVFI_nZnvUryXw8gfHJs9NyDYHIvg,2745
-mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py,sha256=zWPmosEMt94zl00hDMZ-1t1pkROg8yYAktw_aKvAPjA,13978
-mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=64TZh-AfaToTU-UM_0_pz5DzsvxcnVuUl6j9C1S3zGM,15740
-mapFolding/someAssemblyRequired/toolkitNumba.py,sha256=LZdosArlkNzFUwy8BMhswivW5xfhREAPyx2ApNOuse8,8961
-mapFolding/someAssemblyRequired/transformationTools.py,sha256=hNfYXQQMPsNab_oHdx4G3E5cXYp5-vZaG4LTWtnuwFk,19073
+mapFolding/someAssemblyRequired/infoBooth.py,sha256=IXzpt_YKkWfOOiaQaBh61SiEd-TnLRlHifmq_1mCow4,4249
+mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py,sha256=6bKLNI9po2qS1_JsKr4wnqwY1A5eL5LQN9uLu3jTlkM,14039
+mapFolding/someAssemblyRequired/toolkitNumba.py,sha256=c-rq2rY-Vr0X4asnGy2cmmKTJonv2Jh_mw3oWHT1ctI,6649
+mapFolding/someAssemblyRequired/transformationTools.py,sha256=ysvZaP8XqxXjHtSHlaErNDGHI5OrRRcqVhnzs3F8UUA,8256
 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/numbaCount.py,sha256=HOuCGqykFvYwa-WPkj1qGsZOzJV3ZYxeoZZmIUFY_Wo,13503
 mapFolding/syntheticModules/theorem2.py,sha256=9jrbZNNX4BWYZW1S0JjvRY2k7RU7I1RNUMV7JdCt1ZY,3017
 mapFolding/syntheticModules/theorem2Numba.py,sha256=-cKjNyxgUMFhEyFVs0VJ7hw4LfrV0WSNK5tPYbQ1oNU,3369
 mapFolding/syntheticModules/theorem2Trimmed.py,sha256=DHW3NxBdtABQYBKm2WRvfQ5kzc2_UwGI2h4ePuYEJoM,2685
-mapfolding-0.11.2.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+mapfolding-0.11.3.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
 tests/__init__.py,sha256=5VhHf0JJ2_DSh58zJ0rR5UkpoCon-0IkdljspTCzZ04,1950
-tests/conftest.py,sha256=7zoNA5PLIwm8VY2dLVaZqVDwWG1HQ29IuHTQoAScRF0,14138
-tests/test_computations.py,sha256=ADlT9VDYHyi_QV7XIt2qrHPZkn6O8N7dZ3w4aRZDgFE,6524
+tests/conftest.py,sha256=eumQRoDuWVrhsjDxWXGhW0N7lH0ZZ9XD-5q81bWFqOs,10874
+tests/test_computations.py,sha256=HNpfs9Yz3rdfJInD15Jwd6DYsSR5TCwnR5EW0n7KbeI,5682
 tests/test_filesystem.py,sha256=imlcetleJc4G9pDZTgS1j8UAs7ADbRxXVuNPecJAvqc,2964
 tests/test_oeis.py,sha256=uxvwmgbnylSDdsVJfuAT0LuYLbIVFwSgdLxHm-xUGBM,5043
 tests/test_other.py,sha256=DT7YE82YCHrSjdxhpY4UJnXmZvDm1b4e1QpZV3LyzcM,3747
-tests/test_tasks.py,sha256=-Y6BILdUpWhfxccqiTFt1h_eBfgK8-BLluGOZdaIq8k,2778
-mapfolding-0.11.2.dist-info/METADATA,sha256=VEQE8TJb3nCVzn9JJI6U_0rgQtrmfdHf7YupwPTexcE,7796
-mapfolding-0.11.2.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
-mapfolding-0.11.2.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapfolding-0.11.2.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapfolding-0.11.2.dist-info/RECORD,,
+tests/test_tasks.py,sha256=pEDukf2SVTOMEsn82JpAWKQzn1ZCTlkhLzQ5hYLg2yY,2780
+mapfolding-0.11.3.dist-info/METADATA,sha256=FyB0PTluboy3BsrccAJJGrEhGpo5nUsbd3JJe6CAsXo,7712
+mapfolding-0.11.3.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+mapfolding-0.11.3.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapfolding-0.11.3.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapfolding-0.11.3.dist-info/RECORD,,

{mapfolding-0.11.2.dist-info → mapfolding-0.11.3.dist-info}/WHEEL

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

tests/conftest.py

@@ -56,14 +56,10 @@ See the examples in `test_computations.py` for guidance on adapting these fixtur
 """
 
 from collections.abc import Callable, Generator, Sequence
-from mapFolding import getLeavesTotal, validateListDimensions, makeDataContainer, The
+from mapFolding import getLeavesTotal, validateListDimensions, makeDataContainer
 from mapFolding.oeis import oeisIDsImplemented, settingsOEIS
-from mapFolding.someAssemblyRequired import importLogicalPath2Callable, RecipeSynthesizeFlow
-from pathlib import Path, PurePosixPath
-from types import ModuleType
+from pathlib import Path
 from typing import Any
-import importlib
-import importlib.util
 import numpy
 import pytest
 import random
@@ -238,77 +234,6 @@ def oeisID_1random() -> str:
 	"""Return one random valid OEIS ID."""
 	return random.choice(oeisIDsImplemented)
 
-@pytest.fixture
-def useThisDispatcher() -> Generator[Callable[..., None], Any, None]:
-	"""A fixture providing a context manager for temporarily replacing the dispatcher.
-
-	Returns
-		A context manager for patching the dispatcher
-	"""
-	import mapFolding.infoBooth as infoBooth
-
-	# Store original property method
-	original_dispatcher_property = infoBooth.PackageInformation.dispatcher
-
-	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: infoBooth.PackageInformation) -> Callable[..., Any]:
-			def wrapper(state: Any) -> Any:
-				return callableTarget(state)
-			return wrapper
-
-		# Replace the property with our patched version
-		infoBooth.PackageInformation.dispatcher = property(patched_dispatcher) # type: ignore
-
-	yield patchDispatcher
-
-	# Restore the original property
-	infoBooth.PackageInformation.dispatcher = original_dispatcher_property # type: ignore
-
-def getAlgorithmDispatcher() -> Callable[..., Any]:
-	moduleImported: ModuleType = importlib.import_module(The.logicalPathModuleSourceAlgorithm)
-	dispatcherCallable = getattr(moduleImported, The.sourceCallableDispatcher)
-	return dispatcherCallable
-
-@pytest.fixture
-def useAlgorithmSourceDispatcher(useThisDispatcher: Callable[..., Any]) -> Generator[None, None, None]:
-	"""Temporarily patches getDispatcherCallable to return the algorithm dispatcher."""
-	useThisDispatcher(importLogicalPath2Callable(The.logicalPathModuleSourceAlgorithm, The.sourceCallableDispatcher))
-	yield
-
-@pytest.fixture
-def syntheticDispatcherFixture(useThisDispatcher: Callable[..., Any], pathTmpTesting: Path) -> Callable[..., Any]:
-	"""Generate synthetic Numba-optimized dispatcher module and patch the dispatcher"""
-	from mapFolding.someAssemblyRequired.toolkitNumba import makeNumbaFlow
-
-	TESTINGrecipeFlow = RecipeSynthesizeFlow(
-		pathPackage=PurePosixPath(pathTmpTesting.absolute()),
-		logicalPathFlowRoot=None,
-		moduleDispatcher="test_dispatcher",
-# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
-		# dispatcherCallable="dispatcherSynthetic",
-	)
-
-	# Generate optimized module in test directory
-	makeNumbaFlow(TESTINGrecipeFlow)
-
-	# Import synthesized dispatcher
-	importlibSpecificationDispatcher = importlib.util.spec_from_file_location(
-		TESTINGrecipeFlow.moduleDispatcher,
-		Path(TESTINGrecipeFlow.pathFilenameDispatcher),
-	)
-	if importlibSpecificationDispatcher is None or importlibSpecificationDispatcher.loader is None:
-		raise ImportError("Failed to load synthetic dispatcher module")
-
-	moduleSpecificationDispatcher = importlib.util.module_from_spec(importlibSpecificationDispatcher)
-	importlibSpecificationDispatcher.loader.exec_module(moduleSpecificationDispatcher)
-	callableDispatcherSynthetic = getattr(moduleSpecificationDispatcher, TESTINGrecipeFlow.callableDispatcher)
-
-	# Patch dispatcher and return callable
-	useThisDispatcher(callableDispatcherSynthetic)
-	return callableDispatcherSynthetic
-
 def uniformTestMessage(expected: Any, actual: Any, functionName: str, *arguments: Any) -> str:
 	"""Format assertion message for any test comparison."""
 	return (f"\nTesting: `{functionName}({', '.join(str(parameter) for parameter in arguments)})`\n"

tests/test_computations.py

@@ -85,13 +85,14 @@ All tests leverage standardized utilities like `standardizedEqualToCallableRetur
 that provide consistent, informative error messages and simplify test validation.
 """
 
-from typing import Literal
 from mapFolding import countFolds, getFoldsTotalKnown, oeisIDfor_n
+from mapFolding.dataBaskets import MapFoldingState
 from mapFolding.oeis import settingsOEIS
-from mapFolding.someAssemblyRequired.RecipeJob import RecipeJob
-from mapFolding.someAssemblyRequired.transformationTools import makeInitializedComputationState
+from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2Numba
+from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
 from pathlib import Path, PurePosixPath
 from tests.conftest import standardizedEqualToCallableReturn, registrarRecordsTmpObject
+from typing import Literal
 import importlib.util
 import multiprocessing
 import pytest
@@ -99,41 +100,33 @@ import pytest
 if __name__ == '__main__':
 	multiprocessing.set_start_method('spawn')
 
-def test_algorithmSourceParallel(mapShapeTestParallelization: tuple[int, ...], useAlgorithmSourceDispatcher: None) -> None:
-	standardizedEqualToCallableReturn(getFoldsTotalKnown(mapShapeTestParallelization), countFolds, mapShapeTestParallelization, None, 'maximum', None)
+# TODO test synthesis
 
 @pytest.mark.parametrize('flow', ['daoOfMapFolding', 'theorem2', 'theorem2Trimmed', 'theorem2numba'])
 def test_flowControl(mapShapeTestCountFolds: tuple[int, ...], flow: Literal['daoOfMapFolding'] | Literal['theorem2'] | Literal['theorem2numba']) -> None:
 	standardizedEqualToCallableReturn(getFoldsTotalKnown(mapShapeTestCountFolds), countFolds, None, None, None, None, mapShapeTestCountFolds, None, None, flow)
 
-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, mapShapeTestParallelization: tuple[int, ...]) -> None:
-	standardizedEqualToCallableReturn(getFoldsTotalKnown(mapShapeTestParallelization), countFolds, mapShapeTestParallelization, None, 'maximum')
-
-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: tuple[int, ...], pathFilenameTmpTesting: Path) -> None:
 	from mapFolding.someAssemblyRequired.toolkitNumba import SpicesJobNumba
-	from mapFolding.someAssemblyRequired.synthesizeNumbaJob import makeJobNumba
-	state = makeInitializedComputationState(oneTestCuzTestsOverwritingTests)
+	from mapFolding.someAssemblyRequired.makeJobTheorem2Numba import makeJobNumba
+	mapShape = oneTestCuzTestsOverwritingTests
+	state = MapFoldingState(mapShape)
+	state = initializeGroupsOfFolds(state)
 
 	pathFilenameModule = pathFilenameTmpTesting.absolute()
 	pathFilenameFoldsTotal = pathFilenameModule.with_suffix('.foldsTotalTesting')
 	registrarRecordsTmpObject(pathFilenameFoldsTotal)
 
-	jobTest = RecipeJob(state
+	jobTest = RecipeJobTheorem2Numba(state
 						, pathModule=PurePosixPath(pathFilenameModule.parent)
 						, moduleIdentifier=pathFilenameModule.stem
 						, pathFilenameFoldsTotal=PurePosixPath(pathFilenameFoldsTotal))
-	spices = SpicesJobNumba()
+	spices = SpicesJobNumba(useNumbaProgressBar=False)
 	makeJobNumba(jobTest, spices)
 
 	Don_Lapre_Road_to_Self_Improvement = importlib.util.spec_from_file_location("__main__", pathFilenameModule)

tests/test_tasks.py

@@ -6,7 +6,8 @@ from Z0Z_tools.pytestForYourUse import PytestFor_defineConcurrencyLimit
 import multiprocessing
 import pytest
 
-# When to use multiprocessing.set_start_method https://github.com/hunterhogan/mapFolding/issues/6
+# When to use multiprocessing.set_start_method
+# https://github.com/hunterhogan/mapFolding/issues/6
 if __name__ == '__main__':
 	multiprocessing.set_start_method('spawn')
 

mapFolding/someAssemblyRequired/synthesizeNumbaJob.py

@@ -1,315 +0,0 @@
-"""
-Job-specific Numba Code Generation for Map Folding Calculations
-
-This module specializes in generating highly-optimized, single-purpose Numba modules
-for specific map folding calculation jobs. Unlike the general-purpose transformation
-in toolboxNumba.py, this module creates standalone Python modules optimized for a
-single map shape with statically-encoded parameters.
-
-The code generation assembly line focuses on:
-
-1. Converting function parameters to initialized variables with concrete values.
-2. Replacing dynamic computations with statically-known values.
-3. Eliminating unused code paths and variables.
-4. Adding progress tracking for long-running calculations.
-5. Applying appropriate Numba optimizations for the specific calculation.
-
-This creates extremely fast, specialized implementations that can be run directly
-as Python scripts or further compiled into standalone executables.
-"""
-
-from astToolkit import ClassIsAndAttribute
-from mapFolding import getPathFilenameFoldsTotal, raiseIfNoneGitHubIssueNumber3, The
-from mapFolding.someAssemblyRequired import (
-	ast_Identifier,
-	Be,
-	extractFunctionDef,
-	IfThis,
-	IngredientsFunction,
-	IngredientsModule,
-	LedgerOfImports,
-	Make,
-	NodeChanger,
-	NodeTourist,
-	str_nameDOTname,
-	Then,
-	write_astModule,
-)
-from mapFolding.someAssemblyRequired.RecipeJob import RecipeJob
-from mapFolding.someAssemblyRequired.toolkitNumba import parametersNumbaLight, SpicesJobNumba, decorateCallableWithNumba
-from mapFolding.someAssemblyRequired.transformationTools import dictionaryEstimates, makeInitializedComputationState
-from pathlib import PurePosixPath
-from typing import cast, NamedTuple
-from Z0Z_tools import autoDecodingRLE
-import ast
-"""Synthesize one file to compute `foldsTotal` of `mapShape`."""
-
-list_IdentifiersNotUsedAllHARDCODED = ['concurrencyLimit', 'foldsTotal', 'mapShape',]
-list_IdentifiersNotUsedParallelSequentialHARDCODED = ['indexLeaf']
-list_IdentifiersNotUsedSequentialHARDCODED = ['foldGroups', 'taskDivisions', 'taskIndex',]
-
-list_IdentifiersReplacedHARDCODED = ['groupsOfFolds',]
-
-list_IdentifiersStaticValuesHARDCODED = ['dimensionsTotal', 'leavesTotal',]
-
-list_IdentifiersNotUsedHARDCODED = list_IdentifiersStaticValuesHARDCODED + list_IdentifiersReplacedHARDCODED + list_IdentifiersNotUsedAllHARDCODED + list_IdentifiersNotUsedParallelSequentialHARDCODED + list_IdentifiersNotUsedSequentialHARDCODED
-
-def addLauncherNumbaProgress(ingredientsModule: IngredientsModule, ingredientsFunction: IngredientsFunction, job: RecipeJob, spices: SpicesJobNumba) -> tuple[IngredientsModule, IngredientsFunction]:
-	"""
-	Add progress tracking capabilities to a Numba-optimized function.
-
-	This function modifies both the module and the function to integrate Numba-compatible
-	progress tracking for long-running calculations. It performs several key transformations:
-
-	1. Adds a progress bar parameter to the function signature
-	2. Replaces counting increments with progress bar updates
-	3. Creates a launcher section that displays and updates progress
-	4. Configures file output to save results upon completion
-
-	The progress tracking is particularly important for map folding calculations
-	which can take hours or days to complete, providing visual feedback and
-	estimated completion times.
-
-	Parameters:
-		ingredientsModule: The module where the function is defined.
-		ingredientsFunction: The function to modify with progress tracking.
-		job: Configuration specifying shape details and output paths.
-		spices: Configuration specifying progress bar details.
-
-	Returns:
-		A tuple containing the modified module and function with progress tracking.
-	"""
-	linesLaunch: str = f"""
-if __name__ == '__main__':
-	with ProgressBar(total={job.foldsTotalEstimated}, update_interval=2) as statusUpdate:
-		{job.countCallable}(statusUpdate)
-		foldsTotal = statusUpdate.n * {job.state.leavesTotal}
-		print('\\nmap {job.state.mapShape} =', foldsTotal)
-		writeStream = open('{job.pathFilenameFoldsTotal.as_posix()}', 'w')
-		writeStream.write(str(foldsTotal))
-		writeStream.close()
-"""
-	numba_progressPythonClass: ast_Identifier = 'ProgressBar'
-	numba_progressNumbaType: ast_Identifier = 'ProgressBarType'
-	ingredientsModule.imports.addImportFrom_asStr('numba_progress', numba_progressPythonClass)
-	ingredientsModule.imports.addImportFrom_asStr('numba_progress', numba_progressNumbaType)
-
-	ast_argNumbaProgress = ast.arg(arg=spices.numbaProgressBarIdentifier, annotation=ast.Name(id=numba_progressPythonClass, ctx=ast.Load()))
-	ingredientsFunction.astFunctionDef.args.args.append(ast_argNumbaProgress)
-
-	findThis = ClassIsAndAttribute.targetIs(ast.AugAssign, IfThis.isName_Identifier(job.shatteredDataclass.countingVariableName.id)) # type: ignore
-	doThat = Then.replaceWith(Make.Expr(Make.Call(Make.Attribute(Make.Name(spices.numbaProgressBarIdentifier),'update'),[Make.Constant(1)])))
-	countWithProgressBar = NodeChanger(findThis, doThat)
-	countWithProgressBar.visit(ingredientsFunction.astFunctionDef)
-
-	removeReturnStatement = NodeChanger(Be.Return, Then.removeIt)
-	removeReturnStatement.visit(ingredientsFunction.astFunctionDef)
-	ingredientsFunction.astFunctionDef.returns = Make.Constant(value=None)
-
-	ingredientsModule.appendLauncher(ast.parse(linesLaunch))
-
-	return ingredientsModule, ingredientsFunction
-
-def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: IngredientsFunction, job: RecipeJob) -> IngredientsFunction:
-	"""
-	Convert function parameters into initialized variables with concrete values.
-
-	This function implements a critical transformation that converts function parameters
-	into statically initialized variables in the function body. This enables several
-	optimizations:
-
-	1. Eliminating parameter passing overhead.
-	2. Embedding concrete values directly in the code.
-	3. Allowing Numba to optimize based on known value characteristics.
-	4. Simplifying function signatures for specialized use cases.
-
-	The function handles different data types (scalars, arrays, custom types) appropriately,
-	replacing abstract parameter references with concrete values from the computation state.
-	It also removes unused parameters and variables to eliminate dead code.
-
-	Parameters:
-		ingredientsFunction: The function to transform.
-		job: Recipe containing concrete values for parameters and field metadata.
-
-	Returns:
-		The modified function with parameters converted to initialized variables.
-	"""
-	ingredientsFunction.imports.update(job.shatteredDataclass.imports)
-
-	list_argCuzMyBrainRefusesToThink = ingredientsFunction.astFunctionDef.args.args + ingredientsFunction.astFunctionDef.args.posonlyargs + ingredientsFunction.astFunctionDef.args.kwonlyargs
-	list_arg_arg: list[ast_Identifier] = [ast_arg.arg for ast_arg in list_argCuzMyBrainRefusesToThink]
-	listName: list[ast.Name] = []
-	NodeTourist(Be.Name, Then.appendTo(listName)).visit(ingredientsFunction.astFunctionDef)
-	list_Identifiers: list[ast_Identifier] = [astName.id for astName in listName]
-	list_IdentifiersNotUsed: list[ast_Identifier] = list(set(list_arg_arg) - set(list_Identifiers))
-
-	for ast_arg in list_argCuzMyBrainRefusesToThink:
-		if ast_arg.arg in job.shatteredDataclass.field2AnnAssign:
-			if ast_arg.arg in list_IdentifiersNotUsed:
-				pass
-			else:
-				ImaAnnAssign, elementConstructor = job.shatteredDataclass.Z0Z_field2AnnAssign[ast_arg.arg]
-				match elementConstructor:
-					case 'scalar':
-						cast(ast.Constant, cast(ast.Call, ImaAnnAssign.value).args[0]).value = int(job.state.__dict__[ast_arg.arg])
-					case 'array':
-						dataAsStrRLE: str = autoDecodingRLE(job.state.__dict__[ast_arg.arg], True)
-						dataAs_astExpr: ast.expr = cast(ast.Expr, ast.parse(dataAsStrRLE).body[0]).value
-						cast(ast.Call, ImaAnnAssign.value).args = [dataAs_astExpr]
-					case _:
-						list_exprDOTannotation: list[ast.expr] = []
-						list_exprDOTvalue: list[ast.expr] = []
-						for dimension in job.state.mapShape:
-							list_exprDOTannotation.append(Make.Name(elementConstructor))
-							list_exprDOTvalue.append(Make.Call(Make.Name(elementConstructor), [Make.Constant(dimension)]))
-						cast(ast.Tuple, cast(ast.Subscript, cast(ast.AnnAssign, ImaAnnAssign).annotation).slice).elts = list_exprDOTannotation
-						cast(ast.Tuple, ImaAnnAssign.value).elts = list_exprDOTvalue
-
-				ingredientsFunction.astFunctionDef.body.insert(0, ImaAnnAssign)
-
-			findThis = IfThis.is_arg_Identifier(ast_arg.arg)
-			remove_arg = NodeChanger(findThis, Then.removeIt)
-			remove_arg.visit(ingredientsFunction.astFunctionDef)
-
-	ast.fix_missing_locations(ingredientsFunction.astFunctionDef)
-	return ingredientsFunction
-
-def makeJobNumba(job: RecipeJob, spices: SpicesJobNumba) -> None:
-	"""
-	Generate a highly-optimized, single-purpose Numba module for a specific map shape.
-
-	This function implements the complete transformation assembly line for creating a
-	standalone, specialized implementation for calculating map folding solutions for
-	a specific shape. The process includes:
-
-	1. Extracting the counting function from the source module
-	2. Removing unused code paths based on static analysis
-	3. Replacing dynamic variables with concrete values
-	4. Converting parameters to initialized variables
-	5. Adding progress tracking if requested
-	6. Applying Numba optimizations and type specifications
-	7. Writing the final module to the filesystem
-
-	The resulting Python module is both human-readable and extraordinarily efficient,
-	with all shape-specific optimizations statically encoded. This creates specialized
-	implementations that can be orders of magnitude faster than general-purpose code.
-
-	Parameters:
-		job: Configuration specifying the target shape, paths, and computation state.
-		spices: Configuration specifying Numba and progress tracking options.
-	"""
-	astFunctionDef = extractFunctionDef(job.source_astModule, job.countCallable)
-	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
-	ingredientsCount: IngredientsFunction = IngredientsFunction(astFunctionDef, LedgerOfImports())
-
-	# Remove `foldGroups` and any other unused statements, so you can dynamically determine which variables are not used
-	findThis = IfThis.isAssignAndTargets0Is(IfThis.isSubscript_Identifier('foldGroups'))
-	doThat = Then.removeIt
-	remove_foldGroups = NodeChanger(findThis, doThat)
-	remove_foldGroups.visit(ingredientsCount.astFunctionDef)
-
-	# replace identifiers with static values with their values, so you can dynamically determine which variables are not used
-	list_IdentifiersStaticValues = list_IdentifiersStaticValuesHARDCODED
-	for identifier in list_IdentifiersStaticValues:
-		findThis = IfThis.isName_Identifier(identifier)
-		doThat = Then.replaceWith(Make.Constant(int(job.state.__dict__[identifier])))
-		NodeChanger(findThis, doThat).visit(ingredientsCount.astFunctionDef)
-
-	ingredientsModule = IngredientsModule()
-	# This launcher eliminates the use of one identifier, so run it now and you can dynamically determine which variables are not used
-	if spices.useNumbaProgressBar:
-		ingredientsModule, ingredientsCount = addLauncherNumbaProgress(ingredientsModule, ingredientsCount, job, spices)
-		spices.parametersNumba['nogil'] = True
-	else:
-		linesLaunch: str = f"""
-if __name__ == '__main__':
-	import time
-	timeStart = time.perf_counter()
-	foldsTotal = {job.countCallable}() * {job.state.leavesTotal}
-	print(time.perf_counter() - timeStart)
-	print('\\nmap {job.state.mapShape} =', foldsTotal)
-	writeStream = open('{job.pathFilenameFoldsTotal.as_posix()}', 'w')
-	writeStream.write(str(foldsTotal))
-	writeStream.close()
-"""
-	# from mapFolding.oeis import getFoldsTotalKnown
-	# print(foldsTotal == getFoldsTotalKnown({job.state.mapShape}))
-		ingredientsModule.appendLauncher(ast.parse(linesLaunch))
-		changeReturnParallelCallable = NodeChanger(Be.Return, Then.replaceWith(Make.Return(job.shatteredDataclass.countingVariableName)))
-		changeReturnParallelCallable.visit(ingredientsCount.astFunctionDef)
-		ingredientsCount.astFunctionDef.returns = job.shatteredDataclass.countingVariableAnnotation
-
-	ingredientsCount = move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsCount, job)
-
-	class DatatypeConfig(NamedTuple):
-		Z0Z_module: str_nameDOTname
-		fml: ast_Identifier
-		Z0Z_type_name: ast_Identifier
-		Z0Z_asname: ast_Identifier | None = None
-
-	listDatatypeConfigs = [
-		DatatypeConfig(fml='DatatypeLeavesTotal', Z0Z_module='numba', Z0Z_type_name='uint8'),
-		DatatypeConfig(fml='DatatypeElephino', Z0Z_module='numba', Z0Z_type_name='uint16'),
-		DatatypeConfig(fml='DatatypeFoldsTotal', Z0Z_module='numba', Z0Z_type_name='uint64'),
-	]
-
-	for datatypeConfig in listDatatypeConfigs:
-		ingredientsModule.imports.addImportFrom_asStr(datatypeConfig.Z0Z_module, datatypeConfig.Z0Z_type_name)
-		statement = Make.Assign(
-			[Make.Name(datatypeConfig.fml, ast.Store())],
-			Make.Name(datatypeConfig.Z0Z_type_name)
-		)
-		ingredientsModule.appendPrologue(statement=statement)
-
-	ingredientsCount.imports.removeImportFromModule('mapFolding.theSSOT')
-
-	listNumPyTypeConfigs = [
-		DatatypeConfig(fml='Array1DLeavesTotal', Z0Z_module='numpy', Z0Z_type_name='uint8', Z0Z_asname='Array1DLeavesTotal'),
-		DatatypeConfig(fml='Array1DElephino', Z0Z_module='numpy', Z0Z_type_name='uint16', Z0Z_asname='Array1DElephino'),
-		DatatypeConfig(fml='Array3D', Z0Z_module='numpy', Z0Z_type_name='uint8', Z0Z_asname='Array3D'),
-	]
-
-	for typeConfig in listNumPyTypeConfigs:
-		ingredientsCount.imports.removeImportFrom(typeConfig.Z0Z_module, None, typeConfig.fml)
-		ingredientsCount.imports.addImportFrom_asStr(typeConfig.Z0Z_module, typeConfig.Z0Z_type_name, typeConfig.Z0Z_asname)
-
-	ingredientsCount.astFunctionDef.decorator_list = [] # TODO low-priority, handle this more elegantly
-	# TODO when I add the function signature in numba style back to the decorator, the logic needs to handle `ProgressBarType:`
-	ingredientsCount = decorateCallableWithNumba(ingredientsCount, spices.parametersNumba)
-
-	ingredientsModule.appendIngredientsFunction(ingredientsCount)
-	write_astModule(ingredientsModule, job.pathFilenameModule, job.packageIdentifier)
-
-	"""
-	Overview
-	- the code starts life in theDao.py, which has many optimizations;
-		- `makeNumbaOptimizedFlow` increase optimization especially by using numba;
-		- `makeJobNumba` increases optimization especially by limiting its capabilities to just one set of parameters
-	- the synthesized module must run well as a standalone interpreted-Python script
-	- the next major optimization step will (probably) be to use the module synthesized by `makeJobNumba` to compile a standalone executable
-	- Nevertheless, at each major optimization step, the code is constantly being improved and optimized, so everything must be well organized (read: semantic) and able to handle a range of arbitrary upstream and not disrupt downstream transformations
-
-	Necessary
-	- Move the function's parameters to the function body,
-	- initialize identifiers with their state types and values,
-
-	Optimizations
-	- replace static-valued identifiers with their values
-	- narrowly focused imports
-
-	Minutia
-	- do not use `with` statement inside numba jitted code, except to use numba's obj mode
-	"""
-
-if __name__ == '__main__':
-	mapShape = (1,46)
-	state = makeInitializedComputationState(mapShape)
-	# foldsTotalEstimated = getFoldsTotalKnown(state.mapShape) // state.leavesTotal
-	# foldsTotalEstimated = dictionaryEstimates[state.mapShape] // state.leavesTotal
-	foldsTotalEstimated = 0
-	pathModule = PurePosixPath(The.pathPackage, 'jobs')
-	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
-	aJob = RecipeJob(state, foldsTotalEstimated, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
-	spices = SpicesJobNumba(useNumbaProgressBar=False, parametersNumba=parametersNumbaLight)
-	# spices = SpicesJobNumba()
-	makeJobNumba(aJob, spices)