mapFolding 0.8.3__py3-none-any.whl → 0.8.5__py3-none-any.whl

mapFolding/someAssemblyRequired/synthesizeNumbaJobVESTIGIAL.py

@@ -1,413 +0,0 @@
-"""Synthesize one file to compute `foldsTotal` of `mapShape`."""
-from collections.abc import Sequence
-from typing import Any, cast, TYPE_CHECKING
-from mapFolding.filesystem import getFilenameFoldsTotal, getPathFilenameFoldsTotal
-from mapFolding.someAssemblyRequired import ( ifThis, LedgerOfImports, Make, NodeReplacer, Then, )
-from mapFolding.theSSOT import ( ComputationState, raiseIfNoneGitHubIssueNumber3, getPathJobRootDEFAULT, )
-from os import PathLike
-from pathlib import Path
-from types import ModuleType
-from Z0Z_tools import autoDecodingRLE
-import ast
-import python_minifier
-import autoflake
-import copy
-import inspect
-import numpy
-if TYPE_CHECKING:
-	from mapFolding.someAssemblyRequired.transformDataStructures import makeStateJobOUTDATED
-	from mapFolding.someAssemblyRequired.ingredientsNumba import thisIsNumbaDotJit, decorateCallableWithNumba
-	from mapFolding.someAssemblyRequired.ingredientsNumba import ParametersNumba, parametersNumbaDEFAULT
-
-def Z0Z_gamma(FunctionDefTarget: ast.FunctionDef, astAssignee: ast.Name, statement: ast.Assign | ast.stmt, identifier: str, arrayTarget: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.integer[Any]]], allImports: LedgerOfImports) -> tuple[ast.FunctionDef, LedgerOfImports]:
-	arrayType = type(arrayTarget)
-	moduleConstructor: str = arrayType.__module__
-	constructorName: str = arrayType.__name__.replace('ndarray', 'array') # NOTE hack
-	dataAsStrRLE: str = autoDecodingRLE(arrayTarget, addSpaces=True)
-	dataAs_astExpr: ast.expr = cast(ast.Expr, ast.parse(dataAsStrRLE).body[0]).value
-	dtypeName: str = identifier
-	dtypeAsName: str = f"{moduleConstructor}_{dtypeName}"
-	list_astKeywords: list[ast.keyword] = [ast.keyword(arg='dtype', value=ast.Name(id=dtypeAsName, ctx=ast.Load()))]
-	allImports.addImportFromStr(moduleConstructor, dtypeName, dtypeAsName)
-	astCall: ast.Call = Make.astCall(Make.astName(constructorName), [dataAs_astExpr], list_astKeywords)
-	assignment = ast.Assign(targets=[astAssignee], value=astCall)
-	FunctionDefTarget.body.insert(0, assignment)
-	FunctionDefTarget.body.remove(statement)
-	allImports.addImportFromStr(moduleConstructor, constructorName)
-	return FunctionDefTarget, allImports
-
-def insertArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arrayTarget: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.integer[Any]]], allImports: LedgerOfImports, unrollSlices: int | None = None) -> tuple[ast.FunctionDef, LedgerOfImports]:
-	def insertAssign(FunctionDefTarget: ast.FunctionDef, assignee: str, arraySlice: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.integer[Any]]], allImports: LedgerOfImports) -> tuple[ast.FunctionDef, LedgerOfImports]:
-		statement = ast.Assign(targets=[ast.Name(id='beans', ctx=ast.Load())], value=ast.Constant(value='and cornbread'))
-		FunctionDefTarget.body.insert(0, statement)
-		astAssignee = ast.Name(id=assignee, ctx=ast.Store())
-		return Z0Z_gamma(FunctionDefTarget, astAssignee, statement, identifier, arraySlice, allImports)
-
-	if not unrollSlices:
-		FunctionDefTarget, allImports = insertAssign(FunctionDefTarget, identifier, arrayTarget, allImports)
-	else:
-		for index, arraySlice in enumerate(arrayTarget):
-			FunctionDefTarget, allImports = insertAssign(FunctionDefTarget, f"{identifier}_{index}", arraySlice, allImports)
-
-	return FunctionDefTarget, allImports
-
-def findAndReplaceTrackArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arrayTarget: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.integer[Any]]], allImports: LedgerOfImports) -> tuple[ast.FunctionDef, LedgerOfImports]:
-	for statement in FunctionDefTarget.body.copy():
-		if True:
-			indexAsStr: str = ast.unparse(statement.value.slice) # type: ignore
-			arraySlice: numpy.ndarray[Any, numpy.dtype[numpy.integer[Any]]] = arrayTarget[eval(indexAsStr)]
-			astAssignee: ast.Name = cast(ast.Name, statement.targets[0]) # type: ignore
-			FunctionDefTarget, allImports = Z0Z_gamma(FunctionDefTarget, astAssignee, statement, identifier, arraySlice, allImports)
-	return FunctionDefTarget, allImports
-
-def findAndReplaceArraySubscriptIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arrayTarget: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.integer[Any]]], allImports: LedgerOfImports) -> tuple[ast.FunctionDef, LedgerOfImports]:
-	# parameter: I define moduleConstructor
-	moduleConstructor = 'numba'
-
-	for statement in FunctionDefTarget.body.copy():
-		if True:
-			indexAsStr: str = ast.unparse(statement.value.slice) # type: ignore
-			arraySlice: numpy.ndarray[Any, numpy.dtype[numpy.integer[Any]]] = arrayTarget[eval(indexAsStr)]
-			astAssignee: ast.Name = cast(ast.Name, statement.targets[0]) # type: ignore
-			arraySliceItem: int = arraySlice.item()
-			constructorName: str = astAssignee.id
-			dataAs_astExpr = ast.Constant(value=arraySliceItem)
-			list_astKeywords: list[ast.keyword] = []
-			astCall: ast.Call = Make.astCall(Make.astName(constructorName), [dataAs_astExpr], list_astKeywords)
-			assignment = ast.Assign(targets=[astAssignee], value=astCall)
-			FunctionDefTarget.body.insert(0, assignment)
-			FunctionDefTarget.body.remove(statement)
-			allImports.addImportFromStr(moduleConstructor, constructorName)
-	return FunctionDefTarget, allImports
-
-def removeAssignmentFrom_body(FunctionDefTarget: ast.FunctionDef, identifier: str) -> ast.FunctionDef:
-	FunctionDefSherpa: ast.AST | Sequence[ast.AST] | None = NodeReplacer(ifThis.isAnyAssignmentTo(identifier), Then.removeThis).visit(FunctionDefTarget)
-	if not FunctionDefSherpa:
-		raise raiseIfNoneGitHubIssueNumber3("Dude, where's my function?")
-	else:
-		FunctionDefTarget = cast(ast.FunctionDef, FunctionDefSherpa)
-	ast.fix_missing_locations(FunctionDefTarget)
-	return FunctionDefTarget
-
-def findAndReplaceAnnAssignIn_body(FunctionDefTarget: ast.FunctionDef, allImports: LedgerOfImports) -> tuple[ast.FunctionDef, LedgerOfImports]:
-	"""Unlike most of the other functions, this is generic: it tries to turn an annotation into a construction call."""
-	moduleConstructor: str = 'numba'
-	for stmt in FunctionDefTarget.body.copy():
-		if isinstance(stmt, ast.AnnAssign):
-			if isinstance(stmt.target, ast.Name) and isinstance(stmt.value, ast.Constant):
-				astAssignee: ast.Name = stmt.target
-				argData_dtypeName: str = astAssignee.id
-				allImports.addImportFromStr(moduleConstructor, argData_dtypeName)
-				astCall = ast.Call(func=ast.Name(id=argData_dtypeName, ctx=ast.Load()), args=[stmt.value], keywords=[])
-				assignment = ast.Assign(targets=[astAssignee], value=astCall)
-				FunctionDefTarget.body.insert(0, assignment)
-				FunctionDefTarget.body.remove(stmt)
-	return FunctionDefTarget, allImports
-
-def findThingyReplaceWithConstantIn_body(FunctionDefTarget: ast.FunctionDef, object: str, value: int) -> ast.FunctionDef:
-	"""
-	Replaces nodes in astFunction matching the AST of the string `object`
-	with a constant node holding the provided value.
-	"""
-	targetExpression: ast.expr = ast.parse(object, mode='eval').body
-	targetDump: str = ast.dump(targetExpression, annotate_fields=False)
-
-	def findNode(node: ast.AST) -> bool:
-		return ast.dump(node, annotate_fields=False) == targetDump
-
-	def replaceWithConstant(node: ast.AST) -> ast.AST:
-		return ast.copy_location(ast.Constant(value=value), node)
-
-	transformer = NodeReplacer(findNode, replaceWithConstant)
-	newFunction: ast.FunctionDef = cast(ast.FunctionDef, transformer.visit(FunctionDefTarget))
-	ast.fix_missing_locations(newFunction)
-	return newFunction
-
-def findAstNameReplaceWithConstantIn_body(FunctionDefTarget: ast.FunctionDef, name: str, value: int) -> ast.FunctionDef:
-	def replaceWithConstant(node: ast.AST) -> ast.AST:
-		return ast.copy_location(ast.Constant(value=value), node)
-
-	return cast(ast.FunctionDef, NodeReplacer(ifThis.isName_Identifier(name), replaceWithConstant).visit(FunctionDefTarget))
-
-def insertReturnStatementIn_body(FunctionDefTarget: ast.FunctionDef, arrayTarget: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.integer[Any]]], allImports: LedgerOfImports) -> tuple[ast.FunctionDef, LedgerOfImports]:
-	"""Add multiplication and return statement to function, properly constructing AST nodes."""
-	# Create AST for multiplication operation
-	multiplicand = 'Z0Z_identifierCountFolds'
-	multiplyOperation = ast.BinOp(
-		left=ast.Name(id=multiplicand, ctx=ast.Load()),
-		op=ast.Mult(), right=ast.Constant(value=int(arrayTarget[-1])))
-
-	returnStatement = ast.Return(value=multiplyOperation)
-
-	datatype: str = 'Z0Z_identifierCountFolds'
-	FunctionDefTarget.returns = ast.Name(id=datatype, ctx=ast.Load())
-	datatypeModuleScalar: str = 'numba'
-	allImports.addImportFromStr(datatypeModuleScalar, datatype)
-
-	FunctionDefTarget.body.append(returnStatement)
-
-	return FunctionDefTarget, allImports
-
-def findAndReplaceWhileLoopIn_body(FunctionDefTarget: ast.FunctionDef, iteratorName: str, iterationsTotal: int) -> ast.FunctionDef:
-	"""
-	Unroll all nested while loops matching the condition that their test uses `iteratorName`.
-	"""
-	# Helper transformer to replace iterator occurrences with a constant.
-	class ReplaceIterator(ast.NodeTransformer):
-		def __init__(self, iteratorName: str, constantValue: int) -> None:
-			super().__init__()
-			self.iteratorName: str = iteratorName
-			self.constantValue: int = constantValue
-
-		def visit_Name(self, node: ast.Name) -> ast.AST:
-			if node.id == self.iteratorName:
-				return ast.copy_location(ast.Constant(value=self.constantValue), node)
-			return self.generic_visit(node)
-
-	# NodeTransformer that finds while loops (even if deeply nested) and unrolls them.
-	class WhileLoopUnroller(ast.NodeTransformer):
-		def __init__(self, iteratorName: str, iterationsTotal: int) -> None:
-			super().__init__()
-			self.iteratorName: str = iteratorName
-			self.iterationsTotal: int = iterationsTotal
-
-		def visit_While(self, node: ast.While) -> list[ast.stmt]:
-				# Check if the while loop's test uses the iterator.
-			if isinstance(node.test, ast.Compare) and ifThis.isName_Identifier(self.iteratorName)(node.test.left):
-				# Recurse the while loop body and remove AugAssign that increments the iterator.
-				cleanBodyStatements: list[ast.stmt] = []
-				for loopStatement in node.body:
-					# Recursively visit nested statements.
-					visitedStatement = self.visit(loopStatement)
-					# Remove direct AugAssign: iterator += 1.
-					if (isinstance(loopStatement, ast.AugAssign) and
-						isinstance(loopStatement.target, ast.Name) and
-						loopStatement.target.id == self.iteratorName and
-						isinstance(loopStatement.op, ast.Add) and
-						isinstance(loopStatement.value, ast.Constant) and
-						loopStatement.value.value == 1):
-						continue
-					cleanBodyStatements.append(visitedStatement)
-
-				newStatements: list[ast.stmt] = []
-				# Unroll using the filtered body.
-				for iterationIndex in range(self.iterationsTotal):
-					for loopStatement in cleanBodyStatements:
-						copiedStatement: ast.stmt = copy.deepcopy(loopStatement)
-						replacer = ReplaceIterator(self.iteratorName, iterationIndex)
-						newStatement = replacer.visit(copiedStatement)
-						ast.fix_missing_locations(newStatement)
-						newStatements.append(newStatement)
-				# Optionally, process the orelse block.
-				if node.orelse:
-					for elseStmt in node.orelse:
-						visitedElse = self.visit(elseStmt)
-						if isinstance(visitedElse, list):
-							newStatements.extend(cast(list[ast.stmt], visitedElse))
-						else:
-							newStatements.append(visitedElse)
-				return newStatements
-			return [cast(ast.stmt, self.generic_visit(node))]
-
-	newFunctionDef = WhileLoopUnroller(iteratorName, iterationsTotal).visit(FunctionDefTarget)
-	ast.fix_missing_locations(newFunctionDef)
-	return newFunctionDef
-
-def makeLauncherTqdmJobNumba(callableTarget: str, pathFilenameFoldsTotal: Path, totalEstimated: int, leavesTotal:int) -> ast.Module:
-	linesLaunch: str = f"""
-if __name__ == '__main__':
-	with ProgressBar(total={totalEstimated}, update_interval=2) as statusUpdate:
-		{callableTarget}(statusUpdate)
-		foldsTotal = statusUpdate.n * {leavesTotal}
-		print("", foldsTotal)
-		writeStream = open('{pathFilenameFoldsTotal.as_posix()}', 'w')
-		writeStream.write(str(foldsTotal))
-		writeStream.close()
-"""
-	return ast.parse(linesLaunch)
-
-def makeLauncherBasicJobNumba(callableTarget: str, pathFilenameFoldsTotal: Path) -> ast.Module:
-	linesLaunch: str = f"""
-if __name__ == '__main__':
-	import time
-	timeStart = time.perf_counter()
-	foldsTotal = {callableTarget}()
-	print(foldsTotal, time.perf_counter() - timeStart)
-	writeStream = open('{pathFilenameFoldsTotal.as_posix()}', 'w')
-	writeStream.write(str(foldsTotal))
-	writeStream.close()
-"""
-	return ast.parse(linesLaunch)
-
-def doUnrollCountGaps(FunctionDefTarget: ast.FunctionDef, stateJob: ComputationState, allImports: LedgerOfImports) -> tuple[ast.FunctionDef, LedgerOfImports]:
-	"""The initial results were very bad."""
-	FunctionDefTarget = findAndReplaceWhileLoopIn_body(FunctionDefTarget, 'indexDimension', stateJob.dimensionsTotal)
-	FunctionDefTarget = removeAssignmentFrom_body(FunctionDefTarget, 'indexDimension')
-	FunctionDefTarget = removeAssignmentFrom_body(FunctionDefTarget, 'connectionGraph')
-	FunctionDefTarget, allImports = insertArrayIn_body(FunctionDefTarget, 'connectionGraph', stateJob.connectionGraph, allImports, stateJob.dimensionsTotal)
-	for index in range(stateJob.dimensionsTotal):
-		class ReplaceConnectionGraph(ast.NodeTransformer):
-			def visit_Subscript(self, node: ast.Subscript) -> ast.AST:
-				node = cast(ast.Subscript, self.generic_visit(node))
-				if (isinstance(node.value, ast.Name) and node.value.id == "connectionGraph" and
-					isinstance(node.slice, ast.Tuple) and len(node.slice.elts) >= 1):
-					firstElement: ast.expr = node.slice.elts[0]
-					if isinstance(firstElement, ast.Constant) and firstElement.value == index:
-						newName = ast.Name(id=f"connectionGraph_{index}", ctx=ast.Load())
-						remainingIndices: list[ast.expr] = node.slice.elts[1:]
-						if len(remainingIndices) == 1:
-							newSlice: ast.expr = remainingIndices[0]
-						else:
-							newSlice = ast.Tuple(elts=remainingIndices, ctx=ast.Load())
-						return ast.copy_location(ast.Subscript(value=newName, slice=newSlice, ctx=node.ctx), node)
-				return node
-		transformer = ReplaceConnectionGraph()
-		FunctionDefTarget = transformer.visit(FunctionDefTarget)
-	return FunctionDefTarget, allImports
-
-def writeJobNumba(mapShape: Sequence[int], algorithmSource: ModuleType, callableTarget: str | None = None, parametersNumba: ParametersNumba | None = None, pathFilenameWriteJob: str | PathLike[str] | None = None, unrollCountGaps: bool | None = False, Z0Z_totalEstimated: int = 0, **keywordArguments: Any | None) -> Path:
-	""" Parameters: **keywordArguments: most especially for `computationDivisions` if you want to make a parallel job. Also `CPUlimit`.
-	Notes:
-	Hypothetically, everything can now be configured with parameters and functions. And changing how the job is written is relatively easy.
-
-	Overview
-	- the code starts life in theDao.py, which has many optimizations; `makeNumbaOptimizedFlow` increase optimization especially by using numba; `writeJobNumba` 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 `writeJobNumba` 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 and able to handle upstream and downstream changes
-
-	Minutia
-	- perf_counter is for testing. When I run a real job, I delete those lines
-	- avoid `with` statement
-
-	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
-	"""
-
-	# NOTE get the raw ingredients: data and the algorithm
-	stateJob = makeStateJobOUTDATED(mapShape, writeJob=False, **keywordArguments)
-	pythonSource: str = inspect.getsource(algorithmSource)
-	astModule: ast.Module = ast.parse(pythonSource)
-	setFunctionDef: set[ast.FunctionDef] = {statement for statement in astModule.body if isinstance(statement, ast.FunctionDef)}
-
-	if not callableTarget:
-		if len(setFunctionDef) == 1:
-			FunctionDefTarget = setFunctionDef.pop()
-			callableTarget = FunctionDefTarget.name
-		else:
-			raise ValueError(f"I did not receive a `callableTarget` and {algorithmSource.__name__=} has more than one callable: {setFunctionDef}. Please select one.")
-	else:
-		listFunctionDefTarget: list[ast.FunctionDef] = [statement for statement in setFunctionDef if statement.name == callableTarget]
-		FunctionDefTarget = listFunctionDefTarget[0] if listFunctionDefTarget else None # type: ignore
-	if not FunctionDefTarget: raise ValueError(f"I received `{callableTarget=}` and {algorithmSource.__name__=}, but I could not find that function in that source.")
-
-	# NOTE `allImports` is a complementary container to `FunctionDefTarget`; the `FunctionDefTarget` cannot track its own imports very well.
-	allImports = LedgerOfImports(astModule)
-
-	# NOTE remove the parameters from the function signature
-	for pirateScowl in FunctionDefTarget.args.args.copy():
-		match pirateScowl.arg:
-			case 'connectionGraph':
-				FunctionDefTarget, allImports = insertArrayIn_body(FunctionDefTarget, pirateScowl.arg, stateJob.connectionGraph, allImports)
-			case 'gapsWhere':
-				FunctionDefTarget, allImports = insertArrayIn_body(FunctionDefTarget, pirateScowl.arg, stateJob.gapsWhere, allImports)
-			case 'foldGroups':
-				FunctionDefTarget = removeAssignmentFrom_body(FunctionDefTarget, pirateScowl.arg)
-			case _:
-				pass
-		FunctionDefTarget.args.args.remove(pirateScowl)
-
-	identifierCounter = 'Z0Z_identifierCountFolds'
-	astExprIncrementCounter = ast.Expr(value = Make.astCall(Make.nameDOTname(identifierCounter, 'update'), listArguments=[ast.Constant(value=1)], list_astKeywords=[]))
-	FunctionDefTarget= cast(ast.FunctionDef, NodeReplacer(ifThis.isAugAssignTo(identifierCounter), Then.replaceWith(astExprIncrementCounter)).visit(FunctionDefTarget))
-	ast.fix_missing_locations(FunctionDefTarget)
-
-	for assignmentTarget in ['taskIndex', 'dimensionsTotal', identifierCounter]:
-		FunctionDefTarget = removeAssignmentFrom_body(FunctionDefTarget, assignmentTarget)
-	# NOTE replace identifiers with static values with their values
-	FunctionDefTarget = findAstNameReplaceWithConstantIn_body(FunctionDefTarget, 'dimensionsTotal', int(stateJob.dimensionsTotal))
-	FunctionDefTarget = findThingyReplaceWithConstantIn_body(FunctionDefTarget, 'foldGroups[-1]', int(stateJob.foldGroups[-1]))
-
-	# NOTE an attempt at optimization
-	if unrollCountGaps:
-		FunctionDefTarget, allImports = doUnrollCountGaps(FunctionDefTarget, stateJob, allImports)
-
-	# NOTE starting the count and printing the total
-	pathFilenameFoldsTotal: Path = getPathFilenameFoldsTotal(stateJob.mapShape)
-
-	astLauncher: ast.Module = makeLauncherBasicJobNumba(FunctionDefTarget.name, pathFilenameFoldsTotal)
-
-	# TODO create function for assigning value to `totalEstimated`
-	totalEstimated: int = Z0Z_totalEstimated
-	astLauncher = makeLauncherTqdmJobNumba(FunctionDefTarget.name, pathFilenameFoldsTotal, totalEstimated, stateJob.foldGroups[-1])
-
-	allImports.addImportFromStr('numba_progress', 'ProgressBar')
-	allImports.addImportFromStr('numba_progress', 'ProgressBarType')
-
-	# add ProgressBarType parameter to function args
-	counterArg = ast.arg(arg=identifierCounter, annotation=ast.Name(id='ProgressBarType', ctx=ast.Load()))
-	FunctionDefTarget.args.args.append(counterArg)
-
-	if parametersNumba is None:
-		parametersNumba = parametersNumbaDEFAULT
-	parametersNumba['nogil'] = True
-
-	FunctionDefTarget, allImports = insertReturnStatementIn_body(FunctionDefTarget, stateJob.foldGroups, allImports)
-
-	FunctionDefTarget, allImports = findAndReplaceAnnAssignIn_body(FunctionDefTarget, allImports)
-	# NOTE add the perfect decorator
-	if thisIsNumbaDotJit(FunctionDefTarget.decorator_list[0]):
-		astCall: ast.Call = cast(ast.Call, FunctionDefTarget.decorator_list[0])
-		astCall.func = ast.Name(id='jit', ctx=ast.Load())
-		FunctionDefTarget.decorator_list[0] = astCall
-
-	# NOTE add imports, make str, remove unused imports
-	astImports: list[ast.ImportFrom | ast.Import] = allImports.makeListAst()
-	astModule = ast.Module(body=cast(list[ast.stmt], astImports + [FunctionDefTarget] + [astLauncher]), type_ignores=[])
-	ast.fix_missing_locations(astModule)
-	pythonSource = ast.unparse(astModule)
-	pythonSource = autoflake.fix_code(pythonSource, ['mapFolding', 'numba', 'numpy'])
-	pythonSource = python_minifier.minify(pythonSource, remove_annotations = False, remove_pass = False, remove_literal_statements = False, combine_imports = True, hoist_literals = False, rename_locals = False, rename_globals = False, remove_object_base = False, convert_posargs_to_args = False, preserve_shebang = True, remove_asserts = False, remove_debug = False, remove_explicit_return_none = False, remove_builtin_exception_brackets = False, constant_folding = False)
-
-	# NOTE put on disk
-	if pathFilenameWriteJob is None:
-		filename: str = getFilenameFoldsTotal(stateJob.mapShape)
-		pathRoot: Path = getPathJobRootDEFAULT()
-		pathFilenameWriteJob = Path(pathRoot, Path(filename).stem, Path(filename).with_suffix('.py'))
-	else:
-		pathFilenameWriteJob = Path(pathFilenameWriteJob)
-	pathFilenameWriteJob.parent.mkdir(parents=True, exist_ok=True)
-
-	pathFilenameWriteJob.write_text(pythonSource)
-
-	return pathFilenameWriteJob
-
-if __name__ == '__main__':
-	mapShape: list[int] = [5,5]
-	dictionaryEstimates: dict[tuple[int, ...], int] = {
-		(2,2,2,2,2,2,2,2): 362794844160000,
-		(2,21): 1493028892051200,
-		(3,15): 9842024675968800,
-		(3,3,3,3,3): 85109616000000,
-		(3,3,3,3): 85109616000,
-		(8,8): 129950723279272000,
-	}
-
-	totalEstimated: int = dictionaryEstimates.get(tuple(mapShape), 10**8)
-	from mapFolding.syntheticModules import numbaCount_doTheNeedful
-	algorithmSource: ModuleType = numbaCount_doTheNeedful
-
-	callableTarget = 'countSequential'
-
-	parametersNumba: ParametersNumba = parametersNumbaDEFAULT
-	parametersNumba['nogil'] = True
-	parametersNumba['boundscheck'] = False
-
-	pathFilenameWriteJob = None
-
-	writeJobNumba(mapShape, algorithmSource, callableTarget, parametersNumba, pathFilenameWriteJob, Z0Z_totalEstimated=totalEstimated)

mapFolding/someAssemblyRequired/transformDataStructures.py

@@ -1,168 +0,0 @@
-"""
-Utilities for transforming complex data structures in Python code generation.
-
-This module provides specialized tools for working with structured data types during
-the code transformation process, with a particular focus on handling dataclasses. It
-implements functionality that enables:
-
-1. Decomposing dataclasses into individual fields for efficient processing
-2. Creating optimized parameter passing for transformed functions
-3. Converting between different representations of data structures
-4. Serializing and deserializing computation state objects
-
-The core functionality revolves around the "shattering" process that breaks down
-a dataclass into its constituent components, making each field individually accessible
-for code generation and optimization purposes. This dataclass handling is critical for
-transforming algorithms that operate on unified state objects into optimized implementations
-that work with primitive types directly.
-
-While developed for transforming map folding computation state objects, the utilities are
-designed to be applicable to various data structure transformation scenarios.
-"""
-
-from collections.abc import Sequence
-from importlib import import_module as importlib_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, The
-from pathlib import Path
-from types import ModuleType
-from typing import Any, Literal, overload
-import ast
-import dataclasses
-import pickle
-
-# Would `LibCST` be better than `ast` in some cases? https://github.com/hunterhogan/mapFolding/issues/7
-
-countingIdentifierHARDCODED = 'groupsOfFolds'
-
-@dataclasses.dataclass
-class ShatteredDataclass:
-	astAssignDataclassRepack: ast.Assign
-	astSubscriptPrimitiveTupleAnnotations4FunctionDef_returns: ast.Subscript
-	astTuple4AssignTargetsToFragments: ast.Tuple
-	countingVariableAnnotation: ast.expr
-	countingVariableName: ast.Name
-	ledgerDataclassANDFragments: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
-	list_ast_argAnnotated4ArgumentsSpecification: list[ast.arg] = dataclasses.field(default_factory=list)
-	list_keyword4DataclassInitialization: list[ast.keyword] = dataclasses.field(default_factory=list)
-	listAnnAssign4DataclassUnpack: list[ast.AnnAssign] = dataclasses.field(default_factory=list)
-	listAnnotations: list[ast.expr] = dataclasses.field(default_factory=list)
-	listNameDataclassFragments4Parameters: list[ast.Name] = dataclasses.field(default_factory=list)
-
-def shatter_dataclassesDOTdataclass(logicalPathModule: strDotStrCuzPyStoopid, dataclass_Identifier: ast_Identifier, instance_Identifier: ast_Identifier) -> ShatteredDataclass:
-	"""
-	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.
-	"""
-	# TODO learn whether dataclasses.make_dataclass would be useful to transform the target dataclass into the `ShatteredDataclass`
-
-	module: ast.Module = ast.parse(inspect_getsource(importlib_import_module(logicalPathModule)))
-	astName_dataclassesDOTdataclass = Make.astName(dataclass_Identifier)
-
-	dataclass = extractClassDef(module, dataclass_Identifier)
-	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] = []
-
-	# TODO get the value from `groupsOfFolds: DatatypeFoldsTotal = dataclasses.field(default=DatatypeFoldsTotal(0), metadata={'theCountingIdentifier': True})`
-	countingVariable = countingIdentifierHARDCODED
-
-	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
-
-	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
-			]
-		).visit(dataclass)
-
-	shatteredDataclass = ShatteredDataclass(
-	astAssignDataclassRepack = Make.astAssign(listTargets=[Make.astName(instance_Identifier)], value=Make.astCall(astName_dataclassesDOTdataclass, list_astKeywords=list_keyword4DataclassInitialization))
-	, astSubscriptPrimitiveTupleAnnotations4FunctionDef_returns = Make.astSubscript(Make.astName('tuple'), Make.astTuple(listAnnotations))
-	, astTuple4AssignTargetsToFragments = Make.astTuple(listNameDataclassFragments4Parameters, ast.Store())
-	, countingVariableAnnotation = next(ast_arg.annotation for ast_arg in list_ast_argAnnotated4ArgumentsSpecification if ast_arg.arg == countingVariable) or Make.astName('Any')
-	, countingVariableName = Make.astName(countingVariable)
-	, ledgerDataclassANDFragments = ledgerDataclassANDFragments
-	, list_ast_argAnnotated4ArgumentsSpecification = list_ast_argAnnotated4ArgumentsSpecification
-	, list_keyword4DataclassInitialization = list_keyword4DataclassInitialization
-	, listAnnAssign4DataclassUnpack = listAnnAssign4DataclassUnpack
-	, listAnnotations = listAnnotations
-	, listNameDataclassFragments4Parameters = listNameDataclassFragments4Parameters
-	)
-
-	shatteredDataclass.ledgerDataclassANDFragments.addImportFromStr(logicalPathModule, dataclass_Identifier)
-	return shatteredDataclass
-
-def getSourceAlgorithmVESTIGIAL() -> ModuleType:
-	moduleImported: ModuleType = importlib_import_module(The.logicalPathModuleSourceAlgorithm)
-	return moduleImported
-
-@overload
-def makeStateJobOUTDATED(listDimensions: Sequence[int], *, writeJob: Literal[True], **keywordArguments: Any) -> Path: ...
-@overload
-def makeStateJobOUTDATED(listDimensions: Sequence[int], *, writeJob: Literal[False], **keywordArguments: Any) -> ComputationState: ...
-def makeStateJobOUTDATED(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 = getSourceAlgorithmVESTIGIAL()
-	# 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-0.8.3.dist-info/RECORD

@@ -1,43 +0,0 @@
-mapFolding/__init__.py,sha256=XRcskvsF7PTdsNOWWeR1FhQLA3fyBUScCqdfxYhAy8c,1998
-mapFolding/basecamp.py,sha256=uPwbb_fi8zqqBbVjb355qanSNUqqJ9aefcf_nrvA7qI,4510
-mapFolding/beDRY.py,sha256=UhH52BryHQNRjphf_PirtMkV45rhdemdC9PmnpACq7I,9397
-mapFolding/filesystem.py,sha256=-pYpWugd0p3TrAz7xf9YIJW-pn1X-iRCGtJgEAF9Rns,5923
-mapFolding/noHomeYet.py,sha256=UKZeWlyn0SKlF9dhYoud7E6gWXpiSEekZOOoJp88WeI,1362
-mapFolding/oeis.py,sha256=TbY8KtAGbQlT6eEsa_7HVMF7bMLN-aBFKclyTMHfqHk,12615
-mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mapFolding/theDao.py,sha256=Blzm5j24x1BE2nvgXjdzHEeuc2na6kAH9b_eP6PcwlI,9836
-mapFolding/theSSOT.py,sha256=DH0so-BVQm8RrBrqhehRC9spmb5Gg1vFegbMSeeoMcM,12236
-mapFolding/reference/__init__.py,sha256=UIEU8BJR_YDzjFQcLel3XtHzOCJiOUGlGiWzOzbvhik,2206
-mapFolding/reference/flattened.py,sha256=QK1xG9SllqCoi68e86Hyl9d9ATUAAFNpTQI-3zmcp5I,16072
-mapFolding/reference/hunterNumba.py,sha256=espFiX92EPZ1Ub1YQVoBnNYvh2kFg1HR6Qa4djx8Ixg,7253
-mapFolding/reference/irvineJavaPort.py,sha256=UEfIX4QbPLl5jnyfYIyX5YRR3_rYvPUikK8jLehsFko,4076
-mapFolding/reference/jaxCount.py,sha256=TuDNKOnyhQfuixKmIxO9Algv7dvy7KMGhgsV3h96FGE,14853
-mapFolding/reference/lunnanNumpy.py,sha256=mMgrgbrBpe4nmo72ThEI-MGH0OwEHmfMPczSXHp2qKo,4357
-mapFolding/reference/lunnanWhile.py,sha256=ZL8GAQtPs5nJZSgoDl5USrLSS_zs03y98y1Z9E4jOmQ,3799
-mapFolding/reference/rotatedEntryPoint.py,sha256=5ughpKUT2JQhoAKgoDUdYNjgWQYPGV8v-7dWEAdDmfE,10274
-mapFolding/reference/total_countPlus1vsPlusN.py,sha256=yJZAVLVdoXqHag2_N6_6CT-Q6HXBgRro-eny93-Rlpw,9307
-mapFolding/reference/jobsCompleted/__init__.py,sha256=TU93ZGUW1xEkT6d9mQFn_rp5DvRy0ZslEB2Q6MF5ZDc,2596
-mapFolding/reference/jobsCompleted/[2x19]/p2x19.py,sha256=_tvYtfzMWVo2VtUbIAieoscb4N8FFflgTdW4-ljBUuA,19626
-mapFolding/reference/jobsCompleted/p2x19/p2x19.py,sha256=eZEw4Me4ocTt6VXoK2-Sbd5SowZtxRIbN9dZmc7OCVg,6395
-mapFolding/someAssemblyRequired/__init__.py,sha256=xA5a-nZjXIwcqEOig5PEZSxde4_m3JJ5Pb0CN4aiRjw,2488
-mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=CDbesDJSQE-P8uznXIAttRw9f413UpUt-RowK38hqbY,2735
-mapFolding/someAssemblyRequired/ingredientsNumba.py,sha256=g6Z7t35NpoDskzm0OLwTQhHw5CYiYktVYxI2NhCQHww,8435
-mapFolding/someAssemblyRequired/synthesizeNumbaFlow.py,sha256=scEozf2dy4pvrRMtQSycZf3RkNJtYLGKQVDhN6_H8_4,11812
-mapFolding/someAssemblyRequired/synthesizeNumbaJobVESTIGIAL.py,sha256=RBSrtr7US2P7mkY-EA-b2WIOxjs2b0WJaCln1ERxOcI,22314
-mapFolding/someAssemblyRequired/transformDataStructures.py,sha256=ssgnGpO4Z8tfdep-lzeodua8ZxA0qvjIwDGv6wbP_ew,8605
-mapFolding/someAssemblyRequired/transformationTools.py,sha256=_m4i6TylMBCkh-f-LPAtUIzHhZm4nhyuQOceK3yNwIo,41067
-mapFolding/syntheticModules/__init__.py,sha256=evVFqhCGa-WZKDiLcnQWjs-Bj34eRnfSLqz_d7dFYZY,83
-mapFolding/syntheticModules/numbaCount_doTheNeedful.py,sha256=52RuwJVH2fROvWU2dT8wYcQvLgRuvkNZPq01kujCC_U,15725
-mapfolding-0.8.3.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/conftest.py,sha256=hTpUTW7MtYGP5aeQnnoZMKgTEGCKdLJ8Fnmnv9d4NJw,11115
-tests/test_computations.py,sha256=RHHByyuC8w-qbaag4Iqo_QNYm_7A-9BslbstMOdbZbU,3329
-tests/test_filesystem.py,sha256=Kou0gj5T72oISao6umYfU6L_W5Hi7QS9_IxTv2hU0Pw,3147
-tests/test_oeis.py,sha256=uxvwmgbnylSDdsVJfuAT0LuYLbIVFwSgdLxHm-xUGBM,5043
-tests/test_other.py,sha256=AzsCXiX8x5WJ7i0SocWQY6lT30IJg1lKoybx03X2eqU,4281
-tests/test_tasks.py,sha256=hkZygihT8bCEO2zc-2VcxReQrZJBwgLNbYx0YP4lTDg,2853
-mapfolding-0.8.3.dist-info/METADATA,sha256=LPHFjXnPJA3N4TmHLA7EAEL20sRrjMatn-kxmL1_118,9286
-mapfolding-0.8.3.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-mapfolding-0.8.3.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapfolding-0.8.3.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapfolding-0.8.3.dist-info/RECORD,,