mapFolding 0.15.3__py3-none-any.whl → 0.16.0__py3-none-any.whl

mapFolding/someAssemblyRequired/mapFolding/makeMapFoldingModules.py

@@ -0,0 +1,220 @@
+"""makeMapFoldingModules."""
+from astToolkit import (
+	astModuleToIngredientsFunction, Be, DOT, extractClassDef, Grab, hasDOTbody, identifierDotAttribute,
+	IngredientsFunction, IngredientsModule, LedgerOfImports, Make, NodeChanger, NodeTourist, parseLogicalPath2astModule,
+	parsePathFilename2astModule, Then)
+from astToolkit.transformationTools import inlineFunctionDef, removeUnusedParameters, write_astModule
+from hunterMakesPy import importLogicalPath2Identifier, raiseIfNone
+from mapFolding import packageSettings
+from mapFolding.someAssemblyRequired import (
+	DeReConstructField2ast, identifierCallableSourceDEFAULT, identifierCallableSourceDispatcherDEFAULT, IfThis,
+	logicalPathInfixDEFAULT, ShatteredDataclass)
+from mapFolding.someAssemblyRequired.makingModules_count import (
+	makeDaoOfMapFoldingNumba, makeTheorem2, numbaOnTheorem2, trimTheorem2)
+from mapFolding.someAssemblyRequired.makingModules_doTheNeedful import makeInitializeState, makeUnRePackDataclass
+from mapFolding.someAssemblyRequired.toolkitMakeModules import getLogicalPath, getModule, getPathFilename
+from mapFolding.someAssemblyRequired.toolkitNumba import decorateCallableWithNumba, parametersNumbaLight
+from mapFolding.someAssemblyRequired.transformationTools import (
+	removeDataclassFromFunction, shatter_dataclassesDOTdataclass, unpackDataclassCallFunctionRepackDataclass)
+from os import PathLike
+from pathlib import PurePath
+from typing import Any, TYPE_CHECKING
+import ast
+import dataclasses
+
+if TYPE_CHECKING:
+	from collections.abc import Sequence
+
+def makeDaoOfMapFoldingParallelNumba(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | str | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
+	"""Generate parallel implementation with concurrent execution and task division.
+
+	Parameters
+	----------
+	astModule : ast.Module
+		Source module containing the base algorithm.
+	moduleIdentifier : str
+		Name for the generated parallel module.
+	callableIdentifier : str | None = None
+		Name for the core parallel counting function.
+	logicalPathInfix : PathLike[str] | PurePath | str | None = None
+		Directory path for organizing the generated module.
+	sourceCallableDispatcher : str | None = None
+		Optional dispatcher function identifier.
+
+	Returns
+	-------
+	pathFilename : PurePath
+		Filesystem path where the parallel module was written.
+
+	"""
+	sourceCallableIdentifier = identifierCallableSourceDEFAULT
+	if callableIdentifier is None:
+		callableIdentifier = sourceCallableIdentifier
+	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
+	ingredientsFunction.astFunctionDef.name = callableIdentifier
+
+	dataclassName: ast.expr = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(ingredientsFunction.astFunctionDef))
+	dataclassIdentifier: str = raiseIfNone(NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName))
+
+	dataclassLogicalPathModule = None
+	for moduleWithLogicalPath, listNameTuples in ingredientsFunction.imports._dictionaryImportFrom.items():  # noqa: SLF001
+		for nameTuple in listNameTuples:
+			if nameTuple[0] == dataclassIdentifier:
+				dataclassLogicalPathModule = moduleWithLogicalPath
+				break
+		if dataclassLogicalPathModule:
+			break
+	if dataclassLogicalPathModule is None:
+		raise Exception  # noqa: TRY002
+	dataclassInstanceIdentifier: identifierDotAttribute = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
+	shatteredDataclass: ShatteredDataclass = shatter_dataclassesDOTdataclass(dataclassLogicalPathModule, dataclassIdentifier, dataclassInstanceIdentifier)
+
+	# START add the parallel state fields to the count function ------------------------------------------------
+	dataclassBaseFields: tuple[dataclasses.Field[Any], ...] = dataclasses.fields(importLogicalPath2Identifier(dataclassLogicalPathModule, dataclassIdentifier))  # pyright: ignore [reportArgumentType]
+	dataclassIdentifierParallel: identifierDotAttribute = 'Parallel' + dataclassIdentifier
+	dataclassFieldsParallel: tuple[dataclasses.Field[Any], ...] = dataclasses.fields(importLogicalPath2Identifier(dataclassLogicalPathModule, dataclassIdentifierParallel))  # pyright: ignore [reportArgumentType]
+	onlyParallelFields: list[dataclasses.Field[Any]] = [field for field in dataclassFieldsParallel if field.name not in [fieldBase.name for fieldBase in dataclassBaseFields]]
+
+	Official_fieldOrder: list[str] = []
+	dictionaryDeReConstruction: dict[str, DeReConstructField2ast] = {}
+
+	dataclassClassDef: ast.ClassDef | None = extractClassDef(parseLogicalPath2astModule(dataclassLogicalPathModule), dataclassIdentifierParallel)
+	if not dataclassClassDef:
+		message = f"I could not find `{dataclassIdentifierParallel = }` in `{dataclassLogicalPathModule = }`."
+		raise ValueError(message)
+
+	for aField in onlyParallelFields:
+		Official_fieldOrder.append(aField.name)
+		dictionaryDeReConstruction[aField.name] = DeReConstructField2ast(dataclassLogicalPathModule, dataclassClassDef, dataclassInstanceIdentifier, aField)
+
+	shatteredDataclassParallel = ShatteredDataclass(
+		countingVariableAnnotation=shatteredDataclass.countingVariableAnnotation,
+		countingVariableName=shatteredDataclass.countingVariableName,
+		field2AnnAssign={**shatteredDataclass.field2AnnAssign, **{dictionaryDeReConstruction[field].name: dictionaryDeReConstruction[field].astAnnAssignConstructor for field in Official_fieldOrder}},
+		Z0Z_field2AnnAssign={**shatteredDataclass.Z0Z_field2AnnAssign, **{dictionaryDeReConstruction[field].name: dictionaryDeReConstruction[field].Z0Z_hack for field in Official_fieldOrder}},
+		list_argAnnotated4ArgumentsSpecification=shatteredDataclass.list_argAnnotated4ArgumentsSpecification + [dictionaryDeReConstruction[field].ast_argAnnotated for field in Official_fieldOrder],
+		list_keyword_field__field4init=shatteredDataclass.list_keyword_field__field4init + [dictionaryDeReConstruction[field].ast_keyword_field__field for field in Official_fieldOrder if dictionaryDeReConstruction[field].init],
+		listAnnotations=shatteredDataclass.listAnnotations + [dictionaryDeReConstruction[field].astAnnotation for field in Official_fieldOrder],
+		listName4Parameters=shatteredDataclass.listName4Parameters + [dictionaryDeReConstruction[field].astName for field in Official_fieldOrder],
+		listUnpack=shatteredDataclass.listUnpack + [Make.AnnAssign(dictionaryDeReConstruction[field].astName, dictionaryDeReConstruction[field].astAnnotation, dictionaryDeReConstruction[field].ast_nameDOTname) for field in Official_fieldOrder],
+		map_stateDOTfield2Name={**shatteredDataclass.map_stateDOTfield2Name, **{dictionaryDeReConstruction[field].ast_nameDOTname: dictionaryDeReConstruction[field].astName for field in Official_fieldOrder}},
+		)
+	shatteredDataclassParallel.fragments4AssignmentOrParameters = Make.Tuple(shatteredDataclassParallel.listName4Parameters, Make.Store())
+	shatteredDataclassParallel.repack = Make.Assign([Make.Name(dataclassInstanceIdentifier)], value=Make.Call(Make.Name(dataclassIdentifierParallel), list_keyword=shatteredDataclassParallel.list_keyword_field__field4init))
+	shatteredDataclassParallel.signatureReturnAnnotation = Make.Subscript(Make.Name('tuple'), Make.Tuple(shatteredDataclassParallel.listAnnotations))
+
+	shatteredDataclassParallel.imports.update(*(dictionaryDeReConstruction[field].ledger for field in Official_fieldOrder))
+	shatteredDataclassParallel.imports.addImportFrom_asStr(dataclassLogicalPathModule, dataclassIdentifierParallel)
+	shatteredDataclassParallel.imports.update(shatteredDataclass.imports)
+	shatteredDataclassParallel.imports.removeImportFrom(dataclassLogicalPathModule, dataclassIdentifier)
+
+	# END add the parallel state fields to the count function ------------------------------------------------
+
+	ingredientsFunction.imports.update(shatteredDataclassParallel.imports)
+	ingredientsFunction: IngredientsFunction = removeDataclassFromFunction(ingredientsFunction, shatteredDataclassParallel)
+
+	# START add the parallel logic to the count function ------------------------------------------------
+
+	findThis = Be.While.testIs(Be.Compare.leftIs(IfThis.isNameIdentifier('leafConnectee')))
+	captureCountGapsCodeBlock: NodeTourist[ast.While, Sequence[ast.stmt]] = NodeTourist(findThis, doThat = Then.extractIt(DOT.body))
+	countGapsCodeBlock: Sequence[ast.stmt] = raiseIfNone(captureCountGapsCodeBlock.captureLastMatch(ingredientsFunction.astFunctionDef))
+
+	thisIsMyTaskIndexCodeBlock = ast.If(ast.BoolOp(ast.Or()
+		, values=[ast.Compare(ast.Name('leaf1ndex'), ops=[ast.NotEq()], comparators=[ast.Name('taskDivisions')])
+				, ast.Compare(Make.Mod.join([ast.Name('leafConnectee'), ast.Name('taskDivisions')]), ops=[ast.Eq()], comparators=[ast.Name('taskIndex')])])
+	, body=list(countGapsCodeBlock[0:-1]))
+
+	countGapsCodeBlockNew: list[ast.stmt] = [thisIsMyTaskIndexCodeBlock, countGapsCodeBlock[-1]]
+	NodeChanger[ast.While, hasDOTbody](findThis, doThat = Grab.bodyAttribute(Then.replaceWith(countGapsCodeBlockNew))).visit(ingredientsFunction.astFunctionDef)
+
+	# END add the parallel logic to the count function ------------------------------------------------
+
+	ingredientsFunction = removeUnusedParameters(ingredientsFunction)
+
+	ingredientsFunction = decorateCallableWithNumba(ingredientsFunction, parametersNumbaLight)
+
+	# START unpack/repack the dataclass function ------------------------------------------------
+	sourceCallableIdentifier = identifierCallableSourceDispatcherDEFAULT
+
+	unRepackDataclass: IngredientsFunction = astModuleToIngredientsFunction(astModule, sourceCallableIdentifier)
+	unRepackDataclass.astFunctionDef.name = 'unRepack' + dataclassIdentifierParallel
+	unRepackDataclass.imports.update(shatteredDataclassParallel.imports)
+	NodeChanger(
+			findThis = Be.arg.annotationIs(Be.Name.idIs(lambda thisAttribute: thisAttribute == dataclassIdentifier)) # pyright: ignore[reportArgumentType]
+			, doThat = Grab.annotationAttribute(Grab.idAttribute(Then.replaceWith(dataclassIdentifierParallel)))
+		).visit(unRepackDataclass.astFunctionDef)
+	unRepackDataclass.astFunctionDef.returns = Make.Name(dataclassIdentifierParallel)
+	targetCallableIdentifier: identifierDotAttribute = ingredientsFunction.astFunctionDef.name
+	unRepackDataclass = unpackDataclassCallFunctionRepackDataclass(unRepackDataclass, targetCallableIdentifier, shatteredDataclassParallel)
+
+	astTuple: ast.Tuple = raiseIfNone(NodeTourist[ast.Return, ast.Tuple](Be.Return, Then.extractIt(DOT.value)).captureLastMatch(ingredientsFunction.astFunctionDef)) # pyright: ignore[reportArgumentType]
+	astTuple.ctx = Make.Store()
+	changeAssignCallToTarget: NodeChanger[ast.Assign, ast.Assign] = NodeChanger(
+		findThis = Be.Assign.valueIs(IfThis.isCallIdentifier(targetCallableIdentifier))
+		, doThat = Then.replaceWith(Make.Assign([astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts)))
+	)
+	changeAssignCallToTarget.visit(unRepackDataclass.astFunctionDef)
+
+	ingredientsDoTheNeedful: IngredientsFunction = IngredientsFunction(
+		astFunctionDef = Make.FunctionDef('doTheNeedful'
+			, argumentSpecification=Make.arguments(list_arg=[Make.arg('state', annotation=Make.Name(dataclassIdentifierParallel)), Make.arg('concurrencyLimit', annotation=Make.Name('int'))])
+			, body=[Make.Assign([Make.Name('stateParallel', Make.Store())], value=Make.Call(Make.Name('deepcopy'), listParameters=[Make.Name('state')]))
+				, Make.AnnAssign(Make.Name('listStatesParallel', Make.Store()), annotation=Make.Subscript(value=Make.Name('list'), slice=Make.Name(dataclassIdentifierParallel))
+					, value=Make.Mult.join([Make.List([Make.Name('stateParallel')]), Make.Attribute(Make.Name('stateParallel'), 'taskDivisions')]))
+				, Make.AnnAssign(Make.Name('groupsOfFoldsTotal', Make.Store()), annotation=Make.Name('int'), value=Make.Constant(value=0))
+
+				, Make.AnnAssign(Make.Name('dictionaryConcurrency', Make.Store()), annotation=Make.Subscript(value=Make.Name('dict'), slice=Make.Tuple([Make.Name('int'), Make.Subscript(value=Make.Name('ConcurrentFuture'), slice=Make.Name(dataclassIdentifierParallel))])), value=Make.Dict())
+				, Make.With(items=[Make.withitem(context_expr=Make.Call(Make.Name('ProcessPoolExecutor'), listParameters=[Make.Name('concurrencyLimit')]), optional_vars=Make.Name('concurrencyManager', Make.Store()))]
+					, body=[Make.For(Make.Name('indexSherpa', Make.Store()), iter=Make.Call(Make.Name('range'), listParameters=[Make.Attribute(Make.Name('stateParallel'), 'taskDivisions')])
+							, body=[Make.Assign([Make.Name('state', Make.Store())], value=Make.Call(Make.Name('deepcopy'), listParameters=[Make.Name('stateParallel')]))
+								, Make.Assign([Make.Attribute(Make.Name('state'), 'taskIndex', context=Make.Store())], value=Make.Name('indexSherpa'))
+								, Make.Assign([Make.Subscript(Make.Name('dictionaryConcurrency'), slice=Make.Name('indexSherpa'), context=Make.Store())], value=Make.Call(Make.Attribute(Make.Name('concurrencyManager'), 'submit'), listParameters=[Make.Name(unRepackDataclass.astFunctionDef.name), Make.Name('state')]))])
+						, Make.For(Make.Name('indexSherpa', Make.Store()), iter=Make.Call(Make.Name('range'), listParameters=[Make.Attribute(Make.Name('stateParallel'), 'taskDivisions')])
+							, body=[Make.Assign([Make.Subscript(Make.Name('listStatesParallel'), slice=Make.Name('indexSherpa'), context=Make.Store())], value=Make.Call(Make.Attribute(Make.Subscript(Make.Name('dictionaryConcurrency'), slice=Make.Name('indexSherpa')), 'result')))
+								, Make.AugAssign(Make.Name('groupsOfFoldsTotal', Make.Store()), op=ast.Add(), value=Make.Attribute(Make.Subscript(Make.Name('listStatesParallel'), slice=Make.Name('indexSherpa')), 'groupsOfFolds'))])])
+
+				, Make.AnnAssign(Make.Name('foldsTotal', Make.Store()), annotation=Make.Name('int'), value=Make.Mult.join([Make.Name('groupsOfFoldsTotal'), Make.Attribute(Make.Name('stateParallel'), 'leavesTotal')]))
+				, Make.Return(Make.Tuple([Make.Name('foldsTotal'), Make.Name('listStatesParallel')]))]
+			, returns=Make.Subscript(Make.Name('tuple'), slice=Make.Tuple([Make.Name('int'), Make.Subscript(Make.Name('list'), slice=Make.Name(dataclassIdentifierParallel))])))
+		, imports = LedgerOfImports(Make.Module([Make.ImportFrom('concurrent.futures', list_alias=[Make.alias('Future', asName='ConcurrentFuture'), Make.alias('ProcessPoolExecutor')]),
+			Make.ImportFrom('copy', list_alias=[Make.alias('deepcopy')]),
+			Make.ImportFrom('multiprocessing', list_alias=[Make.alias('set_start_method', asName='multiprocessing_set_start_method')])])
+		)
+	)
+
+	ingredientsModule = IngredientsModule([ingredientsFunction, unRepackDataclass, ingredientsDoTheNeedful]
+						, prologue = Make.Module([Make.If(test=Make.Compare(left=Make.Name('__name__'), ops=[Make.Eq()], comparators=[Make.Constant('__main__')]), body=[Make.Expr(Make.Call(Make.Name('multiprocessing_set_start_method'), listParameters=[Make.Constant('spawn')]))])])
+	)
+	ingredientsModule.removeImportFromModule('numpy')
+
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
+
+	write_astModule(ingredientsModule, pathFilename, packageSettings.identifierPackage)
+
+	return pathFilename
+
+def makeMapFoldingModules() -> None:
+	"""Make multidimensional map folding modules."""
+	astModule = getModule(logicalPathInfix='algorithms')
+	pathFilename: PurePath = makeDaoOfMapFoldingNumba(astModule, 'daoOfMapFoldingNumba', None, logicalPathInfixDEFAULT, identifierCallableSourceDispatcherDEFAULT)
+
+	astModule = getModule(logicalPathInfix='algorithms')
+	pathFilename = makeDaoOfMapFoldingParallelNumba(astModule, 'countParallelNumba', None, logicalPathInfixDEFAULT, identifierCallableSourceDispatcherDEFAULT)
+
+	astModule: ast.Module = getModule(logicalPathInfix='algorithms')
+	makeInitializeState(astModule, 'initializeState', 'transitionOnGroupsOfFolds', logicalPathInfixDEFAULT)
+
+	astModule = getModule(logicalPathInfix='algorithms')
+	pathFilename = makeTheorem2(astModule, 'theorem2', None, logicalPathInfixDEFAULT, None)
+
+	astModule = parsePathFilename2astModule(pathFilename)
+	pathFilename = trimTheorem2(astModule, 'theorem2Trimmed', None, logicalPathInfixDEFAULT, None)
+
+	astModule = parsePathFilename2astModule(pathFilename)
+	pathFilename = numbaOnTheorem2(astModule, 'theorem2Numba', None, logicalPathInfixDEFAULT, None)
+
+	astImportFrom: ast.ImportFrom = Make.ImportFrom(getLogicalPath(packageSettings.identifierPackage, logicalPathInfixDEFAULT, 'theorem2Numba'), list_alias=[Make.alias(identifierCallableSourceDEFAULT)])
+	makeUnRePackDataclass(astImportFrom)
+
+if __name__ == '__main__':
+	makeMapFoldingModules()

mapFolding/someAssemblyRequired/toolkitMakeModules.py

@@ -0,0 +1,152 @@
+"""
+Map folding AST transformation system: Comprehensive transformation orchestration and module generation.
+
+This module provides the orchestration layer of the map folding AST transformation system,
+implementing comprehensive tools that coordinate all transformation stages to generate optimized
+implementations with diverse computational strategies and performance characteristics. Building
+upon the foundational pattern recognition, structural decomposition, core transformation tools,
+Numba integration, and configuration management established in previous layers, this module
+executes complete transformation processes that convert high-level dataclass-based algorithms
+into specialized variants optimized for specific execution contexts.
+
+The transformation orchestration addresses the full spectrum of optimization requirements for
+map folding computational research through systematic application of the complete transformation
+toolkit. The comprehensive approach decomposes dataclass parameters into primitive values for
+Numba compatibility while removing object-oriented overhead and preserving computational logic,
+generates concurrent execution variants using ProcessPoolExecutor with task division and result
+aggregation, creates dedicated modules for counting variable setup with transformed loop conditions,
+and provides theorem-specific transformations with configurable optimization levels including
+trimmed variants and Numba-accelerated implementations.
+
+The orchestration process operates through systematic AST manipulation that analyzes source
+algorithms to extract dataclass dependencies, transforms data access patterns, applies performance
+optimizations, and generates specialized modules with consistent naming conventions and filesystem
+organization. The comprehensive transformation process coordinates pattern recognition for structural
+analysis, dataclass decomposition for parameter optimization, function transformation for signature
+adaptation, Numba integration for compilation optimization, and configuration management for
+systematic generation control.
+
+Generated modules maintain algorithmic correctness while providing significant performance
+improvements through just-in-time compilation, parallel execution, and optimized data structures
+tailored for specific computational requirements essential to large-scale map folding research.
+"""
+
+from astToolkit import (
+	Be, DOT, identifierDotAttribute, IngredientsFunction, NodeTourist, parseLogicalPath2astModule, Then)
+from autoflake import fix_code as autoflake_fix_code
+from hunterMakesPy import raiseIfNone, writeStringToHere
+from mapFolding import packageSettings
+from mapFolding.someAssemblyRequired import identifierModuleSourceAlgorithmDEFAULT, logicalPathInfixDEFAULT
+from os import PathLike
+from pathlib import PurePath
+from typing import Any
+import ast
+import io
+
+def findDataclass(ingredientsFunction: IngredientsFunction) -> tuple[str, str, str]:
+	"""Extract dataclass information from a function's AST for transformation operations.
+
+	(AI generated docstring)
+
+	Analyzes the first parameter of a function to identify the dataclass type annotation
+	and instance identifier, then locates the module where the dataclass is defined by
+	examining the function's import statements. This information is essential for
+	dataclass decomposition and transformation operations.
+
+	Parameters
+	----------
+	ingredientsFunction : IngredientsFunction
+		Function container with AST and import information.
+
+	Returns
+	-------
+	dataclassLogicalPathModule : str
+		Module logical path where the dataclass is defined.
+	dataclassIdentifier : str
+		Class name of the dataclass.
+	dataclassInstanceIdentifier : str
+		Parameter name for the dataclass instance.
+
+	Raises
+	------
+	ValueError
+		If dataclass information cannot be extracted from the function.
+
+	"""
+	dataclassName: ast.expr = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(ingredientsFunction.astFunctionDef))
+	dataclassIdentifier: str = raiseIfNone(NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName))
+	dataclassLogicalPathModule = None
+	for moduleWithLogicalPath, listNameTuples in ingredientsFunction.imports._dictionaryImportFrom.items():  # noqa: SLF001
+		for nameTuple in listNameTuples:
+			if nameTuple[0] == dataclassIdentifier:
+				dataclassLogicalPathModule = moduleWithLogicalPath
+				break
+		if dataclassLogicalPathModule:
+			break
+	dataclassInstanceIdentifier: identifierDotAttribute = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
+	return raiseIfNone(dataclassLogicalPathModule), dataclassIdentifier, dataclassInstanceIdentifier
+
+def getLogicalPath(identifierPackage: str | None = None, logicalPathInfix: str | None = None, *moduleIdentifier: str | None) -> identifierDotAttribute:
+	"""Get logical path from components."""
+	listLogicalPathParts: list[str] = []
+	if identifierPackage:
+		listLogicalPathParts.append(identifierPackage)
+	if logicalPathInfix:
+		listLogicalPathParts.append(logicalPathInfix)
+	if moduleIdentifier:
+		listLogicalPathParts.extend([module for module in moduleIdentifier if module is not None])
+	return '.'.join(listLogicalPathParts)
+
+def getModule(identifierPackage: str | None = packageSettings.identifierPackage, logicalPathInfix: str | None = logicalPathInfixDEFAULT, moduleIdentifier: str | None = identifierModuleSourceAlgorithmDEFAULT) -> ast.Module:
+	"""Get Module."""
+	logicalPathSourceModule: identifierDotAttribute = getLogicalPath(identifierPackage, logicalPathInfix, moduleIdentifier)
+	astModule: ast.Module = parseLogicalPath2astModule(logicalPathSourceModule)
+	return astModule
+
+def getPathFilename(pathRoot: PathLike[str] | PurePath | None = packageSettings.pathPackage, logicalPathInfix: PathLike[str] | PurePath | str | None = None, moduleIdentifier: str = '', fileExtension: str = packageSettings.fileExtension) -> PurePath:
+	"""Construct filesystem path from logical path.
+
+	Parameters
+	----------
+	pathRoot : PathLike[str] | PurePath | None = packageSettings.pathPackage
+		Base directory for the package structure.
+	logicalPathInfix : PathLike[str] | PurePath | str | None = None
+		Subdirectory for organizing generated modules.
+	moduleIdentifier : str = ''
+		Name of the specific module file.
+	fileExtension : str = packageSettings.fileExtension
+		File extension for Python modules.
+
+	Returns
+	-------
+	pathFilename : PurePath
+		Complete filesystem path for the generated module file.
+
+	"""
+	pathFilename = PurePath(moduleIdentifier + fileExtension)
+	if logicalPathInfix:
+		pathFilename = PurePath(*(str(logicalPathInfix).split('.')), pathFilename)
+	if pathRoot:
+		pathFilename = PurePath(pathRoot, pathFilename)
+	return pathFilename
+
+def write_astModule(astModule: ast.Module, pathFilename: PathLike[Any] | PurePath | io.TextIOBase, packageName: str | None = None) -> None:
+	"""Prototype.
+
+	Parameters
+	----------
+	astModule : ast.Module
+		The AST module to be written to a file.
+	pathFilename : PathLike[Any] | PurePath
+		The file path where the module should be written.
+	packageName : str | None = None
+		Optional package name to preserve in import optimization.
+	"""
+	ast.fix_missing_locations(astModule)
+	pythonSource: str = ast.unparse(astModule)
+	autoflake_additional_imports: list[str] = []
+	if packageName:
+		autoflake_additional_imports.append(packageName)
+	pythonSource = autoflake_fix_code(pythonSource, autoflake_additional_imports, expand_star_imports=False, remove_all_unused_imports=True, remove_duplicate_keys = False, remove_unused_variables = False)
+	writeStringToHere(pythonSource, pathFilename)
+

mapFolding/someAssemblyRequired/toolkitNumba.py

@@ -136,7 +136,7 @@ While Numba offers multiple decorators (`@jit`, `@njit`, `@vectorize`), this too
 on the general-purpose `@jit` decorator with configurable parameters for flexibility.
 """
 
-def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, parametersNumba: ParametersNumba | None = None) -> IngredientsFunction:  # noqa: C901
+def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, parametersNumba: ParametersNumba | None = None) -> IngredientsFunction:
 	"""Transform a Python function into a Numba-accelerated version with appropriate decorators.
 
 	(AI generated docstring)

mapFolding/someAssemblyRequired/transformationTools.py

@@ -192,3 +192,4 @@ def unpackDataclassCallFunctionRepackDataclass(ingredientsCaller: IngredientsFun
 	unpack4targetCallable.visit(ingredientsCaller.astFunctionDef)
 	repack4targetCallable.visit(ingredientsCaller.astFunctionDef)
 	return ingredientsCaller
+

mapFolding/syntheticModules/A007822/__init__.py

@@ -0,0 +1 @@
+"""Everything in this directory is synthesized by other modules in the package."""

mapFolding/syntheticModules/A007822/asynchronous.py

@@ -0,0 +1,148 @@
+from mapFolding.dataBaskets import MapFoldingState
+from mapFolding.syntheticModules.A007822.asynchronousAnnex import (
+	filterAsymmetricFolds, getAsymmetricFoldsTotal, initializeConcurrencyManager)
+
+def activeLeafGreaterThan0(state: MapFoldingState) -> bool:
+    return state.leaf1ndex > 0
+
+def activeLeafGreaterThanLeavesTotal(state: MapFoldingState) -> bool:
+    return state.leaf1ndex > state.leavesTotal
+
+def activeLeafIsTheFirstLeaf(state: MapFoldingState) -> bool:
+    return state.leaf1ndex <= 1
+
+def activeLeafIsUnconstrainedInAllDimensions(state: MapFoldingState) -> bool:
+    return not state.dimensionsUnconstrained
+
+def activeLeafUnconstrainedInThisDimension(state: MapFoldingState) -> MapFoldingState:
+    state.dimensionsUnconstrained -= 1
+    return state
+
+def filterCommonGaps(state: MapFoldingState) -> MapFoldingState:
+    state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
+    if state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] == state.dimensionsUnconstrained:
+        state = incrementActiveGap(state)
+    state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] = 0
+    return state
+
+def gapAvailable(state: MapFoldingState) -> bool:
+    return state.leaf1ndex > 0
+
+def incrementActiveGap(state: MapFoldingState) -> MapFoldingState:
+    state.gap1ndex += 1
+    return state
+
+def incrementGap1ndexCeiling(state: MapFoldingState) -> MapFoldingState:
+    state.gap1ndexCeiling += 1
+    return state
+
+def incrementIndexMiniGap(state: MapFoldingState) -> MapFoldingState:
+    state.indexMiniGap += 1
+    return state
+
+def initializeIndexMiniGap(state: MapFoldingState) -> MapFoldingState:
+    state.indexMiniGap = state.gap1ndex
+    return state
+
+def initializeVariablesToFindGaps(state: MapFoldingState) -> MapFoldingState:
+    state.dimensionsUnconstrained = state.dimensionsTotal
+    state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
+    state.indexDimension = 0
+    return state
+
+def insertActiveLeaf(state: MapFoldingState) -> MapFoldingState:
+    state.indexLeaf = 0
+    while state.indexLeaf < state.leaf1ndex:
+        state.gapsWhere[state.gap1ndexCeiling] = state.indexLeaf
+        state.gap1ndexCeiling += 1
+        state.indexLeaf += 1
+    return state
+
+def insertActiveLeafAtGap(state: MapFoldingState) -> MapFoldingState:
+    state.gap1ndex -= 1
+    state.leafAbove[state.leaf1ndex] = state.gapsWhere[state.gap1ndex]
+    state.leafBelow[state.leaf1ndex] = state.leafBelow[state.leafAbove[state.leaf1ndex]]
+    state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leaf1ndex
+    state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
+    state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
+    state.leaf1ndex += 1
+    return state
+
+def leafBelowSentinelIs1(state: MapFoldingState) -> bool:
+    return state.leafBelow[0] == 1
+
+def leafConnecteeIsActiveLeaf(state: MapFoldingState) -> bool:
+    return state.leafConnectee == state.leaf1ndex
+
+def lookForGaps(state: MapFoldingState) -> MapFoldingState:
+    state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
+    if state.countDimensionsGapped[state.leafConnectee] == 0:
+        state = incrementGap1ndexCeiling(state)
+    state.countDimensionsGapped[state.leafConnectee] += 1
+    return state
+
+def lookupLeafConnecteeInConnectionGraph(state: MapFoldingState) -> MapFoldingState:
+    state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
+    return state
+
+def loopingLeavesConnectedToActiveLeaf(state: MapFoldingState) -> bool:
+    return state.leafConnectee != state.leaf1ndex
+
+def loopingThroughTheDimensions(state: MapFoldingState) -> bool:
+    return state.indexDimension < state.dimensionsTotal
+
+def loopingToActiveGapCeiling(state: MapFoldingState) -> bool:
+    return state.indexMiniGap < state.gap1ndexCeiling
+
+def noGapsHere(state: MapFoldingState) -> bool:
+    return state.leaf1ndex > 0 and state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1]
+
+def tryAnotherLeafConnectee(state: MapFoldingState) -> MapFoldingState:
+    state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
+    return state
+
+def tryNextDimension(state: MapFoldingState) -> MapFoldingState:
+    state.indexDimension += 1
+    return state
+
+def undoLastLeafPlacement(state: MapFoldingState) -> MapFoldingState:
+    state.leaf1ndex -= 1
+    state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leafBelow[state.leaf1ndex]
+    state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leafAbove[state.leaf1ndex]
+    return state
+
+def count(state: MapFoldingState) -> MapFoldingState:
+    while activeLeafGreaterThan0(state):
+        if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
+            if activeLeafGreaterThanLeavesTotal(state):
+                filterAsymmetricFolds(state.leafBelow)
+            else:
+                state = initializeVariablesToFindGaps(state)
+                while loopingThroughTheDimensions(state):
+                    state = lookupLeafConnecteeInConnectionGraph(state)
+                    if leafConnecteeIsActiveLeaf(state):
+                        state = activeLeafUnconstrainedInThisDimension(state)
+                    else:
+                        while loopingLeavesConnectedToActiveLeaf(state):
+                            state = lookForGaps(state)
+                            state = tryAnotherLeafConnectee(state)
+                    state = tryNextDimension(state)
+                if activeLeafIsUnconstrainedInAllDimensions(state):
+                    state = insertActiveLeaf(state)
+                state = initializeIndexMiniGap(state)
+                while loopingToActiveGapCeiling(state):
+                    state = filterCommonGaps(state)
+                    state = incrementIndexMiniGap(state)
+        while noGapsHere(state):
+            state = undoLastLeafPlacement(state)
+        if gapAvailable(state):
+            state = insertActiveLeafAtGap(state)
+    else:
+        state.groupsOfFolds = getAsymmetricFoldsTotal()
+    state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
+    return state
+
+def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
+    initializeConcurrencyManager()
+    state = count(state)
+    return state

mapFolding/syntheticModules/A007822/asynchronousAnnex.py

@@ -0,0 +1,68 @@
+from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
+from hunterMakesPy import raiseIfNone
+from mapFolding import Array1DLeavesTotal
+from queue import Empty, Queue
+from threading import Thread
+import numpy
+
+
+concurrencyManager = None
+groupsOfFoldsTotal: int = 0
+processingThread = None
+queueFutures: Queue[ConcurrentFuture[int]] = Queue()
+
+def initializeConcurrencyManager(maxWorkers: int | None=None, groupsOfFolds: int=0) -> None:
+    global concurrencyManager, queueFutures, groupsOfFoldsTotal, processingThread
+    concurrencyManager = ProcessPoolExecutor(max_workers=maxWorkers)
+    queueFutures = Queue()
+    groupsOfFoldsTotal = groupsOfFolds
+    processingThread = Thread(target=_processCompletedFutures)
+    processingThread.start()
+
+def _processCompletedFutures() -> None:
+    global queueFutures, groupsOfFoldsTotal
+    while True:
+        try:
+            claimTicket: ConcurrentFuture[int] = queueFutures.get(timeout=1)
+            if claimTicket is None:
+                break
+            groupsOfFoldsTotal += claimTicket.result()
+        except Empty:
+            continue
+
+def _filterAsymmetricFolds(leafBelow: Array1DLeavesTotal) -> int:
+    groupsOfFolds = 0
+    leafComparison: Array1DLeavesTotal = numpy.zeros_like(leafBelow)
+    leavesTotal = leafBelow.size - 1
+    indexLeaf = 0
+    leafConnectee = 0
+    while leafConnectee < leavesTotal + 1:
+        leafNumber = int(leafBelow[indexLeaf])
+        leafComparison[leafConnectee] = (leafNumber - indexLeaf + leavesTotal) % leavesTotal
+        indexLeaf = leafNumber
+        leafConnectee += 1
+    indexInMiddle = leavesTotal // 2
+    indexDistance = 0
+    while indexDistance < leavesTotal + 1:
+        ImaSymmetricFold = True
+        leafConnectee = 0
+        while leafConnectee < indexInMiddle:
+            if leafComparison[(indexDistance + leafConnectee) % (leavesTotal + 1)] != leafComparison[(indexDistance + leavesTotal - 1 - leafConnectee) % (leavesTotal + 1)]:
+                ImaSymmetricFold = False
+                break
+            leafConnectee += 1
+        if ImaSymmetricFold:
+            groupsOfFolds += 1
+        indexDistance += 1
+    return groupsOfFolds
+
+def filterAsymmetricFolds(leafBelow: Array1DLeavesTotal) -> None:
+    global concurrencyManager, queueFutures
+    queueFutures.put(raiseIfNone(concurrencyManager).submit(_filterAsymmetricFolds, leafBelow.copy()))
+
+def getAsymmetricFoldsTotal() -> int:
+    global concurrencyManager, queueFutures, processingThread
+    raiseIfNone(concurrencyManager).shutdown(wait=True)
+    queueFutures.put(None)
+    raiseIfNone(processingThread).join()
+    return groupsOfFoldsTotal