mapFolding 0.8.4__py3-none-any.whl → 0.8.6__py3-none-any.whl

mapFolding/someAssemblyRequired/ingredientsNumba.py

@@ -1,199 +0,0 @@
-"""
-Numba-specific ingredients for optimized code generation.
-
-This module provides specialized tools, constants, and types specifically designed
-for transforming Python code into Numba-accelerated implementations. It implements:
-
-1. A range of Numba jit decorator configurations for different optimization scenarios
-2. Functions to identify and manipulate Numba decorators in abstract syntax trees
-3. Utilities for applying appropriate Numba typing to transformed code
-4. Parameter management for Numba compilation options
-
-The configurations range from conservative options that prioritize compatibility and
-error detection to aggressive optimizations that maximize performance at the cost of
-flexibility. While this module specifically targets Numba, its design follows the pattern
-of generic code transformation tools in the package, allowing similar approaches to be
-applied to other acceleration technologies.
-
-This module works in conjunction with transformation tools to convert the general-purpose
-algorithm implementation into a highly-optimized Numba version.
-"""
-
-from collections.abc import Callable, Sequence
-from mapFolding.someAssemblyRequired import Make
-from mapFolding.someAssemblyRequired._toolboxContainers import IngredientsFunction
-from numba.core.compiler import CompilerBase as numbaCompilerBase
-from typing import Any, cast, Final, TYPE_CHECKING
-import ast
-
-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, }
-
-Z0Z_numbaDataTypeModule = 'numba'
-Z0Z_decoratorCallable = 'jit'
-
-def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, parametersNumba: ParametersNumba | None = None) -> IngredientsFunction:
-	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 makeSpecialSignatureForNumba(signatureElement: ast.arg) -> ast.Subscript | ast.Name | None: # type: ignore
-		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
-			ingredientsFunction.imports.addImportFrom_asStr(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_numbaDataTypeModule
-	list_argsDecorator: Sequence[ast.expr] = []
-
-	list_arg4signature_or_function: list[ast.expr] = []
-	for parameter in ingredientsFunction.astFunctionDef.args.args:
-		# Efficient translation of Python scalar types to Numba types https://github.com/hunterhogan/mapFolding/issues/8
-		# For now, let Numba infer them.
-		continue
-		# signatureElement: ast.Subscript | ast.Name | None = makeSpecialSignatureForNumba(parameter)
-		# if signatureElement:
-		# 	list_arg4signature_or_function.append(signatureElement)
-
-	if ingredientsFunction.astFunctionDef.returns and isinstance(ingredientsFunction.astFunctionDef.returns, ast.Name):
-		theReturn: ast.Name = ingredientsFunction.astFunctionDef.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()))]
-
-	ingredientsFunction.astFunctionDef = Z0Z_UnhandledDecorators(ingredientsFunction.astFunctionDef)
-	if parametersNumba is None:
-		parametersNumba = parametersNumbaDefault
-	listDecoratorKeywords: list[ast.keyword] = [Make.keyword(parameterName, Make.Constant(parameterValue)) for parameterName, parameterValue in parametersNumba.items()]
-
-	decoratorModule: str = Z0Z_numbaDataTypeModule
-	decoratorCallable: str = Z0Z_decoratorCallable
-	ingredientsFunction.imports.addImportFrom_asStr(decoratorModule, decoratorCallable)
-	# Leave this line in so that global edits will change it.
-	astDecorator: ast.Call = Make.Call(Make.Name(decoratorCallable), list_argsDecorator, listDecoratorKeywords)
-	astDecorator: ast.Call = Make.Call(Make.Name(decoratorCallable), list_astKeywords=listDecoratorKeywords)
-
-	ingredientsFunction.astFunctionDef.decorator_list = [astDecorator]
-	return ingredientsFunction

mapFolding/someAssemblyRequired/synthesizeNumbaFlow.py

@@ -1,156 +0,0 @@
-"""
-Orchestrator for generating Numba-optimized versions of the map folding algorithm.
-
-This module transforms the pure Python implementation of the map folding algorithm
-into a highly-optimized Numba implementation. It serves as the high-level coordinator
-for the code transformation process, orchestrating the following steps:
-
-1. Extracting the core algorithm functions from the source implementation
-2. Transforming function signatures and state handling for Numba compatibility
-3. Converting state-based operations to direct primitive operations
-4. Applying Numba decorators with appropriate optimization parameters
-5. Managing imports and dependencies for the generated code
-6. Assembling and writing the transformed implementation
-
-The transformation process preserves the algorithm's logic while dramatically improving
-performance by leveraging Numba's just-in-time compilation capabilities. This module
-depends on the abstract transformation tools, dataclass handling utilities, and
-Numba-specific optimization configurations from other modules in the package.
-
-The primary entry point is the makeNumbaFlow function, which can be executed directly
-to generate a fresh optimized implementation.
-"""
-
-from mapFolding.someAssemblyRequired import (
-	be,
-	ifThis,
-	Make,
-	NodeChanger,
-	NodeTourist,
-	Then,
-	Z0Z_inlineThisFunctionWithTheseValues,
-	Z0Z_lameFindReplace,
-	Z0Z_makeDictionaryReplacementStatements,
-	又,
-)
-from mapFolding.someAssemblyRequired._toolboxContainers import (
-	astModuleToIngredientsFunction,
-	IngredientsModule,
-	LedgerOfImports,
-	RecipeSynthesizeFlow,
-)
-from mapFolding.someAssemblyRequired.ingredientsNumba import decorateCallableWithNumba
-from mapFolding.someAssemblyRequired.transformDataStructures import shatter_dataclassesDOTdataclass
-from mapFolding.someAssemblyRequired.transformationTools import write_astModule
-import ast
-
-def makeNumbaFlow(numbaFlow: RecipeSynthesizeFlow) -> None:
-	# TODO a tool to automatically remove unused variables from the ArgumentsSpecification (return, and returns) _might_ be nice.
-	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
-
-	listAllIngredientsFunctions = [
-	(ingredientsInitialize := astModuleToIngredientsFunction(numbaFlow.source_astModule, numbaFlow.sourceCallableInitialize)),
-	(ingredientsParallel := astModuleToIngredientsFunction(numbaFlow.source_astModule, numbaFlow.sourceCallableParallel)),
-	(ingredientsSequential := astModuleToIngredientsFunction(numbaFlow.source_astModule, numbaFlow.sourceCallableSequential)),
-	(ingredientsDispatcher := astModuleToIngredientsFunction(numbaFlow.source_astModule, numbaFlow.sourceCallableDispatcher)),
-	]
-
-	# Inline functions ========================================================
-	dictionaryReplacementStatements = Z0Z_makeDictionaryReplacementStatements(numbaFlow.source_astModule)
-	# NOTE Replacements statements are based on the identifiers in the _source_, so operate on the source identifiers.
-	ingredientsInitialize.astFunctionDef = Z0Z_inlineThisFunctionWithTheseValues(ingredientsInitialize.astFunctionDef, dictionaryReplacementStatements)
-	ingredientsParallel.astFunctionDef = Z0Z_inlineThisFunctionWithTheseValues(ingredientsParallel.astFunctionDef, dictionaryReplacementStatements)
-	ingredientsSequential.astFunctionDef = Z0Z_inlineThisFunctionWithTheseValues(ingredientsSequential.astFunctionDef, dictionaryReplacementStatements)
-
-	# assignRecipeIdentifiersToCallable. =============================
-	# TODO How can I use `RecipeSynthesizeFlow` as the SSOT for the pairs of items that may need to be replaced?
-	# NOTE reminder: you are updating these `ast.Name` here (and not in a more general search) because this is a
-	# narrow search for `ast.Call` so you won't accidentally replace unrelated `ast.Name`.
-	listFindReplace = [(numbaFlow.sourceCallableDispatcher, numbaFlow.callableDispatcher),
-						(numbaFlow.sourceCallableInitialize, numbaFlow.callableInitialize),
-						(numbaFlow.sourceCallableParallel, numbaFlow.callableParallel),
-						(numbaFlow.sourceCallableSequential, numbaFlow.callableSequential),]
-	for ingredients in listAllIngredientsFunctions:
-		for source_Identifier, recipe_Identifier in listFindReplace:
-			updateCallName = NodeChanger(ifThis.isCall_Identifier(source_Identifier), Then.DOTfunc(Then.replaceWith(Make.Name(recipe_Identifier))))
-			updateCallName.visit(ingredients.astFunctionDef)
-
-	ingredientsDispatcher.astFunctionDef.name = numbaFlow.callableDispatcher
-	ingredientsInitialize.astFunctionDef.name = numbaFlow.callableInitialize
-	ingredientsParallel.astFunctionDef.name = numbaFlow.callableParallel
-	ingredientsSequential.astFunctionDef.name = numbaFlow.callableSequential
-
-	# Assign identifiers per the recipe. ==============================
-	listFindReplace = [(numbaFlow.sourceDataclassInstance, numbaFlow.dataclassInstance),
-		(numbaFlow.sourceDataclassInstanceTaskDistribution, numbaFlow.dataclassInstanceTaskDistribution),
-		(numbaFlow.sourceConcurrencyManagerNamespace, numbaFlow.concurrencyManagerNamespace),]
-	for ingredients in listAllIngredientsFunctions:
-		for source_Identifier, recipe_Identifier in listFindReplace:
-			updateName = NodeChanger(ifThis.isName_Identifier(source_Identifier), Then.DOTid(Then.replaceWith(recipe_Identifier)))
-			update_arg = NodeChanger(ifThis.isArgument_Identifier(source_Identifier), Then.DOTarg(Then.replaceWith(recipe_Identifier)))
-			updateName.visit(ingredients.astFunctionDef)
-			update_arg.visit(ingredients.astFunctionDef)
-
-	updateConcurrencyManager = NodeChanger(ifThis.isCallAttributeNamespace_Identifier(numbaFlow.sourceConcurrencyManagerNamespace, numbaFlow.sourceConcurrencyManagerIdentifier)
-										, Then.DOTfunc(Then.replaceWith(Make.Attribute(Make.Name(numbaFlow.concurrencyManagerNamespace), numbaFlow.concurrencyManagerIdentifier))))
-	updateConcurrencyManager.visit(ingredientsDispatcher.astFunctionDef)
-
-	# shatter Dataclass =======================================================
-	instance_Identifier = numbaFlow.dataclassInstance
-	getTheOtherRecord_damn = numbaFlow.dataclassInstanceTaskDistribution
-	shatteredDataclass = shatter_dataclassesDOTdataclass(numbaFlow.logicalPathModuleDataclass, numbaFlow.sourceDataclassIdentifier, instance_Identifier)
-	ingredientsDispatcher.imports.update(shatteredDataclass.ledger)
-
-	# Change callable parameters and Call to the callable at the same time ====
-	# TODO How can I use ast and/or other tools to ensure that when I change a callable, I also change the statements that call the callable?
-	# Asked differently, how do I integrate separate statements into a "subroutine", and that subroutine is "atomic/indivisible"?
-	# sequentialCallable =========================================================
-	ingredientsSequential.astFunctionDef.args = Make.argumentsSpecification(args=shatteredDataclass.list_argAnnotated4ArgumentsSpecification)
-	astCallSequentialCallable = Make.Call(Make.Name(numbaFlow.callableSequential), shatteredDataclass.listName4Parameters)
-	changeReturnSequentialCallable = NodeChanger(be.Return, Then.replaceWith(Make.Return(shatteredDataclass.fragments4AssignmentOrParameters)))
-	ingredientsSequential.astFunctionDef.returns = shatteredDataclass.signatureReturnAnnotation
-	replaceAssignSequentialCallable = NodeChanger(ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.callableSequential), Then.replaceWith(Make.Assign(listTargets=[shatteredDataclass.fragments4AssignmentOrParameters], value=astCallSequentialCallable)))
-
-	unpack4sequentialCallable = NodeChanger(ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.callableSequential), Then.insertThisAbove(shatteredDataclass.listUnpack))
-	repack4sequentialCallable = NodeChanger(ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.callableSequential), Then.insertThisBelow([shatteredDataclass.repack]))
-
-	changeReturnSequentialCallable.visit(ingredientsSequential.astFunctionDef)
-	replaceAssignSequentialCallable.visit(ingredientsDispatcher.astFunctionDef)
-	unpack4sequentialCallable.visit(ingredientsDispatcher.astFunctionDef)
-	repack4sequentialCallable.visit(ingredientsDispatcher.astFunctionDef)
-
-	ingredientsSequential.astFunctionDef = Z0Z_lameFindReplace(ingredientsSequential.astFunctionDef, shatteredDataclass.map_stateDOTfield2Name)
-
-	# parallelCallable =========================================================
-	ingredientsParallel.astFunctionDef.args = Make.argumentsSpecification(args=shatteredDataclass.list_argAnnotated4ArgumentsSpecification)
-	replaceCall2concurrencyManager = NodeChanger(ifThis.isCallAttributeNamespace_Identifier(numbaFlow.concurrencyManagerNamespace, numbaFlow.concurrencyManagerIdentifier), Then.replaceWith(Make.Call(Make.Attribute(Make.Name(numbaFlow.concurrencyManagerNamespace), numbaFlow.concurrencyManagerIdentifier), listArguments=[Make.Name(numbaFlow.callableParallel)] + shatteredDataclass.listName4Parameters)))
-
-	# NOTE I am dissatisfied with this logic for many reasons, including that it requires separate NodeCollector and NodeReplacer instances.
-	astCallConcurrencyResult: list[ast.Call] = []
-	get_astCallConcurrencyResult: NodeTourist = NodeTourist(ifThis.isAssignAndTargets0Is(ifThis.isSubscript_Identifier(getTheOtherRecord_damn)), lambda node: NodeTourist(be.Call, Then.appendTo(astCallConcurrencyResult)).visit(node)) # pyright: ignore[reportUnknownArgumentType, reportUnknownLambdaType]
-	get_astCallConcurrencyResult.visit(ingredientsDispatcher.astFunctionDef)
-	replaceAssignParallelCallable = NodeChanger(ifThis.isAssignAndTargets0Is(ifThis.isSubscript_Identifier(getTheOtherRecord_damn)), Then.DOTvalue(Then.replaceWith(astCallConcurrencyResult[0])))
-	replaceAssignParallelCallable.visit(ingredientsDispatcher.astFunctionDef)
-	changeReturnParallelCallable = NodeChanger(be.Return, Then.replaceWith(Make.Return(shatteredDataclass.countingVariableName)))
-	ingredientsParallel.astFunctionDef.returns = shatteredDataclass.countingVariableAnnotation
-
-	unpack4parallelCallable = NodeChanger(ifThis.isAssignAndValueIsCallAttributeNamespace_Identifier(numbaFlow.concurrencyManagerNamespace, numbaFlow.concurrencyManagerIdentifier), Then.insertThisAbove(shatteredDataclass.listUnpack))
-
-	unpack4parallelCallable.visit(ingredientsDispatcher.astFunctionDef)
-	replaceCall2concurrencyManager.visit(ingredientsDispatcher.astFunctionDef)
-	changeReturnParallelCallable.visit(ingredientsParallel.astFunctionDef)
-
-	ingredientsParallel.astFunctionDef = Z0Z_lameFindReplace(ingredientsParallel.astFunctionDef, shatteredDataclass.map_stateDOTfield2Name)
-
-	# numba decorators =========================================
-	ingredientsParallel = decorateCallableWithNumba(ingredientsParallel)
-	ingredientsSequential = decorateCallableWithNumba(ingredientsSequential)
-
-	# Module-level transformations ===========================================================
-	ingredientsModuleNumbaUnified = IngredientsModule(ingredientsFunction=listAllIngredientsFunctions, imports=LedgerOfImports(numbaFlow.source_astModule))
-
-	write_astModule(ingredientsModuleNumbaUnified, numbaFlow.pathFilenameDispatcher, numbaFlow.packageIdentifier)
-
-theNumbaFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()
-if __name__ == '__main__':
-	makeNumbaFlow(theNumbaFlow)

mapFolding/someAssemblyRequired/transformDataStructures.py

@@ -1,235 +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 Callable
-from copy import deepcopy
-from mapFolding.beDRY import outfitCountFolds
-from mapFolding.filesystem import getPathFilenameFoldsTotal
-from mapFolding.someAssemblyRequired import (
-	ast_Identifier,
-	be,
-	extractClassDef,
-	ifThis,
-	ImaAnnotationType,
-	importLogicalPath2Callable,
-	Make,
-	NodeTourist,
-	parseLogicalPath2astModule,
-	str_nameDOTname,
-	Then,
-	又,
-)
-from mapFolding.someAssemblyRequired._toolboxContainers import LedgerOfImports
-from mapFolding.theSSOT import ComputationState, raiseIfNoneGitHubIssueNumber3, The
-from os import PathLike
-from pathlib import Path, PurePath
-from typing import Any, Literal, overload
-import ast
-import dataclasses
-import pickle
-
-# Create dummy AST elements for use as defaults
-dummyAssign = Make.Assign([Make.Name("dummyTarget")], Make.Constant(None))
-dummySubscript = Make.Subscript(Make.Name("dummy"), Make.Name("slice"))
-dummyTuple = Make.Tuple([Make.Name("dummyElement")])
-
-@dataclasses.dataclass
-class ShatteredDataclass:
-	countingVariableAnnotation: ImaAnnotationType
-	"""Type annotation for the counting variable extracted from the dataclass."""
-	countingVariableName: ast.Name
-	"""AST name node representing the counting variable identifier."""
-	field2AnnAssign: dict[ast_Identifier, ast.AnnAssign] = dataclasses.field(default_factory=dict)
-	"""Maps field names to their corresponding AST call expressions."""
-	Z0Z_field2AnnAssign: dict[ast_Identifier, tuple[ast.AnnAssign, str]] = dataclasses.field(default_factory=dict)
-	fragments4AssignmentOrParameters: ast.Tuple = dummyTuple
-	"""AST tuple used as target for assignment to capture returned fragments."""
-	ledger: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
-	"""Import records for the dataclass and its constituent parts."""
-	list_argAnnotated4ArgumentsSpecification: list[ast.arg] = dataclasses.field(default_factory=list)
-	"""Function argument nodes with annotations for parameter specification."""
-	list_keyword_field__field4init: list[ast.keyword] = dataclasses.field(default_factory=list)
-	"""Keyword arguments for dataclass initialization with field=field format."""
-	listAnnotations: list[ImaAnnotationType] = dataclasses.field(default_factory=list)
-	"""Type annotations for each dataclass field."""
-	listName4Parameters: list[ast.Name] = dataclasses.field(default_factory=list)
-	"""Name nodes for each dataclass field used as function parameters."""
-	listUnpack: list[ast.AnnAssign] = dataclasses.field(default_factory=list)
-	"""Annotated assignment statements to extract fields from dataclass."""
-	map_stateDOTfield2Name: dict[ast.expr, ast.Name] = dataclasses.field(default_factory=dict)
-	"""Maps AST expressions to Name nodes for find-replace operations."""
-	repack: ast.Assign = dummyAssign
-	"""AST assignment statement that reconstructs the original dataclass instance."""
-	signatureReturnAnnotation: ast.Subscript = dummySubscript
-	"""tuple-based return type annotation for function definitions."""
-
-@dataclasses.dataclass
-class DeReConstructField2ast:
-	dataclassesDOTdataclassLogicalPathModule: dataclasses.InitVar[str_nameDOTname]
-	dataclassClassDef: dataclasses.InitVar[ast.ClassDef]
-	dataclassesDOTdataclassInstance_Identifier: dataclasses.InitVar[ast_Identifier]
-	field: dataclasses.InitVar[dataclasses.Field[Any]]
-
-	ledger: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
-
-	name: ast_Identifier = dataclasses.field(init=False)
-	typeBuffalo: type[Any] | str | Any = dataclasses.field(init=False)
-	default: Any | None = dataclasses.field(init=False)
-	default_factory: Callable[..., Any] | None = dataclasses.field(init=False)
-	repr: bool = dataclasses.field(init=False)
-	hash: bool | None = dataclasses.field(init=False)
-	init: bool = dataclasses.field(init=False)
-	compare: bool = dataclasses.field(init=False)
-	metadata: dict[Any, Any] = dataclasses.field(init=False)
-	kw_only: bool = dataclasses.field(init=False)
-
-	astName: ast.Name = dataclasses.field(init=False)
-	ast_keyword_field__field: ast.keyword = dataclasses.field(init=False)
-	ast_nameDOTname: ast.Attribute = dataclasses.field(init=False)
-	astAnnotation: ImaAnnotationType = dataclasses.field(init=False)
-	ast_argAnnotated: ast.arg = dataclasses.field(init=False)
-	astAnnAssignConstructor: ast.AnnAssign = dataclasses.field(init=False)
-	Z0Z_hack: tuple[ast.AnnAssign, str] = dataclasses.field(init=False)
-
-	def __post_init__(self, dataclassesDOTdataclassLogicalPathModule: str_nameDOTname, dataclassClassDef: ast.ClassDef, dataclassesDOTdataclassInstance_Identifier: ast_Identifier, field: dataclasses.Field[Any]) -> None:
-		self.compare = field.compare
-		self.default = field.default if field.default is not dataclasses.MISSING else None
-		self.default_factory = field.default_factory if field.default_factory is not dataclasses.MISSING else None
-		self.hash = field.hash
-		self.init = field.init
-		self.kw_only = field.kw_only if field.kw_only is not dataclasses.MISSING else False
-		self.metadata = dict(field.metadata)
-		self.name = field.name
-		self.repr = field.repr
-		self.typeBuffalo = field.type
-
-		self.astName = Make.Name(self.name)
-		self.ast_keyword_field__field = Make.keyword(self.name, self.astName)
-		self.ast_nameDOTname = Make.Attribute(Make.Name(dataclassesDOTdataclassInstance_Identifier), self.name)
-
-		sherpa = NodeTourist(ifThis.isAnnAssign_targetIs(ifThis.isName_Identifier(self.name)), 又.annotation(Then.getIt)).captureLastMatch(dataclassClassDef)
-		if sherpa is None: raise raiseIfNoneGitHubIssueNumber3
-		else: self.astAnnotation = sherpa
-
-		self.ast_argAnnotated = Make.arg(self.name, self.astAnnotation)
-
-		dtype = self.metadata.get('dtype', None)
-		if dtype:
-			constructor = 'array'
-			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, self.astAnnotation, Make.Call(Make.Name(constructor), list_astKeywords=[Make.keyword('dtype', Make.Name(dtype.__name__))]))
-			self.ledger.addImportFrom_asStr('numpy', constructor)
-			self.ledger.addImportFrom_asStr('numpy', dtype.__name__)
-			self.Z0Z_hack = (self.astAnnAssignConstructor, 'array')
-		elif be.Name(self.astAnnotation):
-			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, self.astAnnotation, Make.Call(self.astAnnotation, [Make.Constant(-1)]))
-			self.ledger.addImportFrom_asStr(dataclassesDOTdataclassLogicalPathModule, self.astAnnotation.id)
-			self.Z0Z_hack = (self.astAnnAssignConstructor, 'scalar')
-		elif be.Subscript(self.astAnnotation):
-			elementConstructor: ast_Identifier = self.metadata['elementConstructor']
-			self.ledger.addImportFrom_asStr(dataclassesDOTdataclassLogicalPathModule, elementConstructor)
-			takeTheTuple: ast.Tuple = deepcopy(self.astAnnotation.slice)
-			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, self.astAnnotation, takeTheTuple)
-			self.Z0Z_hack = (self.astAnnAssignConstructor, elementConstructor)
-		if be.Name(self.astAnnotation):
-			self.ledger.addImportFrom_asStr(dataclassesDOTdataclassLogicalPathModule, self.astAnnotation.id) # pyright: ignore [reportUnknownArgumentType, reportUnknownMemberType, reportIJustCalledATypeGuardMethod_WTF]
-
-def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, 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.
-	"""
-	Official_fieldOrder: list[ast_Identifier] = []
-	dictionaryDeReConstruction: dict[ast_Identifier, DeReConstructField2ast] = {}
-
-	dataclassClassDef = extractClassDef(parseLogicalPath2astModule(logicalPathModule), dataclass_Identifier)
-	if not isinstance(dataclassClassDef, ast.ClassDef): raise ValueError(f"I could not find {dataclass_Identifier=} in {logicalPathModule=}.")
-
-	countingVariable = None
-	for aField in dataclasses.fields(importLogicalPath2Callable(logicalPathModule, dataclass_Identifier)): # pyright: ignore [reportArgumentType]
-		Official_fieldOrder.append(aField.name)
-		dictionaryDeReConstruction[aField.name] = DeReConstructField2ast(logicalPathModule, dataclassClassDef, instance_Identifier, aField)
-		if aField.metadata.get('theCountingIdentifier', False):
-			countingVariable = dictionaryDeReConstruction[aField.name].name
-
-	if countingVariable is None:
-		raise ValueError(f"I could not find the counting variable in {dataclass_Identifier=} in {logicalPathModule=}.")
-
-	shatteredDataclass = ShatteredDataclass(
-		countingVariableAnnotation=dictionaryDeReConstruction[countingVariable].astAnnotation,
-		countingVariableName=dictionaryDeReConstruction[countingVariable].astName,
-		field2AnnAssign={dictionaryDeReConstruction[field].name: dictionaryDeReConstruction[field].astAnnAssignConstructor for field in Official_fieldOrder},
-		Z0Z_field2AnnAssign={dictionaryDeReConstruction[field].name: dictionaryDeReConstruction[field].Z0Z_hack for field in Official_fieldOrder},
-		list_argAnnotated4ArgumentsSpecification=[dictionaryDeReConstruction[field].ast_argAnnotated for field in Official_fieldOrder],
-		list_keyword_field__field4init=[dictionaryDeReConstruction[field].ast_keyword_field__field for field in Official_fieldOrder if dictionaryDeReConstruction[field].init],
-		listAnnotations=[dictionaryDeReConstruction[field].astAnnotation for field in Official_fieldOrder],
-		listName4Parameters=[dictionaryDeReConstruction[field].astName for field in Official_fieldOrder],
-		listUnpack=[Make.AnnAssign(dictionaryDeReConstruction[field].astName, dictionaryDeReConstruction[field].astAnnotation, dictionaryDeReConstruction[field].ast_nameDOTname) for field in Official_fieldOrder],
-		map_stateDOTfield2Name={dictionaryDeReConstruction[field].ast_nameDOTname: dictionaryDeReConstruction[field].astName for field in Official_fieldOrder},
-		)
-	shatteredDataclass.fragments4AssignmentOrParameters = Make.Tuple(shatteredDataclass.listName4Parameters, ast.Store())
-	shatteredDataclass.repack = Make.Assign(listTargets=[Make.Name(instance_Identifier)], value=Make.Call(Make.Name(dataclass_Identifier), list_astKeywords=shatteredDataclass.list_keyword_field__field4init))
-	shatteredDataclass.signatureReturnAnnotation = Make.Subscript(Make.Name('tuple'), Make.Tuple(shatteredDataclass.listAnnotations))
-
-	shatteredDataclass.ledger.update(*(dictionaryDeReConstruction[field].ledger for field in Official_fieldOrder))
-	shatteredDataclass.ledger.addImportFrom_asStr(logicalPathModule, dataclass_Identifier)
-
-	return shatteredDataclass
-
-@overload
-def makeInitializedComputationState(mapShape: tuple[int, ...], writeJob: Literal[True], *,  pathFilename: PathLike[str] | PurePath | None = None, **keywordArguments: Any) -> Path: ...
-@overload
-def makeInitializedComputationState(mapShape: tuple[int, ...], writeJob: Literal[False] = False, **keywordArguments: Any) -> ComputationState: ...
-def makeInitializedComputationState(mapShape: tuple[int, ...], writeJob: bool = False, *,  pathFilename: PathLike[str] | PurePath | None = None, **keywordArguments: Any) -> ComputationState | Path:
-	"""
-	Initializes a computation state and optionally saves it to disk.
-
-	This function initializes a computation state using the source algorithm.
-
-	Hint: If you want an uninitialized state, call `outfitCountFolds` directly.
-
-	Parameters:
-		mapShape: List of integers representing the dimensions of the map to be folded.
-		writeJob (False): Whether to save the state to disk.
-		pathFilename (getPathFilenameFoldsTotal.pkl): The path and filename to save the state. If None, uses a default path.
-		**keywordArguments: computationDivisions:int|str|None=None,concurrencyLimit:int=1.
-	Returns:
-		stateUniversal|pathFilenameJob: The computation state for the map folding calculations, or
-			the path to the saved state file if writeJob is True.
-	"""
-	stateUniversal: ComputationState = outfitCountFolds(mapShape, **keywordArguments)
-
-	initializeState = importLogicalPath2Callable(The.logicalPathModuleSourceAlgorithm, The.sourceCallableInitialize)
-	stateUniversal = initializeState(stateUniversal)
-
-	if not writeJob:
-		return stateUniversal
-
-	if pathFilename:
-		pathFilenameJob = Path(pathFilename)
-		pathFilenameJob.parent.mkdir(parents=True, exist_ok=True)
-	else:
-		pathFilenameJob = getPathFilenameFoldsTotal(stateUniversal.mapShape).with_suffix('.pkl')
-
-	pathFilenameJob.write_bytes(pickle.dumps(stateUniversal))
-	return pathFilenameJob

mapfolding-0.8.4.dist-info/RECORD

@@ -1,49 +0,0 @@
-mapFolding/__init__.py,sha256=z3joPk4hgIbSEsIWGgkOukl-nrgI5u4wg0mRJ7aSRHM,1982
-mapFolding/basecamp.py,sha256=CGJOUE0eQsS4EzHjptzJbxg-Oy4t6TsE7P3vgTRuAww,4763
-mapFolding/beDRY.py,sha256=UhH52BryHQNRjphf_PirtMkV45rhdemdC9PmnpACq7I,9397
-mapFolding/filesystem.py,sha256=JyeFLlkeMqhsYGp80ViwDjrrDgFaTTdGTewLtla-m00,7132
-mapFolding/noHomeYet.py,sha256=UKZeWlyn0SKlF9dhYoud7E6gWXpiSEekZOOoJp88WeI,1362
-mapFolding/oeis.py,sha256=F1tGo2kT9xR3eRaXyxH0bnAWscbn38VS2fIY8-VlLZs,12616
-mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mapFolding/theDao.py,sha256=MVopt1LzhdIQYA97SEoq9bdzct6hbK0lEyPxBAAlVTc,9934
-mapFolding/theSSOT.py,sha256=JCejbNNVP6s9dR2vkdttKXleyZrQroYRWUjGQrXyFaI,11845
-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=v8aBRcRa4d_34SUNu_mZC5K_NC7-buy849k2nnk9lTE,2704
-mapFolding/someAssemblyRequired/_theTypes.py,sha256=nHFgpts-hVy2lNbyvIyP5JeG-ikaIlbRaMUPnEDwzhc,1924
-mapFolding/someAssemblyRequired/_tool_Make.py,sha256=nIAjiq-Q2sBvO_bVEGFh3Z79vXmcqcfJCtuhR4Vyzqw,7081
-mapFolding/someAssemblyRequired/_tool_Then.py,sha256=8ZCI8A6-EtUo02m71h60iJwnWfdwxWiQT0_OWJDFBho,2566
-mapFolding/someAssemblyRequired/_toolboxAntecedents.py,sha256=USqFn2HKiu2aUYUrUI-UVRq2tAvVw2hLtH2uLJ61ZbY,19110
-mapFolding/someAssemblyRequired/_toolboxContainers.py,sha256=jjGyKhblHqDiCzjHRfyqnI2UHNzJTe3aBwNofukcf88,15998
-mapFolding/someAssemblyRequired/_toolboxPython.py,sha256=OSFMNBiyBofzckF6J8OYibm9Zh3GHXB8bJrMggVT8fw,3801
-mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=CDbesDJSQE-P8uznXIAttRw9f413UpUt-RowK38hqbY,2735
-mapFolding/someAssemblyRequired/ingredientsNumba.py,sha256=Qb2WVDv5XszwcQCs3zFrodS7G0GKstSqVrKDXBzdMaw,8128
-mapFolding/someAssemblyRequired/synthesizeNumbaFlow.py,sha256=A9H6gbTNtK0bihxJ98Xv5ePzGeOyYP6e0Fxmj2NTh-M,11186
-mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=_TPANqYkWS4O2IhU4EOatRv-OetfFCfk5b6rrxB5i48,13210
-mapFolding/someAssemblyRequired/transformDataStructures.py,sha256=I4OtFUF7ZNpEzsAbIbcqTifnY1vIwN0v1f-XFQQp3Wk,13558
-mapFolding/someAssemblyRequired/transformationTools.py,sha256=fXr3XKHuFntKLTxoau9ZnbZJRPOG3aS2BhjJvkgRXRs,7932
-mapFolding/syntheticModules/__init__.py,sha256=evVFqhCGa-WZKDiLcnQWjs-Bj34eRnfSLqz_d7dFYZY,83
-mapFolding/syntheticModules/numbaCount_doTheNeedful.py,sha256=3thXThbv2Xo0t_cRGzMbHPFXTBmLClmKejR_Ibu_jOo,15697
-mapfolding-0.8.4.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/conftest.py,sha256=-5rAnacJAuDcG84jeoQAA35GvUTW6YTcT6E_xU7EXQ0,11587
-tests/test_computations.py,sha256=R5gea8liIE_rBYvgRDIby6GljBazuGgqCeYcqKRjORg,3449
-tests/test_filesystem.py,sha256=RplMT0GULGQxomQSbk5wLlvNsj7ehDlZmzayatJopp4,3150
-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.4.dist-info/METADATA,sha256=NMXRV8HTCO8Nab_q1Bo3W6i0eAirJ9K453LRGOv86i8,9326
-mapfolding-0.8.4.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-mapfolding-0.8.4.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapfolding-0.8.4.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapfolding-0.8.4.dist-info/RECORD,,