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

mapFolding/someAssemblyRequired/Z0Z_workbench.py

@@ -0,0 +1,34 @@
+from mapFolding.someAssemblyRequired.synthesizeDataConverters import makeStateJob
+from mapFolding.someAssemblyRequired.synthesizeDataConverters import makeDataclassConverter
+from mapFolding.someAssemblyRequired.whatWillBe import IngredientsFunction, IngredientsModule, numbaFlow
+from mapFolding.someAssemblyRequired.synthesizeCountingFunctions import Z0Z_makeCountingFunction
+import ast
+
+if __name__ == '__main__':
+	ingredientsFunctionDataConverter = makeDataclassConverter(
+		dataclassIdentifierAsStr=numbaFlow.dataclassIdentifierAsStr
+		, logicalPathModuleDataclass=numbaFlow.logicalPathModuleDataclass
+		, dataclassInstanceAsStr=numbaFlow.dataclassInstanceAsStr
+
+		, dispatcherCallableAsStr=numbaFlow.dispatcherCallableAsStr
+		, logicalPathModuleDispatcher=numbaFlow.logicalPathModuleDispatcher
+		, dataConverterCallableAsStr=numbaFlow.dataConverterCallableAsStr
+		)
+
+	# initialize with theDao
+	dataInitializationHack = "state=makeStateJob(state.mapShape,writeJob=False)"
+	ingredientsFunctionDataConverter.FunctionDef.body.insert(0, ast.parse(dataInitializationHack).body[0])
+	ingredientsFunctionDataConverter.imports.addImportFromStr('mapFolding.someAssemblyRequired', 'makeStateJob')
+
+	ingredientsSequential = Z0Z_makeCountingFunction(numbaFlow.sequentialCallableAsStr
+													, numbaFlow.sourceAlgorithm
+													, inline=True
+													, dataclass=False)
+
+	ingredientsModuleDataConverter = IngredientsModule(
+		name=numbaFlow.dataConverterModule,
+		ingredientsFunction=ingredientsFunctionDataConverter,
+		logicalPathINFIX=numbaFlow.moduleOfSyntheticModules,
+	)
+
+	ingredientsModuleDataConverter.writeModule()

mapFolding/someAssemblyRequired/__init__.py

@@ -0,0 +1,16 @@
+from mapFolding.someAssemblyRequired.whatWillBe import (
+	ast_Identifier as ast_Identifier,
+	extractClassDef as extractClassDef,
+	extractFunctionDef as extractFunctionDef,
+	executeActionUnlessDescendantMatches as executeActionUnlessDescendantMatches,
+	ifThis as ifThis,
+	IngredientsFunction as IngredientsFunction,
+	IngredientsModule as IngredientsModule,
+	LedgerOfImports as LedgerOfImports,
+	listNumbaCallableDispatchees as listNumbaCallableDispatchees,
+	Make as Make,
+	NodeCollector as NodeCollector,
+	NodeReplacer as NodeReplacer,
+	strDotStrCuzPyStoopid as strDotStrCuzPyStoopid,
+	Then as Then,
+	)

mapFolding/someAssemblyRequired/getLLVMforNoReason.py

@@ -0,0 +1,21 @@
+import importlib
+from importlib.machinery import ModuleSpec
+from types import ModuleType
+import importlib.util
+import llvmlite.binding
+import pathlib
+
+def writeModuleLLVM(pathFilename: pathlib.Path, identifierCallable: str) -> pathlib.Path:
+	"""Import the generated module directly and get its LLVM IR."""
+	specTarget: ModuleSpec | None = importlib.util.spec_from_file_location("generatedModule", pathFilename)
+	if specTarget is None or specTarget.loader is None:
+		raise ImportError(f"Could not create module spec or loader for {pathFilename}")
+	moduleTarget: ModuleType = importlib.util.module_from_spec(specTarget)
+	specTarget.loader.exec_module(moduleTarget)
+
+	# Get LLVM IR and write to file
+	linesLLVM = moduleTarget.__dict__[identifierCallable].inspect_llvm()[()]
+	moduleLLVM: llvmlite.binding.ModuleRef = llvmlite.binding.module.parse_assembly(linesLLVM)
+	pathFilenameLLVM: pathlib.Path = pathFilename.with_suffix(".ll")
+	pathFilenameLLVM.write_text(str(moduleLLVM))
+	return pathFilenameLLVM

mapFolding/someAssemblyRequired/ingredientsNumba.py

@@ -0,0 +1,100 @@
+from collections.abc import Callable
+from numba.core.compiler import CompilerBase as numbaCompilerBase
+from typing import Any, TYPE_CHECKING, Final
+
+try:
+	from typing import NotRequired
+except Exception:
+	from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+	from typing import TypedDict
+else:
+	TypedDict = dict
+
+class ParametersNumba(TypedDict):
+	_dbg_extend_lifetimes: NotRequired[bool]
+	_dbg_optnone: NotRequired[bool]
+	_nrt: NotRequired[bool]
+	boundscheck: NotRequired[bool]
+	cache: bool
+	debug: NotRequired[bool]
+	error_model: str
+	fastmath: bool
+	forceinline: bool
+	forceobj: NotRequired[bool]
+	inline: str
+	locals: NotRequired[dict[str, Any]]
+	looplift: bool
+	no_cfunc_wrapper: bool
+	no_cpython_wrapper: bool
+	no_rewrites: NotRequired[bool]
+	nogil: NotRequired[bool]
+	nopython: bool
+	parallel: bool
+	pipeline_class: NotRequired[type[numbaCompilerBase]]
+	signature_or_function: NotRequired[Any | Callable[..., Any] | str | tuple[Any, ...]]
+	target: NotRequired[str]
+
+parametersNumbaFailEarly: Final[ParametersNumba] = {
+		'_nrt': True,
+		'boundscheck': True,
+		'cache': True,
+		'error_model': 'python',
+		'fastmath': False,
+		'forceinline': True,
+		'inline': 'always',
+		'looplift': False,
+		'no_cfunc_wrapper': False,
+		'no_cpython_wrapper': False,
+		'nopython': True,
+		'parallel': False, }
+"""For a production function: speed is irrelevant, error discovery is paramount, must be compatible with anything downstream."""
+
+parametersNumbaDEFAULT: Final[ParametersNumba] = {
+		'_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, }
+"""Middle of the road: fast, lean, but will talk to non-jitted functions."""
+
+parametersNumbaParallelDEFAULT: Final[ParametersNumba] = {
+		**parametersNumbaDEFAULT,
+		'_nrt': True,
+		'parallel': True, }
+"""Middle of the road: fast, lean, but will talk to non-jitted functions."""
+
+parametersNumbaSuperJit: Final[ParametersNumba] = {
+		**parametersNumbaDEFAULT,
+		'no_cfunc_wrapper': True,
+		'no_cpython_wrapper': True, }
+"""Speed, no helmet, no talking to non-jitted functions."""
+
+parametersNumbaSuperJitParallel: Final[ParametersNumba] = {
+		**parametersNumbaSuperJit,
+		'_nrt': True,
+		'parallel': True, }
+"""Speed, no helmet, concurrency, no talking to non-jitted functions."""
+
+parametersNumbaMinimum: Final[ParametersNumba] = {
+		'_nrt': True,
+		'boundscheck': True,
+		'cache': True,
+		'error_model': 'numpy',
+		'fastmath': True,
+		'forceinline': False,
+		'inline': 'always',
+		'looplift': False,
+		'no_cfunc_wrapper': False,
+		'no_cpython_wrapper': False,
+		'nopython': False,
+		'forceobj': True,
+		'parallel': False, }

mapFolding/someAssemblyRequired/synthesizeCountingFunctions.py

@@ -0,0 +1,7 @@
+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/synthesizeDataConverters.py

@@ -0,0 +1,135 @@
+from collections.abc import Sequence
+from importlib import import_module
+from inspect import getsource as inspect_getsource
+from pathlib import Path
+from types import ModuleType
+from typing import Any, cast, overload, Literal
+import ast
+import pickle
+from mapFolding.beDRY import ComputationState, outfitCountFolds, validateListDimensions
+from mapFolding.filesystem import getPathFilenameFoldsTotal
+from mapFolding.someAssemblyRequired import (
+	ast_Identifier,
+	executeActionUnlessDescendantMatches,
+	extractClassDef,
+	ifThis,
+	IngredientsFunction,
+	LedgerOfImports,
+	Make,
+	NodeCollector,
+	strDotStrCuzPyStoopid,
+	Then,
+)
+from mapFolding.theSSOT import getSourceAlgorithm
+
+def shatter_dataclassesDOTdataclass(logicalPathModule: strDotStrCuzPyStoopid, dataclass_Identifier: ast_Identifier, instance_Identifier: ast_Identifier
+									) -> tuple[ast.Name, LedgerOfImports, list[ast.AnnAssign], list[ast.Name], list[ast.keyword], ast.Tuple]:
+	"""
+	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=}.")
+
+	list_astAnnAssign: list[ast.AnnAssign] = []
+	listKeywordForDataclassInitialization: list[ast.keyword] = []
+	list_astNameDataclassFragments: list[ast.Name] = []
+	ledgerDataclassAndFragments = LedgerOfImports()
+
+	addToLedgerPredicate = ifThis.isAnnAssignAndAnnotationIsName
+	addToLedgerAction = Then.Z0Z_ledger(logicalPathModule, ledgerDataclassAndFragments)
+	addToLedger = NodeCollector(addToLedgerPredicate, [addToLedgerAction])
+
+	exclusionPredicate = ifThis.is_keyword_IdentifierEqualsConstantValue('init', False)
+	appendKeywordAction = Then.Z0Z_appendKeywordMirroredTo(listKeywordForDataclassInitialization)
+	filteredAppendKeywordAction = executeActionUnlessDescendantMatches(exclusionPredicate, appendKeywordAction)
+
+	collector = NodeCollector(
+			ifThis.isAnnAssignAndTargetIsName,
+				[Then.Z0Z_appendAnnAssignOfNameDOTnameTo(instance_Identifier, list_astAnnAssign)
+				, Then.append_targetTo(list_astNameDataclassFragments)
+				, lambda node: addToLedger.visit(node)
+				, filteredAppendKeywordAction
+				]
+			)
+
+	collector.visit(dataclass)
+
+	ledgerDataclassAndFragments.addImportFromStr(logicalPathModule, dataclass_Identifier)
+
+	astNameDataclass = Make.astName(dataclass_Identifier)
+	astTupleForAssignTargetsToFragments: ast.Tuple = Make.astTuple(list_astNameDataclassFragments, ast.Store())
+	return astNameDataclass, ledgerDataclassAndFragments, list_astAnnAssign, list_astNameDataclassFragments, listKeywordForDataclassInitialization, astTupleForAssignTargetsToFragments
+
+def makeDataclassConverter(dataclassIdentifierAsStr: str,
+		logicalPathModuleDataclass: str,
+		dataclassInstanceAsStr: str,
+		dispatcherCallableAsStr: str,
+		logicalPathModuleDispatcher: str,
+		dataConverterCallableAsStr: str,
+		) -> IngredientsFunction:
+
+	astNameDataclass, ledgerDataclassAndFragments, list_astAnnAssign, list_astNameDataclassFragments, list_astKeywordDataclassFragments, astTupleForAssignTargetsToFragments = shatter_dataclassesDOTdataclass(logicalPathModuleDataclass, dataclassIdentifierAsStr, dataclassInstanceAsStr)
+
+	ingredientsFunction = IngredientsFunction(
+		FunctionDef = Make.astFunctionDef(name=dataConverterCallableAsStr
+										, argumentsSpecification=Make.astArgumentsSpecification(args=[Make.astArg(dataclassInstanceAsStr, astNameDataclass)])
+										, body = cast(list[ast.stmt], list_astAnnAssign)
+										, returns = astNameDataclass
+										)
+		, imports = ledgerDataclassAndFragments
+	)
+
+	callToDispatcher = Make.astAssign(listTargets=[astTupleForAssignTargetsToFragments]
+										, value=Make.astCall(Make.astName(dispatcherCallableAsStr), args=list_astNameDataclassFragments))
+	ingredientsFunction.FunctionDef.body.append(callToDispatcher)
+	ingredientsFunction.imports.addImportFromStr(logicalPathModuleDispatcher, dispatcherCallableAsStr)
+
+	ingredientsFunction.FunctionDef.body.append(Make.astReturn(Make.astCall(astNameDataclass, list_astKeywords=list_astKeywordDataclassFragments)))
+
+	return ingredientsFunction
+
+@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 = outfitCountFolds(mapShape, **keywordArguments)
+
+	moduleSource: ModuleType = getSourceAlgorithm()
+	# TODO `countInitialize` is hardcoded
+	stateUniversal: ComputationState = 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/someAssemblyRequired/synthesizeNumba.py

@@ -0,0 +1,91 @@
+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