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

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.toolboxNumba import SpicesJobNumba
-	from mapFolding.someAssemblyRequired.synthesizeNumbaJob import makeJobNumba
-	state = makeInitializedComputationState(oneTestCuzTestsOverwritingTests)
+	from mapFolding.someAssemblyRequired.toolkitNumba import SpicesJobNumba
+	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_filesystem.py

@@ -1,6 +1,5 @@
 from contextlib import redirect_stdout
-from mapFolding import validateListDimensions, getPathRootJobDEFAULT, getPathFilenameFoldsTotal, saveFoldsTotal
-from mapFolding.toolboxFilesystem import getFilenameFoldsTotal
+from mapFolding import validateListDimensions, getPathRootJobDEFAULT, getPathFilenameFoldsTotal, saveFoldsTotal, getFilenameFoldsTotal
 from pathlib import Path
 import io
 import pytest

tests/test_other.py

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

tests/test_tasks.py

@@ -1,14 +1,13 @@
 from collections.abc import Callable
-from mapFolding import countFolds
-from mapFolding.beDRY import getTaskDivisions, setProcessorLimit, validateListDimensions, getLeavesTotal
-from mapFolding.oeis import getFoldsTotalKnown
+from mapFolding import countFolds, getTaskDivisions, setProcessorLimit, validateListDimensions, getLeavesTotal, getFoldsTotalKnown
 from tests.conftest import standardizedEqualToCallableReturn
 from typing import Literal
 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/Z0Z_makeSomeModules.py

@@ -1,325 +0,0 @@
-from mapFolding import raiseIfNoneGitHubIssueNumber3, The
-from mapFolding.someAssemblyRequired import (
-	ast_Identifier,
-	astModuleToIngredientsFunction,
-	Be,
-	DOT,
-	extractFunctionDef,
-	Grab,
-	IfThis,
-	IngredientsFunction,
-	IngredientsModule,
-	inlineFunctionDef,
-	LedgerOfImports,
-	Make,
-	NodeChanger,
-	NodeTourist,
-	parseLogicalPath2astModule,
-	parsePathFilename2astModule,
-	removeUnusedParameters,
-	str_nameDOTname,
-	Then,
-	write_astModule,
-)
-from mapFolding.someAssemblyRequired.toolboxNumba import decorateCallableWithNumba, parametersNumbaLight
-from mapFolding.someAssemblyRequired.transformationTools import (
-	removeDataclassFromFunction,
-	shatter_dataclassesDOTdataclass,
-	unpackDataclassCallFunctionRepackDataclass,
-)
-from pathlib import PurePath
-import ast
-
-algorithmSourceModuleHARDCODED = 'daoOfMapFolding'
-sourceCallableIdentifierHARDCODED = 'count'
-logicalPathInfixHARDCODED: ast_Identifier = 'syntheticModules'
-theCountingIdentifierHARDCODED: ast_Identifier = 'groupsOfFolds'
-
-def makeInitializeGroupsOfFolds() -> None:
-	callableIdentifierHARDCODED = 'initializeGroupsOfFolds'
-	moduleIdentifierHARDCODED: ast_Identifier = 'initializeCount'
-
-	algorithmSourceModule = algorithmSourceModuleHARDCODED
-	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
-	logicalPathSourceModule = '.'.join([The.packageName, algorithmSourceModule])
-
-	callableIdentifier = callableIdentifierHARDCODED
-	logicalPathInfix = logicalPathInfixHARDCODED
-	moduleIdentifier = moduleIdentifierHARDCODED
-
-	astModule = parseLogicalPath2astModule(logicalPathSourceModule)
-	countInitializeIngredients = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule)
-		, LedgerOfImports(astModule))
-
-	countInitializeIngredients.astFunctionDef.name = callableIdentifier
-
-	dataclassInstanceIdentifier = NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(countInitializeIngredients.astFunctionDef)
-	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
-	theCountingIdentifier = theCountingIdentifierHARDCODED
-
-	findThis = IfThis.isWhileAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
-	doThat = Grab.testAttribute(Grab.andDoAllOf([ Grab.opsAttribute(Then.replaceWith([ast.Eq()])), Grab.leftAttribute(Grab.attrAttribute(Then.replaceWith(theCountingIdentifier))) ])) # type: ignore
-	NodeChanger(findThis, doThat).visit(countInitializeIngredients.astFunctionDef.body[0])
-
-	ingredientsModule = IngredientsModule(countInitializeIngredients)
-
-	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
-
-	write_astModule(ingredientsModule, pathFilename, The.packageName)
-
-def makeDaoOfMapFolding() -> PurePath:
-	moduleIdentifierHARDCODED: ast_Identifier = 'daoOfMapFolding'
-
-	algorithmSourceModule = algorithmSourceModuleHARDCODED
-	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
-	logicalPathSourceModule = '.'.join([The.packageName, algorithmSourceModule])
-
-	logicalPathInfix = logicalPathInfixHARDCODED
-	moduleIdentifier = moduleIdentifierHARDCODED
-
-	astModule = parseLogicalPath2astModule(logicalPathSourceModule)
-	daoOfMapFolding = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule)
-		, LedgerOfImports(astModule))
-
-	dataclassName: ast.expr | None = NodeTourist(Be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(daoOfMapFolding.astFunctionDef)
-	if dataclassName is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclass_Identifier: ast_Identifier | None = NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
-	if dataclass_Identifier is None: raise raiseIfNoneGitHubIssueNumber3
-
-	dataclassLogicalPathModule = None
-	for moduleWithLogicalPath, listNameTuples in daoOfMapFolding.imports.dictionaryImportFrom.items():
-		for nameTuple in listNameTuples:
-			if nameTuple[0] == dataclass_Identifier:
-				dataclassLogicalPathModule = moduleWithLogicalPath
-				break
-		if dataclassLogicalPathModule:
-			break
-	if dataclassLogicalPathModule is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclassInstanceIdentifier = NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(daoOfMapFolding.astFunctionDef)
-	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
-	shatteredDataclass = shatter_dataclassesDOTdataclass(dataclassLogicalPathModule, dataclass_Identifier, dataclassInstanceIdentifier)
-
-	# theCountingIdentifier = theCountingIdentifierHARDCODED
-	# doubleTheCount = Make.AugAssign(Make.Attribute(ast.Name(dataclassInstanceIdentifier), theCountingIdentifier), ast.Mult(), Make.Constant(2))
-	# findThis = be.Return
-	# doThat = Then.insertThisAbove([doubleTheCount])
-	# NodeChanger(findThis, doThat).visit(daoOfMapFolding.astFunctionDef)
-
-	daoOfMapFolding.imports.update(shatteredDataclass.imports)
-	daoOfMapFolding = removeDataclassFromFunction(daoOfMapFolding, shatteredDataclass)
-
-	daoOfMapFolding = removeUnusedParameters(daoOfMapFolding)
-
-	daoOfMapFolding = decorateCallableWithNumba(daoOfMapFolding, parametersNumbaLight)
-
-	sourceCallableIdentifier = The.sourceCallableDispatcher
-
-	doTheNeedful: IngredientsFunction = astModuleToIngredientsFunction(astModule, sourceCallableIdentifier)
-	doTheNeedful.imports.update(shatteredDataclass.imports)
-	targetCallableIdentifier = daoOfMapFolding.astFunctionDef.name
-	doTheNeedful = unpackDataclassCallFunctionRepackDataclass(doTheNeedful, targetCallableIdentifier, shatteredDataclass)
-	astTuple: ast.Tuple | None = NodeTourist(Be.Return, Then.extractIt(DOT.value)).captureLastMatch(daoOfMapFolding.astFunctionDef)
-	if astTuple is None: raise raiseIfNoneGitHubIssueNumber3
-	astTuple.ctx = ast.Store()
-
-	findThis = IfThis.isAssignAndValueIs(IfThis.isCall_Identifier(targetCallableIdentifier))
-	doThat = Then.replaceWith(Make.Assign([astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts)))
-	changeAssignCallToTarget = NodeChanger(findThis, doThat)
-	changeAssignCallToTarget.visit(doTheNeedful.astFunctionDef)
-
-	ingredientsModule = IngredientsModule([daoOfMapFolding, doTheNeedful])
-	ingredientsModule.removeImportFromModule('numpy')
-
-	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
-
-	write_astModule(ingredientsModule, pathFilename, The.packageName)
-
-	return pathFilename
-
-def makeTheorem2() -> PurePath:
-	moduleIdentifierHARDCODED: ast_Identifier = 'theorem2'
-
-	algorithmSourceModule = algorithmSourceModuleHARDCODED
-	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
-	logicalPathSourceModule = '.'.join([The.packageName, algorithmSourceModule])
-
-	logicalPathInfix = logicalPathInfixHARDCODED
-	moduleIdentifier = moduleIdentifierHARDCODED
-
-	astModule = parseLogicalPath2astModule(logicalPathSourceModule)
-	countTheorem2 = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule)
-		, LedgerOfImports(astModule))
-
-	dataclassInstanceIdentifier = NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(countTheorem2.astFunctionDef)
-	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
-
-	findThis = IfThis.isWhileAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
-	doThat = Grab.testAttribute(Grab.comparatorsAttribute(Then.replaceWith([Make.Constant(4)]))) # type: ignore
-	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
-
-	findThis = IfThis.isIfAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
-	doThat = Then.extractIt(DOT.body)
-	insertLeaf = NodeTourist(findThis, doThat).captureLastMatch(countTheorem2.astFunctionDef)
-	findThis = IfThis.isIfAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
-	doThat = Then.replaceWith(insertLeaf)
-	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
-
-	findThis = IfThis.isAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
-	doThat = Then.removeIt
-	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
-
-	findThis = IfThis.isAttributeNamespace_IdentifierLessThanOrEqual0(dataclassInstanceIdentifier, 'leaf1ndex')
-	doThat = Then.removeIt
-	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
-
-	theCountingIdentifier = theCountingIdentifierHARDCODED
-	doubleTheCount = Make.AugAssign(Make.Attribute(ast.Name(dataclassInstanceIdentifier), theCountingIdentifier), ast.Mult(), Make.Constant(2))
-	findThis = Be.Return
-	doThat = Then.insertThisAbove([doubleTheCount])
-	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
-
-	ingredientsModule = IngredientsModule(countTheorem2)
-
-	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
-
-	write_astModule(ingredientsModule, pathFilename, The.packageName)
-
-	return pathFilename
-
-def trimTheorem2(pathFilenameSource: PurePath) -> PurePath:
-	logicalPathInfix = logicalPathInfixHARDCODED
-	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
-	ingredientsFunction = astModuleToIngredientsFunction(parsePathFilename2astModule(pathFilenameSource), sourceCallableIdentifier)
-
-	dataclassInstanceIdentifier = NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef)
-	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
-
-	findThis = IfThis.isIfUnaryNotAttributeNamespace_Identifier(dataclassInstanceIdentifier, 'dimensionsUnconstrained')
-	doThat = Then.removeIt
-	NodeChanger(findThis, doThat).visit(ingredientsFunction.astFunctionDef)
-
-	ingredientsModule = IngredientsModule(ingredientsFunction)
-	ingredientsModule.removeImportFromModule('numpy')
-
-	pathFilename = pathFilenameSource.with_stem(pathFilenameSource.stem + 'Trimmed')
-
-	write_astModule(ingredientsModule, pathFilename, The.packageName)
-
-	logicalPath: list[str] = []
-	if The.packageName:
-		logicalPath.append(The.packageName)
-	if logicalPathInfix:
-		logicalPath.append(logicalPathInfix)
-	logicalPath.append(pathFilename.stem)
-	moduleWithLogicalPath: str_nameDOTname = '.'.join(logicalPath)
-
-	astImportFrom: ast.ImportFrom = Make.ImportFrom(moduleWithLogicalPath, list_alias=[Make.alias(ingredientsFunction.astFunctionDef.name)])
-
-	return pathFilename
-
-def numbaOnTheorem2(pathFilenameSource: PurePath) -> ast.ImportFrom:
-	logicalPathInfix = logicalPathInfixHARDCODED
-	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
-	countNumbaTheorem2 = astModuleToIngredientsFunction(parsePathFilename2astModule(pathFilenameSource), sourceCallableIdentifier)
-	dataclassName: ast.expr | None = NodeTourist(Be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(countNumbaTheorem2.astFunctionDef)
-	if dataclassName is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclass_Identifier: ast_Identifier | None = NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
-	if dataclass_Identifier is None: raise raiseIfNoneGitHubIssueNumber3
-
-	dataclassLogicalPathModule = None
-	for moduleWithLogicalPath, listNameTuples in countNumbaTheorem2.imports.dictionaryImportFrom.items():
-		for nameTuple in listNameTuples:
-			if nameTuple[0] == dataclass_Identifier:
-				dataclassLogicalPathModule = moduleWithLogicalPath
-				break
-		if dataclassLogicalPathModule:
-			break
-	if dataclassLogicalPathModule is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclassInstanceIdentifier = NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(countNumbaTheorem2.astFunctionDef)
-	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
-	shatteredDataclass = shatter_dataclassesDOTdataclass(dataclassLogicalPathModule, dataclass_Identifier, dataclassInstanceIdentifier)
-
-	countNumbaTheorem2.imports.update(shatteredDataclass.imports)
-	countNumbaTheorem2 = removeDataclassFromFunction(countNumbaTheorem2, shatteredDataclass)
-
-	countNumbaTheorem2 = removeUnusedParameters(countNumbaTheorem2)
-
-	countNumbaTheorem2 = decorateCallableWithNumba(countNumbaTheorem2, parametersNumbaLight)
-
-	ingredientsModule = IngredientsModule(countNumbaTheorem2)
-	ingredientsModule.removeImportFromModule('numpy')
-
-	pathFilename = pathFilenameSource.with_stem(pathFilenameSource.stem.replace('Trimmed', '') + 'Numba')
-
-	write_astModule(ingredientsModule, pathFilename, The.packageName)
-
-	logicalPath: list[str] = []
-	if The.packageName:
-		logicalPath.append(The.packageName)
-	if logicalPathInfix:
-		logicalPath.append(logicalPathInfix)
-	logicalPath.append(pathFilename.stem)
-	moduleWithLogicalPath: str_nameDOTname = '.'.join(logicalPath)
-
-	astImportFrom: ast.ImportFrom = Make.ImportFrom(moduleWithLogicalPath, list_alias=[Make.alias(countNumbaTheorem2.astFunctionDef.name)])
-
-	return astImportFrom
-
-def makeUnRePackDataclass(astImportFrom: ast.ImportFrom) -> None:
-	moduleIdentifierHARDCODED: ast_Identifier = 'dataPacking'
-
-	algorithmSourceModule = algorithmSourceModuleHARDCODED
-	sourceCallableIdentifier = The.sourceCallableDispatcher
-	logicalPathSourceModule = '.'.join([The.packageName, algorithmSourceModule])
-
-	logicalPathInfix = logicalPathInfixHARDCODED
-	moduleIdentifier = moduleIdentifierHARDCODED
-
-	doTheNeedful: IngredientsFunction = astModuleToIngredientsFunction(parseLogicalPath2astModule(logicalPathSourceModule), sourceCallableIdentifier)
-	dataclassName: ast.expr | None = NodeTourist(Be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(doTheNeedful.astFunctionDef)
-	if dataclassName is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclass_Identifier: ast_Identifier | None = NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
-	if dataclass_Identifier is None: raise raiseIfNoneGitHubIssueNumber3
-
-	dataclassLogicalPathModule = None
-	for moduleWithLogicalPath, listNameTuples in doTheNeedful.imports.dictionaryImportFrom.items():
-		for nameTuple in listNameTuples:
-			if nameTuple[0] == dataclass_Identifier:
-				dataclassLogicalPathModule = moduleWithLogicalPath
-				break
-		if dataclassLogicalPathModule:
-			break
-	if dataclassLogicalPathModule is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclassInstanceIdentifier = NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(doTheNeedful.astFunctionDef)
-	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
-	shatteredDataclass = shatter_dataclassesDOTdataclass(dataclassLogicalPathModule, dataclass_Identifier, dataclassInstanceIdentifier)
-
-	doTheNeedful.imports.update(shatteredDataclass.imports)
-	doTheNeedful.imports.addAst(astImportFrom)
-	targetCallableIdentifier = astImportFrom.names[0].name
-	doTheNeedful = unpackDataclassCallFunctionRepackDataclass(doTheNeedful, targetCallableIdentifier, shatteredDataclass)
-	if astImportFrom.module is None: raise raiseIfNoneGitHubIssueNumber3
-	targetFunctionDef = extractFunctionDef(parseLogicalPath2astModule(astImportFrom.module), targetCallableIdentifier)
-	if targetFunctionDef is None: raise raiseIfNoneGitHubIssueNumber3
-	astTuple: ast.Tuple | None = NodeTourist(Be.Return, Then.extractIt(DOT.value)).captureLastMatch(targetFunctionDef)
-	if astTuple is None: raise raiseIfNoneGitHubIssueNumber3
-	astTuple.ctx = ast.Store()
-
-	findThis = IfThis.isAssignAndValueIs(IfThis.isCall_Identifier(targetCallableIdentifier))
-	doThat = Then.replaceWith(Make.Assign([astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts)))
-	NodeChanger(findThis, doThat).visit(doTheNeedful.astFunctionDef)
-
-	ingredientsModule = IngredientsModule(doTheNeedful)
-	ingredientsModule.removeImportFromModule('numpy')
-
-	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
-
-	write_astModule(ingredientsModule, pathFilename, The.packageName)
-
-if __name__ == '__main__':
-	makeInitializeGroupsOfFolds()
-	pathFilename = makeTheorem2()
-	pathFilename = trimTheorem2(pathFilename)
-	astImportFrom = numbaOnTheorem2(pathFilename)
-	makeUnRePackDataclass(astImportFrom)
-	makeDaoOfMapFolding()