mapFolding 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

mapfolding-0.8.0.dist-info/RECORD

@@ -0,0 +1,41 @@
+mapFolding/__init__.py,sha256=hONqdWnBN1ebgrKZuMIZfI8m-1krSR66L4GTVRwBmw4,203
+mapFolding/basecamp.py,sha256=Ik_oH-MpH8f6k-yBzwm99lfkv3pMDgFFEnSSDyiJjsQ,3861
+mapFolding/beDRY.py,sha256=nn0AEGzrroM3wp91Fts7mmx1VQgG14s0EZsXR-Uy5x8,9049
+mapFolding/filesystem.py,sha256=KqgsO-jaSWAlYib_9ovoXQY76PcQri09_73u0OqMWC8,4094
+mapFolding/noHomeYet.py,sha256=DAppmTJG95Ip1qF1uVLU_vXGz4Lmonp8OYfGXtmOnTE,785
+mapFolding/oeis.py,sha256=ZNt3UBklmpfjdmgbA7pO-ezz2prafr2JvdkpIDapi1w,11853
+mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/theDao.py,sha256=E-hisOy_1_iQqS6w4c7S-C-sIgIcwnAPFqooeWuinVY,9008
+mapFolding/theSSOT.py,sha256=r7_9t0dOo_IfBMqmkm1WXOzMfZjyPNco0hl1g9uU_2Y,12710
+mapFolding/reference/flattened.py,sha256=S6D9wiFTlbeoetEqaMLOcA-R22BHOzjqPRujffNxxUM,14875
+mapFolding/reference/hunterNumba.py,sha256=jDS0ORHkIhcJ1rzA5hT49sZHKf3rgJOoGesUCcbKFFY,6054
+mapFolding/reference/irvineJavaPort.py,sha256=7GvBU0tnS6wpFgkYad3465do9jBQW-2bYvbCYyABPHM,3341
+mapFolding/reference/jax.py,sha256=7ji9YWia6Kof0cjcNdiS1GG1rMbC5SBjcyVr_07AeUk,13845
+mapFolding/reference/lunnan.py,sha256=iAbJELfW6RKNMdPcBY9b6rGQ-z1zoRf-1XCurCRMOo8,3951
+mapFolding/reference/lunnanNumpy.py,sha256=rwVP3WIDXimpAuaxhRIuBYU56nVDTKlfGiclw_FkgUU,3765
+mapFolding/reference/lunnanWhile.py,sha256=uRrMT23jTJvoQDlD_FzeIQe_pfMXJG6_bRvs7uhC8z0,3271
+mapFolding/reference/rotatedEntryPoint.py,sha256=USZY3n3zwhSE68ATscUuN66t1qShuEbMI790Gz9JFTw,9352
+mapFolding/reference/total_countPlus1vsPlusN.py,sha256=wpgay-uqPOBd64Z4Pg6tg40j7-4pzWHGMM6v0bnmjhE,6288
+mapFolding/someAssemblyRequired/Z0Z_workbench.py,sha256=g4VkNKp2ts0koqcMSPNbE_ySR2-23Y-5CJBDpvbT6XU,16853
+mapFolding/someAssemblyRequired/__init__.py,sha256=G1uIo1RWcdBjeFPXFwa69kizsZFzkDR55B2uyyY5z7E,680
+mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=2kGRji3FGaALZwUZ6qlEjS7QxOkJK1Si-mAnsWePs_Q,983
+mapFolding/someAssemblyRequired/ingredientsNumba.py,sha256=u5621TzZW7Sp8BXedq0yooyYoFwDDsd9smoqObzRf8g,7359
+mapFolding/someAssemblyRequired/synthesizeDataConverters.py,sha256=J1qLKxqCMQd5JhcrTg9fvpPCfhb5TLz2wXY-J9z-TH8,5792
+mapFolding/someAssemblyRequired/synthesizeNumbaJobVESTIGIAL.py,sha256=3yRCEMIf9UCswu6wQvdUK9H3MW6Ossn-wg5eOq8LWz8,22362
+mapFolding/someAssemblyRequired/transformationTools.py,sha256=u2ah47kOqvVGKifuk7rZe4bSm3Z681nJzp73IXavYw4,36297
+mapFolding/syntheticModules/numbaCountHistoricalExample.py,sha256=Oo0Xeex89sLD15iRt3N76OKRFScKl9qwO84-d5sv6lM,11871
+mapFolding/syntheticModules/numbaCount_doTheNeedful.py,sha256=52RuwJVH2fROvWU2dT8wYcQvLgRuvkNZPq01kujCC_U,15725
+mapFolding/syntheticModules/numba_doTheNeedfulHistoricalExample.py,sha256=J9wZ9PW5EVduOQWVze7CgpTHkUjRIvBPG8fNuT3IVpA,1145
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/conftest.py,sha256=rRlXOhihwheHyQ8ggjRBbmgPVERxWjupajguVBzBkVE,10783
+tests/test_computations.py,sha256=YhadlskBh_r5RiefHRy0FlrYQ0FelYbqcSNNSkSJMIY,3368
+tests/test_filesystem.py,sha256=Kou0gj5T72oISao6umYfU6L_W5Hi7QS9_IxTv2hU0Pw,3147
+tests/test_oeis.py,sha256=uxvwmgbnylSDdsVJfuAT0LuYLbIVFwSgdLxHm-xUGBM,5043
+tests/test_other.py,sha256=1uuApByNWPiTf0zaro2dETkvyWQFfMweU_ge4aJuVgM,4244
+tests/test_tasks.py,sha256=hkZygihT8bCEO2zc-2VcxReQrZJBwgLNbYx0YP4lTDg,2853
+mapfolding-0.8.0.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+mapfolding-0.8.0.dist-info/METADATA,sha256=AA0b9jY45EztgHbZQq8SbpBExcDpnmhotXZB4DDO_2A,7670
+mapfolding-0.8.0.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+mapfolding-0.8.0.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapfolding-0.8.0.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapfolding-0.8.0.dist-info/RECORD,,

{mapfolding-0.7.0.dist-info → mapfolding-0.8.0.dist-info}/WHEEL

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

tests/conftest.py

@@ -1,5 +1,5 @@
 from collections.abc import Callable, Generator, Sequence
-from mapFolding.theSSOT import getAlgorithmDispatcher, getSourceAlgorithm, getPackageDispatcher, theModuleOfSyntheticModules, FREAKOUT
+from mapFolding.theSSOT import getAlgorithmDispatcher, getSourceAlgorithm, getPackageDispatcher, theModuleOfSyntheticModules, raiseIfNoneGitHubIssueNumber3
 from mapFolding.beDRY import getLeavesTotal, validateListDimensions, makeDataContainer
 from mapFolding.oeis import oeisIDsImplemented, settingsOEIS
 from pathlib import Path
@@ -10,7 +10,6 @@ import random
 import shutil
 import unittest.mock
 import uuid
-# TODO learn how to run tests and coverage analysis without `env = ["NUMBA_DISABLE_JIT=1"]`
 
 # SSOT for test data paths and filenames
 pathDataSamples = Path("tests/dataSamples")
@@ -215,7 +214,7 @@ def syntheticDispatcherFixture(useThisDispatcher: Callable[..., Any]) -> Callabl
 			dispatcherSynthetic = stuff
 
 	if dispatcherSynthetic is None:
-		raise FREAKOUT
+		raise raiseIfNoneGitHubIssueNumber3
 
 	dispatcherSpec = importlib.util.spec_from_file_location(dispatcherSynthetic.callableSynthesized, dispatcherSynthetic.pathFilenameForMe)
 	if dispatcherSpec is None:

tests/test_computations.py

@@ -3,16 +3,20 @@ from mapFolding.filesystem import getPathFilenameFoldsTotal
 from mapFolding.noHomeYet import getFoldsTotalKnown
 from mapFolding.oeis import settingsOEIS, oeisIDfor_n
 # from mapFolding.someAssemblyRequired import writeJobNumba
+from pathlib import Path
 from tests.conftest import standardizedEqualToCallableReturn, registrarRecordsTmpObject
+from types import ModuleType
 import importlib.util
+import multiprocessing
 import pytest
-from pathlib import Path
-from types import ModuleType
 
-def test_algorithmSourceParallel(listDimensionsTestParallelization, useAlgorithmSourceDispatcher: None) -> None:
-    standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestParallelization)), countFolds, listDimensionsTestParallelization, None, 'maximum')
+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_algorithmSourceSequential(listDimensionsTestCountFolds, useAlgorithmSourceDispatcher: None) -> None:
+def test_algorithmSourceSequential(listDimensionsTestCountFolds: tuple[int, ...], useAlgorithmSourceDispatcher: None) -> None:
     standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestCountFolds)), countFolds, listDimensionsTestCountFolds)
 
 def test_aOFn_calculate_value(oeisID: str) -> None:

tests/test_filesystem.py

@@ -3,9 +3,7 @@ from mapFolding.filesystem import getFilenameFoldsTotal, getPathFilenameFoldsTot
 from mapFolding.beDRY import validateListDimensions
 from mapFolding.theSSOT import getPathJobRootDEFAULT
 from pathlib import Path
-from typing import Any
 import io
-import numpy
 import pytest
 import unittest.mock
 

tests/test_other.py

@@ -42,8 +42,8 @@ import sys
 	(tuple([3, 5, 7]), [3, 5, 7], (3, 5, 7)),  # tuple sequence type
 ])
 def test_listDimensionsAsParameter(listDimensions: None | list[str] | list[int] | list[float] | list[None] | list[bool] | list[list[int]] | list[complex] | range | tuple[int, ...],
-							   expected_intInnit: type[ValueError] | list[int] | type[TypeError],
-							   expected_validateListDimensions: type[ValueError] | type[NotImplementedError] | tuple[int, ...] | type[TypeError]) -> None:
+							expected_intInnit: type[ValueError] | list[int] | type[TypeError],
+							expected_validateListDimensions: type[ValueError] | type[NotImplementedError] | tuple[int, ...] | type[TypeError]) -> None:
 	"""Test both validateListDimensions and getLeavesTotal with the same inputs."""
 	standardizedEqualToCallableReturn(expected_intInnit, intInnit, listDimensions)
 	standardizedEqualToCallableReturn(expected_validateListDimensions, validateListDimensions, listDimensions)
@@ -56,7 +56,6 @@ def test_getLeavesTotal_edge_cases() -> None:
 	# Input preservation
 	mapShape = (2, 3)
 	standardizedEqualToCallableReturn(6, getLeavesTotal, mapShape)
-	# Remove the lambda entirely for a simpler approach
 	assert mapShape == (2, 3), "Input tuple was modified"
 
 @pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_intInnit())

tests/test_tasks.py

@@ -1,20 +1,22 @@
-from typing import Literal
+from collections.abc import Callable
 from mapFolding.basecamp import countFolds
 from mapFolding.beDRY import getTaskDivisions, setCPUlimit, validateListDimensions, getLeavesTotal
 from mapFolding.noHomeYet import getFoldsTotalKnown
 from tests.conftest import standardizedEqualToCallableReturn
+from typing import Literal
 from Z0Z_tools.pytestForYourUse import PytestFor_defineConcurrencyLimit
-from collections.abc import Callable
+import multiprocessing
 import pytest
 
-# TODO add a test. `C` = number of logical cores available. `n = C + 1`. Ensure that `[2,n]` is computed correctly.
-# Or, probably smarter: limit the number of cores, then run a test with C+1.
+# When to use multiprocessing.set_start_method https://github.com/hunterhogan/mapFolding/issues/6
+if __name__ == '__main__':
+	multiprocessing.set_start_method('spawn')
 
 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')
+	standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestParallelization)), countFolds, listDimensionsTestParallelization, None, 'maximum', None)
 
 @pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_defineConcurrencyLimit())
 def test_defineConcurrencyLimit(nameOfTest: str, callablePytest: Callable[[], None]) -> None:

mapFolding/someAssemblyRequired/synthesizeCountingFunctions.py

@@ -1,7 +0,0 @@
-from mapFolding.someAssemblyRequired import IngredientsFunction, Make
-from typing import cast
-from types import ModuleType
-import ast
-
-def Z0Z_makeCountingFunction(callableTarget: str, sourceAlgorithm: ModuleType, inline: bool, dataclass: bool):
-	pass

mapFolding/someAssemblyRequired/synthesizeNumba.py

@@ -1,91 +0,0 @@
-from collections.abc import Sequence
-from mapFolding.someAssemblyRequired.whatWillBe import LedgerOfImports, ParametersNumba, Z0Z_getDatatypeModuleScalar, parametersNumbaDEFAULT
-from mapFolding.someAssemblyRequired.whatWillBe import Z0Z_getDecoratorCallable
-from mapFolding.someAssemblyRequired import Make, ifThis
-from typing import Any, cast
-import ast
-
-def thisIsNumbaDotJit(Ima: ast.AST) -> bool:
-	return ifThis.isCallNamespace_Identifier(Z0Z_getDatatypeModuleScalar(), Z0Z_getDecoratorCallable())(Ima)
-
-def thisIsJit(Ima: ast.AST) -> bool:
-	return ifThis.isCall_Identifier(Z0Z_getDecoratorCallable())(Ima)
-
-def thisIsAnyNumbaJitDecorator(Ima: ast.AST) -> bool:
-	return thisIsNumbaDotJit(Ima) or thisIsJit(Ima)
-
-def decorateCallableWithNumba(FunctionDefTarget: ast.FunctionDef, allImports: LedgerOfImports, parametersNumba: ParametersNumba | None = None) -> tuple[ast.FunctionDef, LedgerOfImports]:
-	def Z0Z_UnhandledDecorators(astCallable: ast.FunctionDef) -> ast.FunctionDef:
-		# TODO: more explicit handling of decorators. I'm able to ignore this because I know `algorithmSource` doesn't have any decorators.
-		for decoratorItem in astCallable.decorator_list.copy():
-			import warnings
-			astCallable.decorator_list.remove(decoratorItem)
-			warnings.warn(f"Removed decorator {ast.unparse(decoratorItem)} from {astCallable.name}")
-		return astCallable
-
-	def make_arg4parameter(signatureElement: ast.arg) -> ast.Subscript | ast.Name | None:
-		if isinstance(signatureElement.annotation, ast.Subscript) and isinstance(signatureElement.annotation.slice, ast.Tuple):
-			annotationShape: ast.expr = signatureElement.annotation.slice.elts[0]
-			if isinstance(annotationShape, ast.Subscript) and isinstance(annotationShape.slice, ast.Tuple):
-				shapeAsListSlices: list[ast.Slice] = [ast.Slice() for _axis in range(len(annotationShape.slice.elts))]
-				shapeAsListSlices[-1] = ast.Slice(step=ast.Constant(value=1))
-				shapeAST: ast.Slice | ast.Tuple = ast.Tuple(elts=list(shapeAsListSlices), ctx=ast.Load())
-			else:
-				shapeAST = ast.Slice(step=ast.Constant(value=1))
-
-			annotationDtype: ast.expr = signatureElement.annotation.slice.elts[1]
-			if (isinstance(annotationDtype, ast.Subscript) and isinstance(annotationDtype.slice, ast.Attribute)):
-				datatypeAST = annotationDtype.slice.attr
-			else:
-				datatypeAST = None
-
-			ndarrayName = signatureElement.arg
-			Z0Z_hacky_dtype: str = ndarrayName
-			datatype_attr = datatypeAST or Z0Z_hacky_dtype
-			allImports.addImportFromStr(datatypeModuleDecorator, datatype_attr)
-			datatypeNumba = ast.Name(id=datatype_attr, ctx=ast.Load())
-
-			return ast.Subscript(value=datatypeNumba, slice=shapeAST, ctx=ast.Load())
-
-		elif isinstance(signatureElement.annotation, ast.Name):
-			return signatureElement.annotation
-		return None
-
-	datatypeModuleDecorator: str = Z0Z_getDatatypeModuleScalar()
-	list_argsDecorator: Sequence[ast.expr] = []
-
-	list_arg4signature_or_function: list[ast.expr] = []
-	for parameter in FunctionDefTarget.args.args:
-		signatureElement: ast.Subscript | ast.Name | None = make_arg4parameter(parameter)
-		if signatureElement:
-			list_arg4signature_or_function.append(signatureElement)
-
-	if FunctionDefTarget.returns and isinstance(FunctionDefTarget.returns, ast.Name):
-		theReturn: ast.Name = FunctionDefTarget.returns
-		list_argsDecorator = [cast(ast.expr, ast.Call(func=ast.Name(id=theReturn.id, ctx=ast.Load())
-							, args=list_arg4signature_or_function if list_arg4signature_or_function else [], keywords=[] ) )]
-	elif list_arg4signature_or_function:
-		list_argsDecorator = [cast(ast.expr, ast.Tuple(elts=list_arg4signature_or_function, ctx=ast.Load()))]
-
-	for decorator in FunctionDefTarget.decorator_list.copy():
-		if thisIsAnyNumbaJitDecorator(decorator):
-			decorator = cast(ast.Call, decorator)
-			if parametersNumba is None:
-				parametersNumbaSherpa: dict[str, Any] = Make.copy_astCallKeywords(decorator)
-				if (_HunterIsSureThereAreBetterWaysToDoThis := True):
-					if parametersNumbaSherpa:
-						parametersNumba = cast(ParametersNumba, parametersNumbaSherpa)
-		FunctionDefTarget.decorator_list.remove(decorator)
-
-	FunctionDefTarget = Z0Z_UnhandledDecorators(FunctionDefTarget)
-	if parametersNumba is None:
-		parametersNumba = parametersNumbaDEFAULT
-	listDecoratorKeywords: list[ast.keyword] = [ast.keyword(arg=parameterName, value=ast.Constant(value=parameterValue)) for parameterName, parameterValue in parametersNumba.items()]
-
-	decoratorModule: str = Z0Z_getDatatypeModuleScalar()
-	decoratorCallable: str = Z0Z_getDecoratorCallable()
-	allImports.addImportFromStr(decoratorModule, decoratorCallable)
-	astDecorator: ast.Call = Make.astCall(Make.astName(decoratorCallable), list_argsDecorator, listDecoratorKeywords)
-
-	FunctionDefTarget.decorator_list = [astDecorator]
-	return FunctionDefTarget, allImports

mapFolding/someAssemblyRequired/synthesizeNumbaModules.py

@@ -1,91 +0,0 @@
-# pyright: basic
-from os import PathLike
-from typing import TYPE_CHECKING
-if TYPE_CHECKING:
-	from mapFolding.someAssemblyRequired.whatWillBe import ParametersSynthesizeNumbaCallable, listNumbaCallableDispatchees
-from mapFolding.theSSOT import theModuleOfSyntheticModules
-from mapFolding.theSSOT import getSourceAlgorithm
-import types
-
-def makeFlowNumbaOptimized(listCallablesInline: list[ParametersSynthesizeNumbaCallable] = listNumbaCallableDispatchees, callableDispatcher: bool = True, algorithmSource: types.ModuleType = getSourceAlgorithm(), relativePathWrite: str | PathLike[str] = theModuleOfSyntheticModules, filenameModuleWrite: str = 'filenameModuleSyntheticWrite', formatFilenameWrite: str = 'formatStrFilenameForCallableSynthetic'):
-	from mapFolding.someAssemblyRequired.whatWillBe import ParametersSynthesizeNumbaCallable, listNumbaCallableDispatchees
-	from mapFolding.someAssemblyRequired.whatWillBe import LedgerOfImports, Z0Z_autoflake_additional_imports
-	from mapFolding.theSSOT import FREAKOUT
-	from mapFolding.theSSOT import thePathPackage, getDatatypePackage
-	from mapFolding.someAssemblyRequired.whatWillBe import FunctionInliner, YouOughtaKnow, ast_Identifier
-	from pathlib import Path
-	from typing import cast
-	import ast
-	import autoflake
-	import inspect
-	import warnings
-	if relativePathWrite and Path(relativePathWrite).is_absolute():
-		raise ValueError("The path to write the module must be relative to the root of the package.")
-
-	listStuffYouOughtaKnow: list[YouOughtaKnow] = []
-
-	listFunctionDefs: list[ast.FunctionDef] = []
-	allImportsModule = LedgerOfImports()
-	for tupleParameters in listCallablesInline:
-		pythonSource: str = inspect.getsource(algorithmSource)
-		astModule: ast.Module = ast.parse(pythonSource)
-		if allImports is None:
-			allImports = LedgerOfImports(astModule)
-		else:
-			allImports.walkThis(astModule)
-
-		if inlineCallables:
-			dictionaryFunctionDef: dict[ast_Identifier, ast.FunctionDef] = {statement.name: statement for statement in astModule.body if isinstance(statement, ast.FunctionDef)}
-			callableInlinerWorkhorse = FunctionInliner(dictionaryFunctionDef)
-			FunctionDefTarget = callableInlinerWorkhorse.inlineFunctionBody(callableTarget)
-		else:
-			FunctionDefTarget = next((statement for statement in astModule.body if isinstance(statement, ast.FunctionDef) and statement.name == callableTarget), None)
-		if not FunctionDefTarget:
-			raise ValueError(f"Could not find function {callableTarget} in source code")
-
-		ast.fix_missing_locations(FunctionDefTarget)
-		listFunctionDefs.append(FunctionDefTarget)
-		allImportsModule.update(allImports)
-
-	listAstImports: list[ast.ImportFrom | ast.Import] = allImportsModule.makeListAst()
-	additional_imports: list[str] = Z0Z_autoflake_additional_imports
-	additional_imports.append(getDatatypePackage())
-
-	astModule = ast.Module(body=cast(list[ast.stmt], listAstImports + listFunctionDefs), type_ignores=[])
-	ast.fix_missing_locations(astModule)
-	pythonSource: str = ast.unparse(astModule)
-	if not pythonSource: raise FREAKOUT
-	pythonSource = autoflake.fix_code(pythonSource, additional_imports)
-
-	pathWrite: Path = thePathPackage / relativePathWrite
-
-	if not filenameWrite:
-		if len(listCallableSynthesized) == 1:
-			callableTarget: str = listCallableSynthesized[0].callableTarget
-		else:
-			callableTarget = filenameWriteCallableTargetDEFAULT
-			# NOTE WARNING I think I broken this format string. See theSSOT.py
-		filenameWrite = formatFilenameWrite.format(callableTarget=callableTarget)
-	else:
-		if not filenameWrite.endswith('.py'):
-			warnings.warn(f"Filename {filenameWrite=} does not end with '.py'.")
-
-	pathFilename: Path = pathWrite / filenameWrite
-
-	pathFilename.write_text(pythonSource)
-
-	howIsThisStillAThing: Path = thePathPackage.parent
-	dumbassPythonNamespace: tuple[str, ...] = pathFilename.relative_to(howIsThisStillAThing).with_suffix('').parts
-	ImaModule: str = '.'.join(dumbassPythonNamespace)
-
-	for item in listCallableSynthesized:
-		callableTarget: str = item.callableTarget
-		astImportFrom = ast.ImportFrom(module=ImaModule, names=[ast.alias(name=callableTarget, asname=None)], level=0)
-		stuff = YouOughtaKnow(callableSynthesized=callableTarget, pathFilenameForMe=pathFilename, astForCompetentProgrammers=astImportFrom)
-		listStuffYouOughtaKnow.append(stuff)
-	listStuffYouOughtaKnow.extend(listStuff)
-
-	if callableDispatcher:
-		pass
-
-	return listStuffYouOughtaKnow

mapFolding/someAssemblyRequired/whatWillBe.py

@@ -1,311 +0,0 @@
-"""
-- Settings for synthesizing the modules used by the package (i.e., the flow for numba)
-- Settings for synthesizing modules that could be used by the package (e.g., the flow for JAX)
-- Therefore, an abstracted system for creating settings for the package
-- And with only a little more effort, an abstracted system for creating settings to synthesize arbitrary subsets of modules for arbitrary packages
-"""
-from mapFolding.someAssemblyRequired.transformationTools import *
-from mapFolding.theSSOT import (
-	FREAKOUT,
-	getDatatypePackage,
-	getSourceAlgorithm,
-	theDataclassIdentifierAsStr,
-	theDataclassInstanceAsStr,
-	theDispatcherCallableAsStr,
-	theFileExtension,
-	theFormatStrModuleForCallableSynthetic,
-	theFormatStrModuleSynthetic,
-	theLogicalPathModuleDataclass,
-	theLogicalPathModuleDispatcherSynthetic,
-	theModuleOfSyntheticModules,
-	thePackageName,
-	thePathPackage,
-	Z0Z_sequentialCallableAsStr,
-)
-from autoflake import fix_code as autoflake_fix_code
-from collections import defaultdict
-from collections.abc import Sequence
-from inspect import getsource as inspect_getsource
-from mapFolding.someAssemblyRequired.ingredientsNumba import parametersNumbaDEFAULT, parametersNumbaSuperJit, parametersNumbaSuperJitParallel, ParametersNumba
-from pathlib import Path
-from types import ModuleType
-from typing import NamedTuple
-from Z0Z_tools import updateExtendPolishDictionaryLists
-import ast
-import dataclasses
-
-"""
-Start with what is: theDao.py
-Create settings that can transform into what I or the user want it to be.
-
-The simplest flow with numba is:
-1. one module
-2. dispatcher
-	- initialize data with makeJob
-	- smash dataclass
-	- call countSequential
-3. countSequential
-	- jitted, not super-jitted
-	- functions inlined (or I'd have to jit them)
-	- return groupsOfFolds
-4. recycle the dataclass with groupsOfFolds
-5. return the dataclass
-"""
-
-@dataclasses.dataclass
-class RecipeSynthesizeFlow:
-	"""Settings for synthesizing flow."""
-	# TODO consider `IngredientsFlow` or similar
-	sourceAlgorithm: ModuleType = getSourceAlgorithm()
-	sourcePython: str = inspect_getsource(sourceAlgorithm)
-	# sourcePython: str = inspect_getsource(self.sourceAlgorithm)
-	# "self" is not defined
-	# I still hate the OOP paradigm. But I like this dataclass stuff.
-	source_astModule: ast.Module = ast.parse(sourcePython)
-
-	# ========================================
-	# Filesystem
-	pathPackage: Path = thePathPackage
-	fileExtension: str = theFileExtension
-
-	# ========================================
-	# Logical identifiers
-	# meta
-	formatStrModuleSynthetic: str = theFormatStrModuleSynthetic
-	formatStrModuleForCallableSynthetic: str = theFormatStrModuleForCallableSynthetic
-
-	# Package
-	packageName: ast_Identifier = thePackageName
-
-	# Module
-	moduleOfSyntheticModules: str = theModuleOfSyntheticModules
-	logicalPathModuleDataclass: str = theLogicalPathModuleDataclass
-	logicalPathModuleDispatcher: str = theLogicalPathModuleDispatcherSynthetic
-	dataConverterModule: str = 'dataNamespaceFlattened'
-
-	# Function
-	dataclassIdentifierAsStr: str = theDataclassIdentifierAsStr
-	dispatcherCallableAsStr: str = theDispatcherCallableAsStr
-	dataConverterCallableAsStr: str = 'flattenData'
-	sequentialCallableAsStr: str = Z0Z_sequentialCallableAsStr
-
-	# Variable
-	dataclassInstanceAsStr: str = theDataclassInstanceAsStr
-
-class LedgerOfImports:
-	def __init__(self, startWith: ast.AST | None = None) -> None:
-		self.dictionaryImportFrom: dict[str, list[tuple[str, str | None]]] = defaultdict(list)
-		self.listImport: list[str] = []
-
-		if startWith:
-			self.walkThis(startWith)
-
-	def addAst(self, astImport_: ast.Import | ast.ImportFrom) -> None:
-		if not isinstance(astImport_, (ast.Import, ast.ImportFrom)): # pyright: ignore[reportUnnecessaryIsInstance]
-			raise ValueError(f"Expected ast.Import or ast.ImportFrom, got {type(astImport_)}")
-		if isinstance(astImport_, ast.Import):
-			for alias in astImport_.names:
-				self.listImport.append(alias.name)
-		else:
-			if astImport_.module is not None:
-				for alias in astImport_.names:
-					self.dictionaryImportFrom[astImport_.module].append((alias.name, alias.asname))
-
-	def addImportStr(self, module: str) -> None:
-		self.listImport.append(module)
-
-	def addImportFromStr(self, module: str, name: str, asname: str | None = None) -> None:
-		self.dictionaryImportFrom[module].append((name, asname))
-
-	def makeListAst(self) -> list[ast.ImportFrom | ast.Import]:
-		listAstImportFrom: list[ast.ImportFrom] = []
-
-		for module, listOfNameTuples in sorted(self.dictionaryImportFrom.items()):
-			listOfNameTuples = sorted(list(set(listOfNameTuples)), key=lambda nameTuple: nameTuple[0])
-			listAlias: list[ast.alias] = []
-			for name, asname in listOfNameTuples:
-				listAlias.append(Make.astAlias(name, asname))
-			listAstImportFrom.append(Make.astImportFrom(module, listAlias))
-
-		listAstImport: list[ast.Import] = [Make.astImport(name) for name in sorted(set(self.listImport))]
-		return listAstImportFrom + listAstImport
-
-	def update(self, *fromLedger: 'LedgerOfImports') -> None:
-		"""
-		Update this ledger with imports from one or more other ledgers.
-
-		Parameters:
-			*fromTracker: One or more other `LedgerOfImports` objects from which to merge.
-		"""
-		self.dictionaryImportFrom = updateExtendPolishDictionaryLists(self.dictionaryImportFrom, *(ledger.dictionaryImportFrom for ledger in fromLedger), destroyDuplicates=True, reorderLists=True)
-
-		for ledger in fromLedger:
-			self.listImport.extend(ledger.listImport)
-
-	def walkThis(self, walkThis: ast.AST) -> None:
-		for smurf in ast.walk(walkThis):
-			if isinstance(smurf, (ast.Import, ast.ImportFrom)):
-				self.addAst(smurf)
-
-@dataclasses.dataclass
-class IngredientsFunction:
-	"""Everything necessary to integrate a function into a module should be here."""
-	FunctionDef: ast.FunctionDef # hint `Make.astFunctionDef`
-	imports: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
-
-@dataclasses.dataclass
-class IngredientsModule:
-	"""Everything necessary to create a module, including the package context, should be here."""
-	name: ast_Identifier
-	ingredientsFunction: dataclasses.InitVar[Sequence[IngredientsFunction] | IngredientsFunction | None] = None
-
-	imports: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
-	prologue: list[ast.stmt] = dataclasses.field(default_factory=list)
-	functions: list[ast.FunctionDef | ast.stmt] = dataclasses.field(default_factory=list)
-	epilogue: list[ast.stmt] = dataclasses.field(default_factory=list)
-	launcher: list[ast.stmt] = dataclasses.field(default_factory=list)
-
-	packageName: ast_Identifier | None= thePackageName
-	logicalPathINFIX: ast_Identifier | strDotStrCuzPyStoopid | None = None # module names other than the module itself and the package name
-	pathPackage: Path = thePathPackage
-	fileExtension: str = theFileExtension
-	type_ignores: list[ast.TypeIgnore] = dataclasses.field(default_factory=list)
-
-	def _getLogicalPathParent(self) -> str | None:
-		listModules: list[ast_Identifier] = []
-		if self.packageName:
-			listModules.append(self.packageName)
-		if self.logicalPathINFIX:
-			listModules.append(self.logicalPathINFIX)
-		if listModules:
-			return '.'.join(listModules)
-
-	def _getLogicalPathAbsolute(self) -> str:
-		listModules: list[ast_Identifier] = []
-		logicalPathParent: str | None = self._getLogicalPathParent()
-		if logicalPathParent:
-			listModules.append(logicalPathParent)
-		listModules.append(self.name)
-		return '.'.join(listModules)
-
-	@property
-	def pathFilename(self) -> Path:
-		pathRoot: Path = self.pathPackage
-		filename = self.name + self.fileExtension
-		if self.logicalPathINFIX:
-			whyIsThisStillAThing = self.logicalPathINFIX.split('.')
-			pathRoot = pathRoot.joinpath(*whyIsThisStillAThing)
-		return pathRoot.joinpath(filename)
-
-	@property
-	def absoluteImport(self) -> ast.Import:
-		return Make.astImport(self._getLogicalPathAbsolute())
-
-	@property
-	def absoluteImportFrom(self) -> ast.ImportFrom:
-		""" `from . import theModule` """
-		logicalPathParent: str | None = self._getLogicalPathParent()
-		if logicalPathParent is None:
-			logicalPathParent = '.'
-		return Make.astImportFrom(logicalPathParent, [Make.astAlias(self.name)])
-
-	def __post_init__(self, ingredientsFunction: Sequence[IngredientsFunction] | IngredientsFunction | None = None) -> None:
-		if ingredientsFunction is not None:
-			if isinstance(ingredientsFunction, IngredientsFunction):
-				self.addIngredientsFunction(ingredientsFunction)
-			else:
-				self.addIngredientsFunction(*ingredientsFunction)
-
-	def addIngredientsFunction(self, *ingredientsFunction: IngredientsFunction) -> None:
-		"""Add one or more `IngredientsFunction`. """
-		listLedgers: list[LedgerOfImports] = []
-		for definition in ingredientsFunction:
-			self.functions.append(definition.FunctionDef)
-			listLedgers.append(definition.imports)
-		self.imports.update(*listLedgers)
-
-	def _makeModuleBody(self) -> list[ast.stmt]:
-		"""Constructs the body of the module, including prologue, functions, epilogue, and launcher."""
-		body: list[ast.stmt] = []
-		body.extend(self.imports.makeListAst())
-		body.extend(self.prologue)
-		body.extend(self.functions)
-		body.extend(self.epilogue)
-		body.extend(self.launcher)
-		# TODO `launcher` must start with `if __name__ == '__main__':` and be indented
-		return body
-
-	def writeModule(self) -> None:
-		"""Writes the module to disk with proper imports and functions.
-
-		This method creates a proper AST module with imports and function definitions,
-		fixes missing locations, unpacks the AST to Python code, applies autoflake
-		to clean up imports, and writes the resulting code to the appropriate file.
-		"""
-		astModule = Make.astModule(body=self._makeModuleBody(), type_ignores=self.type_ignores)
-		ast.fix_missing_locations(astModule)
-		pythonSource: str = ast.unparse(astModule)
-		if not pythonSource: raise FREAKOUT
-		autoflake_additional_imports: list[str] = []
-		if self.packageName:
-			autoflake_additional_imports.append(self.packageName)
-		# TODO LedgerOfImports method: list of package names. autoflake_additional_imports.extend()
-		autoflake_additional_imports.append(getDatatypePackage())
-		pythonSource = autoflake_fix_code(pythonSource, autoflake_additional_imports, expand_star_imports=False, remove_all_unused_imports=False, remove_duplicate_keys = False, remove_unused_variables = False,)
-		self.pathFilename.write_text(pythonSource)
-
-@dataclasses.dataclass
-class RecipeSynthesizeCountingFunction:
-	"""Settings for synthesizing counting functions."""
-	ingredients: IngredientsFunction
-
-numbaFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()
-
-# https://github.com/hunterhogan/mapFolding/issues/3
-sequentialFunctionDef = extractFunctionDef(numbaFlow.sequentialCallableAsStr, numbaFlow.source_astModule)
-if sequentialFunctionDef is None: raise FREAKOUT
-
-numbaCountSequential = RecipeSynthesizeCountingFunction(IngredientsFunction(
-	FunctionDef=sequentialFunctionDef,
-	imports=LedgerOfImports(numbaFlow.source_astModule)
-))
-
-# the data converter and the dispatcher could be in the same module.
-
-Z0Z_autoflake_additional_imports: list[str] = []
-Z0Z_autoflake_additional_imports.append(thePackageName)
-
-class ParametersSynthesizeNumbaCallable(NamedTuple):
-	callableTarget: str
-	parametersNumba: ParametersNumba | None = None
-	inlineCallables: bool = False
-
-listNumbaCallableDispatchees: list[ParametersSynthesizeNumbaCallable] = [
-	ParametersSynthesizeNumbaCallable('countParallel', parametersNumbaSuperJitParallel, True),
-	ParametersSynthesizeNumbaCallable('countSequential', parametersNumbaSuperJit, True),
-	ParametersSynthesizeNumbaCallable('countInitialize', parametersNumbaDEFAULT, True),
-]
-
-_datatypeModuleScalar = ''
-_decoratorCallable = ''
-
-# if numba
-_datatypeModuleScalar = 'numba'
-_decoratorCallable = 'jit'
-Z0Z_autoflake_additional_imports.append('numba')
-
-def Z0Z_getDatatypeModuleScalar() -> str:
-	return _datatypeModuleScalar
-
-def Z0Z_setDatatypeModuleScalar(moduleName: str) -> str:
-	global _datatypeModuleScalar
-	_datatypeModuleScalar = moduleName
-	return _datatypeModuleScalar
-
-def Z0Z_getDecoratorCallable() -> str:
-	return _decoratorCallable
-
-def Z0Z_setDecoratorCallable(decoratorName: str) -> str:
-	global _decoratorCallable
-	_decoratorCallable = decoratorName
-	return _decoratorCallable