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

mapFolding/someAssemblyRequired/Z0Z_workbench.py

@@ -1,350 +0,0 @@
-from autoflake import fix_code as autoflake_fix_code
-from mapFolding.filesystem import writeStringToHere
-from mapFolding.someAssemblyRequired import (
-	ast_Identifier,
-	extractFunctionDef,
-	ifThis,
-	IngredientsFunction,
-	IngredientsModule,
-	LedgerOfImports,
-	Make,
-	makeDictionaryReplacementStatements,
-	NodeCollector,
-	NodeReplacer,
-	RecipeSynthesizeFlow,
-	strDotStrCuzPyStoopid,
-	Then,
-)
-from mapFolding.someAssemblyRequired.ingredientsNumba import decorateCallableWithNumba
-from mapFolding.someAssemblyRequired.synthesizeDataConverters import shatter_dataclassesDOTdataclass
-from mapFolding.theSSOT import raiseIfNoneGitHubIssueNumber3
-from pathlib import Path
-import ast
-
-# Would `LibCST` be better than `ast` in some cases? https://github.com/hunterhogan/mapFolding/issues/7
-
-def Z0Z_alphaTest_putModuleOnDisk(ingredients: IngredientsModule, recipeFlow: RecipeSynthesizeFlow):
-	# Physical namespace
-	filenameStem: str = recipeFlow.moduleDispatcher
-	fileExtension: str = recipeFlow.fileExtension
-	pathPackage: Path = Path(recipeFlow.pathPackage)
-
-	# Physical and logical namespace
-	packageName: ast_Identifier | None = recipeFlow.packageName # module name of the package, if any
-	logicalPathINFIX: ast_Identifier | strDotStrCuzPyStoopid | None = recipeFlow.Z0Z_flowLogicalPathRoot
-
-	def _getLogicalPathParent() -> str | None:
-		listModules: list[ast_Identifier] = []
-		if packageName:
-			listModules.append(packageName)
-		if logicalPathINFIX:
-			listModules.append(logicalPathINFIX)
-		if listModules:
-			return '.'.join(listModules)
-		return None
-
-	def _getLogicalPathAbsolute() -> str:
-		listModules: list[ast_Identifier] = []
-		logicalPathParent: str | None = _getLogicalPathParent()
-		if logicalPathParent:
-			listModules.append(logicalPathParent)
-		listModules.append(filenameStem)
-		return '.'.join(listModules)
-
-	def getPathFilename():
-		pathRoot: Path = pathPackage
-		filename: str = filenameStem + fileExtension
-		if logicalPathINFIX:
-			whyIsThisStillAThing: list[str] = logicalPathINFIX.split('.')
-			pathRoot = pathRoot.joinpath(*whyIsThisStillAThing)
-		return pathRoot.joinpath(filename)
-
-	def absoluteImport() -> ast.Import:
-		return Make.astImport(_getLogicalPathAbsolute())
-
-	def absoluteImportFrom() -> ast.ImportFrom:
-		""" `from . import theModule` """
-		logicalPathParent: str = _getLogicalPathParent() or '.'
-		return Make.astImportFrom(logicalPathParent, [Make.astAlias(filenameStem)])
-
-	def writeModule() -> None:
-		astModule = ingredients.export()
-		ast.fix_missing_locations(astModule)
-		pythonSource: str = ast.unparse(astModule)
-		if not pythonSource: raise raiseIfNoneGitHubIssueNumber3
-		autoflake_additional_imports: list[str] = ingredients.imports.exportListModuleNames()
-		if packageName:
-			autoflake_additional_imports.append(packageName)
-		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,)
-		pathFilename = getPathFilename()
-		writeStringToHere(pythonSource, pathFilename)
-
-	writeModule()
-
-def inlineThisFunctionWithTheseValues(astFunctionDef: ast.FunctionDef, dictionaryReplacementStatements: dict[str, ast.stmt | list[ast.stmt]]) -> ast.FunctionDef:
-	class FunctionInliner(ast.NodeTransformer):
-		def __init__(self, dictionaryReplacementStatements: dict[str, ast.stmt | list[ast.stmt]]) -> None:
-			self.dictionaryReplacementStatements = dictionaryReplacementStatements
-
-		def generic_visit(self, node: ast.AST) -> ast.AST:
-			"""Visit all nodes and replace them if necessary."""
-			return super().generic_visit(node)
-
-		def visit_Expr(self, node: ast.Expr) -> ast.AST | list[ast.stmt]:
-			"""Visit Expr nodes and replace value if it's a function call in our dictionary."""
-			if ifThis.CallDoesNotCallItselfAndNameDOTidIsIn(self.dictionaryReplacementStatements)(node.value):
-				return self.dictionaryReplacementStatements[node.value.func.id] # type: ignore[attr-defined]
-			return node
-
-		def visit_Assign(self, node: ast.Assign) -> ast.AST | list[ast.stmt]:
-			"""Visit Assign nodes and replace value if it's a function call in our dictionary."""
-			if ifThis.CallDoesNotCallItselfAndNameDOTidIsIn(self.dictionaryReplacementStatements)(node.value):
-				return self.dictionaryReplacementStatements[node.value.func.id] # type: ignore[attr-defined]
-			return node
-
-		def visit_Call(self, node: ast.Call) -> ast.AST | list[ast.stmt]:
-			"""Replace call nodes with their replacement statements if they're in the dictionary."""
-			if ifThis.CallDoesNotCallItselfAndNameDOTidIsIn(self.dictionaryReplacementStatements)(node):
-				replacement = self.dictionaryReplacementStatements[node.func.id] # type: ignore[attr-defined]
-				if not isinstance(replacement, list):
-					return replacement
-			return node
-
-	import copy
-	keepGoing = True
-	ImaInlineFunction = copy.deepcopy(astFunctionDef)
-	while keepGoing:
-		ImaInlineFunction = copy.deepcopy(astFunctionDef)
-		FunctionInliner(copy.deepcopy(dictionaryReplacementStatements)).visit(ImaInlineFunction)
-		if ast.unparse(ImaInlineFunction) == ast.unparse(astFunctionDef):
-			keepGoing = False
-		else:
-			astFunctionDef = copy.deepcopy(ImaInlineFunction)
-	return ImaInlineFunction
-
-def replaceMatchingASTnodes(astTree: ast.AST, replacementMap: list[tuple[ast.AST, ast.AST]]) -> ast.AST:
-	"""Replace matching AST nodes using type-specific visitors.
-
-	Parameters:
-		astTree: The AST to transform
-		replacementMap: List of (find, replace) node pairs
-
-	Returns:
-		The transformed AST
-	"""
-	class TargetedNodeReplacer(ast.NodeTransformer):
-		def __init__(self, replacementMap: list[tuple[ast.AST, ast.AST]]) -> None:
-			# Group replacements by node type for more efficient lookups
-			self.replacementByType: dict[type[ast.AST], list[tuple[ast.AST, ast.AST]]] = {}
-			for findNode, replaceNode in replacementMap:
-				nodeType = type(findNode)
-				if nodeType not in self.replacementByType:
-					self.replacementByType[nodeType] = []
-				self.replacementByType[nodeType].append((findNode, replaceNode))
-
-		def visit(self, node: ast.AST) -> ast.AST:
-			"""Check if this node should be replaced before continuing traversal."""
-			nodeType = type(node)
-			if nodeType in self.replacementByType:
-				for findNode, replaceNode in self.replacementByType[nodeType]:
-					if self.nodesMatchStructurally(node, findNode):
-						return replaceNode
-			return super().visit(node)
-
-		def nodesMatchStructurally(self, node1: ast.AST | list, node2: ast.AST | list) -> bool:
-			"""Compare two AST nodes structurally, ignoring position information."""
-			# Different types can't be equal
-			if type(node1) != type(node2):
-				return False
-
-			if isinstance(node1, ast.AST):
-				# Compare fields that matter for structural equality
-				fields = [f for f in node1._fields
-							if f not in ('lineno', 'col_offset', 'end_lineno', 'end_col_offset', 'ctx')]
-
-				for field in fields:
-					smurf1 = getattr(node1, field, None)
-					smurf2 = getattr(node2, field, None)
-
-					if isinstance(smurf1, (ast.AST, list)) and isinstance(smurf2, (ast.AST, list)):
-						if not self.nodesMatchStructurally(smurf1, smurf2):
-							return False
-					elif smurf1 != smurf2:
-						return False
-				return True
-
-			elif isinstance(node1, list) and isinstance(node2, list):
-				if len(node1) != len(node2):
-					return False
-				return all(self.nodesMatchStructurally(x, y) for x, y in zip(node1, node2))
-
-			else:
-				# Direct comparison for non-AST objects (strings, numbers, etc.)
-				return node1 == node2
-
-	import copy
-	keepGoing = True
-	astResult = copy.deepcopy(astTree)
-
-	while keepGoing:
-		astBeforeChange = copy.deepcopy(astResult)
-		TargetedNodeReplacer(copy.deepcopy(replacementMap)).visit(astResult)
-
-		# Check if we've reached a fixed point (no more changes)
-		if ast.unparse(astResult) == ast.unparse(astBeforeChange):
-			keepGoing = False
-
-	return astResult
-
-def Z0Z_main() -> None:
-	numbaFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()
-	dictionaryReplacementStatements = makeDictionaryReplacementStatements(numbaFlow.source_astModule)
-	# TODO remove hardcoding
-	theCountingIdentifierHARDCODED = 'groupsOfFolds'
-	theCountingIdentifier = theCountingIdentifierHARDCODED
-
-	# TODO remember that `sequentialCallable` and `sourceSequentialCallable` are two different values.
-	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
-
-	# ===========================================================
-	sourcePython = numbaFlow.sourceDispatcherCallable
-	astFunctionDef = extractFunctionDef(sourcePython, numbaFlow.source_astModule)
-	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
-	ingredientsDispatcher = IngredientsFunction(astFunctionDef, LedgerOfImports(numbaFlow.source_astModule))
-
-	# sourceParallelCallable
-	(astName_dataclassesDOTdataclass, ledgerDataclassANDFragments, listAnnAssign4DataclassUnpack,
-		astTuple4AssignTargetsToFragments, listNameDataclassFragments4Parameters, list_ast_argAnnotated4ArgumentsSpecification,
-		astSubscriptPrimitiveTupleAnnotations4FunctionDef_returns, astAssignDataclassRepack, list_keyword4DataclassInitialization) = shatter_dataclassesDOTdataclass(
-			numbaFlow.logicalPathModuleDataclass, numbaFlow.sourceDataclassIdentifier, numbaFlow.sourceDataclassInstanceTaskDistribution)
-	ingredientsDispatcher.imports.update(ledgerDataclassANDFragments)
-
-	# TODO remove hardcoding
-	namespaceHARDCODED = 'concurrencyManager'
-	identifierHARDCODED = 'submit'
-	namespace = namespaceHARDCODED
-	identifier = identifierHARDCODED
-	NodeReplacer(
-		findThis = ifThis.isAssignAndValueIsCallNamespace_Identifier(namespace, identifier)
-		, doThat = Then.insertThisAbove(listAnnAssign4DataclassUnpack)
-			).visit(ingredientsDispatcher.astFunctionDef)
-	NodeReplacer(
-		findThis = ifThis.isCallNamespace_Identifier(namespace, identifier)
-		, doThat = Then.replaceWith(Make.astCall(Make.astAttribute(Make.astName(namespace), identifier)
-									, listArguments=[Make.astName(numbaFlow.parallelCallable)] + listNameDataclassFragments4Parameters))
-			).visit(ingredientsDispatcher.astFunctionDef)
-
-	CapturedAssign: list[ast.AST] = []
-	CapturedCall: list[ast.Call] = []
-	findThis = ifThis.isCall
-	doThat = [Then.appendTo(CapturedCall)]
-	capture = NodeCollector(findThis, doThat)
-
-	NodeCollector(
-		findThis = ifThis.isAssignAndTargets0Is(ifThis.isSubscript_Identifier(numbaFlow.sourceDataclassInstance))
-		, doThat = [Then.appendTo(CapturedAssign)
-					, lambda node: capture.visit(node)]
-			).visit(ingredientsDispatcher.astFunctionDef)
-
-	newAssign = CapturedAssign[0]
-	NodeReplacer(
-		findThis = lambda node: ifThis.isSubscript(node) and ifThis.isAttribute(node.value) and ifThis.isCall(node.value.value)
-		, doThat = Then.replaceWith(CapturedCall[0])
-			).visit(newAssign)
-
-	NodeReplacer(
-		findThis = ifThis.isAssignAndTargets0Is(ifThis.isSubscript_Identifier(numbaFlow.sourceDataclassInstance))
-		, doThat = Then.replaceWith(newAssign)
-			).visit(ingredientsDispatcher.astFunctionDef)
-
-	# sourceSequentialCallable
-	(astName_dataclassesDOTdataclass, ledgerDataclassANDFragments, listAnnAssign4DataclassUnpack,
-		astTuple4AssignTargetsToFragments, listNameDataclassFragments4Parameters, list_ast_argAnnotated4ArgumentsSpecification,
-		astSubscriptPrimitiveTupleAnnotations4FunctionDef_returns, astAssignDataclassRepack, list_keyword4DataclassInitialization) = shatter_dataclassesDOTdataclass(
-			numbaFlow.logicalPathModuleDataclass, numbaFlow.sourceDataclassIdentifier, numbaFlow.sourceDataclassInstance)
-	ingredientsDispatcher.imports.update(ledgerDataclassANDFragments)
-
-	NodeReplacer(
-		findThis = ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.sourceSequentialCallable)
-		, doThat = Then.insertThisAbove(listAnnAssign4DataclassUnpack)
-			).visit(ingredientsDispatcher.astFunctionDef)
-	NodeReplacer(
-		findThis = ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.sourceSequentialCallable)
-		# findThis = ifThis.isReturn
-		, doThat = Then.insertThisBelow([astAssignDataclassRepack])
-			).visit(ingredientsDispatcher.astFunctionDef)
-	# TODO reconsider: This calls a function, but I don't inspect the function for its parameters or return.
-	NodeReplacer(
-		findThis = ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.sourceSequentialCallable)
-		, doThat = Then.replaceWith(Make.astAssign(listTargets=[astTuple4AssignTargetsToFragments], value=Make.astCall(Make.astName(numbaFlow.sequentialCallable), listNameDataclassFragments4Parameters)))
-			).visit(ingredientsDispatcher.astFunctionDef)
-
-	# ===========================================================
-	sourcePython = numbaFlow.sourceInitializeCallable
-	astFunctionDef = extractFunctionDef(sourcePython, numbaFlow.source_astModule)
-	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
-	astFunctionDef = inlineThisFunctionWithTheseValues(astFunctionDef, dictionaryReplacementStatements)
-	ingredientsInitialize = IngredientsFunction(astFunctionDef, LedgerOfImports(numbaFlow.source_astModule))
-
-	# ===========================================================
-	sourcePython = numbaFlow.sourceParallelCallable
-	astFunctionDef = extractFunctionDef(sourcePython, numbaFlow.source_astModule)
-	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
-	astFunctionDef = inlineThisFunctionWithTheseValues(astFunctionDef, dictionaryReplacementStatements)
-	ingredientsParallel = IngredientsFunction(astFunctionDef, LedgerOfImports(numbaFlow.source_astModule))
-	ingredientsParallel.astFunctionDef.name = numbaFlow.parallelCallable
-	ingredientsParallel.astFunctionDef.args = Make.astArgumentsSpecification(args=list_ast_argAnnotated4ArgumentsSpecification)
-	NodeReplacer(
-		findThis = ifThis.isReturn
-		, doThat = Then.replaceWith(Make.astReturn(astTuple4AssignTargetsToFragments))
-			).visit(ingredientsParallel.astFunctionDef)
-	NodeReplacer(
-		findThis = ifThis.isReturn
-		# , doThat = Then.replaceWith(Make.astReturn(astTuple4AssignTargetsToFragments))
-		, doThat = Then.replaceWith(Make.astReturn(Make.astName(theCountingIdentifier)))
-			).visit(ingredientsParallel.astFunctionDef)
-	theCountingIdentifierAnnotation = next(
-		ast_arg.annotation for ast_arg in list_ast_argAnnotated4ArgumentsSpecification if ast_arg.arg == theCountingIdentifier)
-	ingredientsParallel.astFunctionDef.returns = theCountingIdentifierAnnotation
-	# ingredientsParallel.astFunctionDef.returns = astSubscriptPrimitiveTupleAnnotations4FunctionDef_returns
-	replacementMap = [(statement.value, statement.target) for statement in listAnnAssign4DataclassUnpack]
-	ingredientsParallel.astFunctionDef = replaceMatchingASTnodes(
-		ingredientsParallel.astFunctionDef, replacementMap) # type: ignore
-	# TODO a tool to automatically remove unused variables from the ArgumentsSpecification (return, and returns) _might_ be nice.
-	# But, I would need to update the calling function, too.
-	ingredientsParallel = decorateCallableWithNumba(ingredientsParallel) # parametersNumbaParallelDEFAULT
-
-	# ===========================================================
-	sourcePython = numbaFlow.sourceSequentialCallable
-	astFunctionDef = extractFunctionDef(sourcePython, numbaFlow.source_astModule)
-	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
-	astFunctionDef = inlineThisFunctionWithTheseValues(astFunctionDef, dictionaryReplacementStatements)
-	ingredientsSequential = IngredientsFunction(astFunctionDef, LedgerOfImports(numbaFlow.source_astModule))
-	ingredientsSequential.astFunctionDef.name = numbaFlow.sequentialCallable
-	ingredientsSequential.astFunctionDef.args = Make.astArgumentsSpecification(args=list_ast_argAnnotated4ArgumentsSpecification)
-	NodeReplacer(
-		findThis = ifThis.isReturn
-		, doThat = Then.replaceWith(Make.astReturn(astTuple4AssignTargetsToFragments))
-			).visit(ingredientsSequential.astFunctionDef)
-	NodeReplacer(
-		findThis = ifThis.isReturn
-		, doThat = Then.replaceWith(Make.astReturn(astTuple4AssignTargetsToFragments))
-			).visit(ingredientsSequential.astFunctionDef)
-	ingredientsSequential.astFunctionDef.returns = astSubscriptPrimitiveTupleAnnotations4FunctionDef_returns
-	replacementMap = [(statement.value, statement.target) for statement in listAnnAssign4DataclassUnpack]
-	ingredientsSequential.astFunctionDef = replaceMatchingASTnodes(
-		ingredientsSequential.astFunctionDef, replacementMap) # type: ignore
-	# TODO a tool to automatically remove unused variables from the ArgumentsSpecification (return, and returns) _might_ be nice.
-	# But, I would need to update the calling function, too.
-	ingredientsSequential = decorateCallableWithNumba(ingredientsSequential)
-
-	ingredientsModuleNumbaUnified = IngredientsModule(
-		ingredientsFunction=[ingredientsInitialize,
-							ingredientsParallel,
-							ingredientsSequential,
-							ingredientsDispatcher], imports=LedgerOfImports(numbaFlow.source_astModule))
-
-	Z0Z_alphaTest_putModuleOnDisk(ingredientsModuleNumbaUnified, numbaFlow)
-
-if __name__ == '__main__':
-	Z0Z_main()

mapFolding/someAssemblyRequired/synthesizeDataConverters.py

@@ -1,117 +0,0 @@
-from collections.abc import Sequence
-from importlib import import_module
-from inspect import getsource as inspect_getsource
-from mapFolding.beDRY import outfitCountFolds, validateListDimensions
-from mapFolding.filesystem import getPathFilenameFoldsTotal
-from mapFolding.someAssemblyRequired import (
-	ast_Identifier,
-	extractClassDef,
-	ifThis,
-	LedgerOfImports,
-	Make,
-	NodeCollector,
-	strDotStrCuzPyStoopid,
-	Then,
-	Z0Z_executeActionUnlessDescendantMatches,
-)
-from mapFolding.theSSOT import ComputationState, getSourceAlgorithm
-from pathlib import Path
-from types import ModuleType
-from typing import Any, Literal, overload
-import ast
-import pickle
-
-# Would `LibCST` be better than `ast` in some cases? https://github.com/hunterhogan/mapFolding/issues/7
-
-def shatter_dataclassesDOTdataclass(logicalPathModule: strDotStrCuzPyStoopid, dataclass_Identifier: ast_Identifier, instance_Identifier: ast_Identifier
-		)-> tuple[ast.Name, LedgerOfImports, list[ast.AnnAssign], ast.Tuple, list[ast.Name], list[ast.arg], ast.Subscript, ast.Assign, list[ast.keyword]]:
-	"""
-	Parameters:
-		logicalPathModule: gimme string cuz python is stoopid
-		dataclass_Identifier: The identifier of the dataclass to be dismantled.
-		instance_Identifier: In the synthesized module/function/scope, the identifier that will be used for the instance.
-	"""
-	module: ast.Module = ast.parse(inspect_getsource(import_module(logicalPathModule)))
-
-	dataclass = extractClassDef(dataclass_Identifier, module)
-
-	if not isinstance(dataclass, ast.ClassDef):
-		raise ValueError(f"I could not find {dataclass_Identifier=} in {logicalPathModule=}.")
-
-	ledgerDataclassANDFragments = LedgerOfImports()
-	list_ast_argAnnotated4ArgumentsSpecification: list[ast.arg] = []
-	list_keyword4DataclassInitialization: list[ast.keyword] = []
-	listAnnAssign4DataclassUnpack: list[ast.AnnAssign] = []
-	listAnnotations: list[ast.expr] = []
-	listNameDataclassFragments4Parameters: list[ast.Name] = []
-
-	addToLedgerPredicate = ifThis.isAnnAssignAndAnnotationIsName
-	addToLedgerAction = Then.Z0Z_ledger(logicalPathModule, ledgerDataclassANDFragments)
-	addToLedger = NodeCollector(addToLedgerPredicate, [addToLedgerAction])
-
-	exclusionPredicate = ifThis.is_keyword_IdentifierEqualsConstantValue('init', False)
-	appendKeywordAction = Then.Z0Z_appendKeywordMirroredTo(list_keyword4DataclassInitialization)
-	filteredAppendKeywordAction = Z0Z_executeActionUnlessDescendantMatches(exclusionPredicate, appendKeywordAction) # type: ignore
-
-	collector = NodeCollector(
-			ifThis.isAnnAssignAndTargetIsName,
-				[Then.Z0Z_appendAnnAssignOf_nameDOTnameTo(instance_Identifier, listAnnAssign4DataclassUnpack)
-				, Then.append_targetTo(listNameDataclassFragments4Parameters) # type: ignore
-				, lambda node: addToLedger.visit(node)
-				, filteredAppendKeywordAction
-				, lambda node: list_ast_argAnnotated4ArgumentsSpecification.append(Make.ast_arg(node.target.id, node.annotation)) # type: ignore
-				, lambda node: listAnnotations.append(node.annotation) # type: ignore
-				]
-			)
-
-	collector.visit(dataclass)
-
-	astSubscriptPrimitiveTupleAnnotations4FunctionDef_returns = Make.astSubscript(Make.astName('tuple'), Make.astTuple(listAnnotations))
-
-	ledgerDataclassANDFragments.addImportFromStr(logicalPathModule, dataclass_Identifier)
-
-	astName_dataclassesDOTdataclass = Make.astName(dataclass_Identifier)
-	astTuple4AssignTargetsToFragments: ast.Tuple = Make.astTuple(listNameDataclassFragments4Parameters, ast.Store())
-	astAssignDataclassRepack = Make.astAssign(listTargets=[Make.astName(instance_Identifier)], value=Make.astCall(astName_dataclassesDOTdataclass, list_astKeywords=list_keyword4DataclassInitialization))
-	return (astName_dataclassesDOTdataclass, ledgerDataclassANDFragments, listAnnAssign4DataclassUnpack,
-			astTuple4AssignTargetsToFragments, listNameDataclassFragments4Parameters, list_ast_argAnnotated4ArgumentsSpecification,
-			astSubscriptPrimitiveTupleAnnotations4FunctionDef_returns, astAssignDataclassRepack, list_keyword4DataclassInitialization)
-
-@overload
-def makeStateJob(listDimensions: Sequence[int], *, writeJob: Literal[True], **keywordArguments: Any) -> Path: ...
-@overload
-def makeStateJob(listDimensions: Sequence[int], *, writeJob: Literal[False], **keywordArguments: Any) -> ComputationState: ...
-def makeStateJob(listDimensions: Sequence[int], *, writeJob: bool = True, **keywordArguments: Any) -> ComputationState | Path:
-	"""
-	Creates a computation state job for map folding calculations and optionally saves it to disk.
-
-	This function initializes a computation state for map folding calculations based on the given dimensions,
-	sets up the initial counting configuration, and can optionally save the state to a pickle file.
-
-	Parameters:
-		listDimensions: List of integers representing the dimensions of the map to be folded.
-		writeJob (True): Whether to save the state to disk.
-		**keywordArguments: Additional keyword arguments to pass to the computation state initialization.
-
-	Returns:
-		stateUniversal|pathFilenameJob: The computation state for the map folding calculations, or
-			the path to the saved state file if writeJob is True.
-	"""
-	mapShape = validateListDimensions(listDimensions)
-	stateUniversal: ComputationState = outfitCountFolds(mapShape, **keywordArguments)
-
-	moduleSource: ModuleType = getSourceAlgorithm()
-	# TODO `countInitialize` is hardcoded
-	stateUniversal = moduleSource.countInitialize(stateUniversal)
-
-	if not writeJob:
-		return stateUniversal
-
-	pathFilenameChopChop = getPathFilenameFoldsTotal(stateUniversal.mapShape, None)
-	suffix = pathFilenameChopChop.suffix
-	pathJob = Path(str(pathFilenameChopChop)[0:-len(suffix)])
-	pathJob.mkdir(parents=True, exist_ok=True)
-	pathFilenameJob = pathJob / 'stateJob.pkl'
-
-	pathFilenameJob.write_bytes(pickle.dumps(stateUniversal))
-	return pathFilenameJob

mapFolding/syntheticModules/numbaCountHistoricalExample.py

@@ -1,158 +0,0 @@
-from mapFolding.theSSOT import indexMy, indexTrack
-from numba import uint16, prange, int64, jit
-from numpy import ndarray, dtype, integer
-from typing import Any
-
-@jit((uint16[:, :, ::1], uint16[::1], uint16[::1], uint16[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
-def countInitialize(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]], gapsWhere: ndarray[tuple[int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
-    while my[indexMy.leaf1ndex] > 0:
-        if my[indexMy.leaf1ndex] <= 1 or track[indexTrack.leafBelow, 0] == 1:
-            my[indexMy.dimensionsUnconstrained] = my[indexMy.dimensionsTotal]
-            my[indexMy.gap1ndexCeiling] = track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex] - 1]
-            my[indexMy.indexDimension] = 0
-            while my[indexMy.indexDimension] < my[indexMy.dimensionsTotal]:
-                if connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], my[indexMy.leaf1ndex]] == my[indexMy.leaf1ndex]:
-                    my[indexMy.dimensionsUnconstrained] -= 1
-                else:
-                    my[indexMy.leafConnectee] = connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], my[indexMy.leaf1ndex]]
-                    while my[indexMy.leafConnectee] != my[indexMy.leaf1ndex]:
-                        gapsWhere[my[indexMy.gap1ndexCeiling]] = my[indexMy.leafConnectee]
-                        if track[indexTrack.countDimensionsGapped, my[indexMy.leafConnectee]] == 0:
-                            my[indexMy.gap1ndexCeiling] += 1
-                        track[indexTrack.countDimensionsGapped, my[indexMy.leafConnectee]] += 1
-                        my[indexMy.leafConnectee] = connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], track[indexTrack.leafBelow, my[indexMy.leafConnectee]]]
-                my[indexMy.indexDimension] += 1
-            if not my[indexMy.dimensionsUnconstrained]:
-                my[indexMy.indexLeaf] = 0
-                while my[indexMy.indexLeaf] < my[indexMy.leaf1ndex]:
-                    gapsWhere[my[indexMy.gap1ndexCeiling]] = my[indexMy.indexLeaf]
-                    my[indexMy.gap1ndexCeiling] += 1
-                    my[indexMy.indexLeaf] += 1
-            my[indexMy.indexMiniGap] = my[indexMy.gap1ndex]
-            while my[indexMy.indexMiniGap] < my[indexMy.gap1ndexCeiling]:
-                gapsWhere[my[indexMy.gap1ndex]] = gapsWhere[my[indexMy.indexMiniGap]]
-                if track[indexTrack.countDimensionsGapped, gapsWhere[my[indexMy.indexMiniGap]]] == my[indexMy.dimensionsUnconstrained]:
-                    my[indexMy.gap1ndex] += 1
-                track[indexTrack.countDimensionsGapped, gapsWhere[my[indexMy.indexMiniGap]]] = 0
-                my[indexMy.indexMiniGap] += 1
-        if my[indexMy.leaf1ndex] > 0:
-            my[indexMy.gap1ndex] -= 1
-            track[indexTrack.leafAbove, my[indexMy.leaf1ndex]] = gapsWhere[my[indexMy.gap1ndex]]
-            track[indexTrack.leafBelow, my[indexMy.leaf1ndex]] = track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]]
-            track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]] = my[indexMy.leaf1ndex]
-            track[indexTrack.leafAbove, track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]] = my[indexMy.leaf1ndex]
-            track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex]] = my[indexMy.gap1ndex]
-            my[indexMy.leaf1ndex] += 1
-        if my[indexMy.gap1ndex] > 0:
-            return
-
-@jit((uint16[:, :, ::1], int64[::1], uint16[::1], uint16[::1], uint16[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=True)
-def countParallel(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[tuple[int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
-    gapsWherePARALLEL = gapsWhere.copy()
-    myPARALLEL = my.copy()
-    trackPARALLEL = track.copy()
-    taskDivisionsPrange = myPARALLEL[indexMy.taskDivisions]
-    for indexSherpa in prange(taskDivisionsPrange):
-        groupsOfFolds: int = 0
-        gapsWhere = gapsWherePARALLEL.copy()
-        my = myPARALLEL.copy()
-        track = trackPARALLEL.copy()
-        my[indexMy.taskIndex] = indexSherpa
-        while my[indexMy.leaf1ndex] > 0:
-            if my[indexMy.leaf1ndex] <= 1 or track[indexTrack.leafBelow, 0] == 1:
-                if my[indexMy.leaf1ndex] > foldGroups[-1]:
-                    groupsOfFolds += 1
-                else:
-                    my[indexMy.dimensionsUnconstrained] = my[indexMy.dimensionsTotal]
-                    my[indexMy.gap1ndexCeiling] = track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex] - 1]
-                    my[indexMy.indexDimension] = 0
-                    while my[indexMy.indexDimension] < my[indexMy.dimensionsTotal]:
-                        if connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], my[indexMy.leaf1ndex]] == my[indexMy.leaf1ndex]:
-                            my[indexMy.dimensionsUnconstrained] -= 1
-                        else:
-                            my[indexMy.leafConnectee] = connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], my[indexMy.leaf1ndex]]
-                            while my[indexMy.leafConnectee] != my[indexMy.leaf1ndex]:
-                                if my[indexMy.leaf1ndex] != my[indexMy.taskDivisions] or my[indexMy.leafConnectee] % my[indexMy.taskDivisions] == my[indexMy.taskIndex]:
-                                    gapsWhere[my[indexMy.gap1ndexCeiling]] = my[indexMy.leafConnectee]
-                                    if track[indexTrack.countDimensionsGapped, my[indexMy.leafConnectee]] == 0:
-                                        my[indexMy.gap1ndexCeiling] += 1
-                                    track[indexTrack.countDimensionsGapped, my[indexMy.leafConnectee]] += 1
-                                my[indexMy.leafConnectee] = connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], track[indexTrack.leafBelow, my[indexMy.leafConnectee]]]
-                        my[indexMy.indexDimension] += 1
-                    my[indexMy.indexMiniGap] = my[indexMy.gap1ndex]
-                    while my[indexMy.indexMiniGap] < my[indexMy.gap1ndexCeiling]:
-                        gapsWhere[my[indexMy.gap1ndex]] = gapsWhere[my[indexMy.indexMiniGap]]
-                        if track[indexTrack.countDimensionsGapped, gapsWhere[my[indexMy.indexMiniGap]]] == my[indexMy.dimensionsUnconstrained]:
-                            my[indexMy.gap1ndex] += 1
-                        track[indexTrack.countDimensionsGapped, gapsWhere[my[indexMy.indexMiniGap]]] = 0
-                        my[indexMy.indexMiniGap] += 1
-            while my[indexMy.leaf1ndex] > 0 and my[indexMy.gap1ndex] == track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex] - 1]:
-                my[indexMy.leaf1ndex] -= 1
-                track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]] = track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]
-                track[indexTrack.leafAbove, track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]] = track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]
-            if my[indexMy.leaf1ndex] > 0:
-                my[indexMy.gap1ndex] -= 1
-                track[indexTrack.leafAbove, my[indexMy.leaf1ndex]] = gapsWhere[my[indexMy.gap1ndex]]
-                track[indexTrack.leafBelow, my[indexMy.leaf1ndex]] = track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]]
-                track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]] = my[indexMy.leaf1ndex]
-                track[indexTrack.leafAbove, track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]] = my[indexMy.leaf1ndex]
-                track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex]] = my[indexMy.gap1ndex]
-                my[indexMy.leaf1ndex] += 1
-        foldGroups[my[indexMy.taskIndex]] = groupsOfFolds
-
-@jit((uint16[:, :, ::1], int64[::1], uint16[::1], uint16[::1], uint16[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=False)
-def countSequential(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[tuple[int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
-    leafBelow = track[indexTrack.leafBelow.value]
-    gapRangeStart = track[indexTrack.gapRangeStart.value]
-    countDimensionsGapped = track[indexTrack.countDimensionsGapped.value]
-    leafAbove = track[indexTrack.leafAbove.value]
-    leaf1ndex = my[indexMy.leaf1ndex.value]
-    dimensionsUnconstrained = my[indexMy.dimensionsUnconstrained.value]
-    dimensionsTotal = my[indexMy.dimensionsTotal.value]
-    gap1ndexCeiling = my[indexMy.gap1ndexCeiling.value]
-    indexDimension = my[indexMy.indexDimension.value]
-    leafConnectee = my[indexMy.leafConnectee.value]
-    indexMiniGap = my[indexMy.indexMiniGap.value]
-    gap1ndex = my[indexMy.gap1ndex.value]
-    taskIndex = my[indexMy.taskIndex.value]
-    groupsOfFolds: int = 0
-    while leaf1ndex > 0:
-        if leaf1ndex <= 1 or leafBelow[0] == 1:
-            if leaf1ndex > foldGroups[-1]:
-                groupsOfFolds += 1
-            else:
-                dimensionsUnconstrained = dimensionsTotal
-                gap1ndexCeiling = gapRangeStart[leaf1ndex - 1]
-                indexDimension = 0
-                while indexDimension < dimensionsTotal:
-                    leafConnectee = connectionGraph[indexDimension, leaf1ndex, leaf1ndex]
-                    if leafConnectee == leaf1ndex:
-                        dimensionsUnconstrained -= 1
-                    else:
-                        while leafConnectee != leaf1ndex:
-                            gapsWhere[gap1ndexCeiling] = leafConnectee
-                            if countDimensionsGapped[leafConnectee] == 0:
-                                gap1ndexCeiling += 1
-                            countDimensionsGapped[leafConnectee] += 1
-                            leafConnectee = connectionGraph[indexDimension, leaf1ndex, leafBelow[leafConnectee]]
-                    indexDimension += 1
-                indexMiniGap = gap1ndex
-                while indexMiniGap < gap1ndexCeiling:
-                    gapsWhere[gap1ndex] = gapsWhere[indexMiniGap]
-                    if countDimensionsGapped[gapsWhere[indexMiniGap]] == dimensionsUnconstrained:
-                        gap1ndex += 1
-                    countDimensionsGapped[gapsWhere[indexMiniGap]] = 0
-                    indexMiniGap += 1
-        while leaf1ndex > 0 and gap1ndex == gapRangeStart[leaf1ndex - 1]:
-            leaf1ndex -= 1
-            leafBelow[leafAbove[leaf1ndex]] = leafBelow[leaf1ndex]
-            leafAbove[leafBelow[leaf1ndex]] = leafAbove[leaf1ndex]
-        if leaf1ndex > 0:
-            gap1ndex -= 1
-            leafAbove[leaf1ndex] = gapsWhere[gap1ndex]
-            leafBelow[leaf1ndex] = leafBelow[leafAbove[leaf1ndex]]
-            leafBelow[leafAbove[leaf1ndex]] = leaf1ndex
-            leafAbove[leafBelow[leaf1ndex]] = leaf1ndex
-            gapRangeStart[leaf1ndex] = gap1ndex
-            leaf1ndex += 1
-    foldGroups[taskIndex] = groupsOfFolds

mapFolding/syntheticModules/numba_doTheNeedfulHistoricalExample.py

@@ -1,13 +0,0 @@
-from mapFolding import indexMy
-from mapFolding.syntheticModules.numbaCount import countInitialize, countSequential, countParallel
-from numba import uint16, int64, jit
-from numpy import ndarray, dtype, integer
-from typing import Any
-
-@jit((uint16[:, :, ::1], int64[::1], uint16[::1], uint16[::1], uint16[::1], uint16[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
-def doTheNeedful(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[tuple[int], dtype[integer[Any]]], mapShape: ndarray[tuple[int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
-    countInitialize(connectionGraph, gapsWhere, my, track)
-    if my[indexMy.taskDivisions] > 0:
-        countParallel(connectionGraph, foldGroups, gapsWhere, my, track)
-    else:
-        countSequential(connectionGraph, foldGroups, gapsWhere, my, track)