mapFolding 0.15.4__py3-none-any.whl → 0.16.1__py3-none-any.whl

mapFolding/someAssemblyRequired/meanders/makeMeandersModules.py

@@ -0,0 +1,64 @@
+"""makeMeandersModules."""
+from astToolkit import (
+	astModuleToIngredientsFunction, Be, Grab, identifierDotAttribute, Make, NodeChanger, NodeTourist, Then)
+from hunterMakesPy import raiseIfNone
+from mapFolding import packageSettings
+from mapFolding.someAssemblyRequired import (
+	identifierCallableSourceDEFAULT, identifierCallableSourceDispatcherDEFAULT, IfThis, logicalPathInfixDEFAULT)
+from mapFolding.someAssemblyRequired.toolkitMakeModules import (
+	findDataclass, getModule, getPathFilename, write_astModule)
+from os import PathLike
+from pathlib import PurePath
+import ast
+
+identifierDataclassNumPyHARDCODED = 'MatrixMeandersNumPyState'
+
+logicalPathInfixMeanders: str = logicalPathInfixDEFAULT + '.meanders'
+
+def makeCountBigInt(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:
+	"""Make `countBigInt` module for meanders using `MatrixMeandersNumPyState` dataclass."""
+	identifierDataclassNumPy: str = identifierDataclassNumPyHARDCODED
+	_logicalPathDataclass, identifierDataclassOld, identifierDataclassInstance = findDataclass(astModuleToIngredientsFunction(astModule, raiseIfNone(sourceCallableDispatcher)))
+
+	NodeChanger(findThis=Be.FunctionDef.nameIs(IfThis.isIdentifier(identifierCallableSourceDEFAULT))
+		, doThat=Grab.nameAttribute(Then.replaceWith(raiseIfNone(callableIdentifier)))
+	).visit(astModule)
+
+	# Remove `doTheNeedful`
+	NodeChanger(Be.FunctionDef.nameIs(IfThis.isIdentifier(sourceCallableDispatcher)), Then.removeIt).visit(astModule)
+
+	# Change to `MatrixMeandersNumPyState`
+	NodeChanger(Be.Name.idIs(IfThis.isIdentifier(identifierDataclassOld))
+			, Grab.idAttribute(Then.replaceWith(identifierDataclassNumPy))
+		).visit(astModule)
+
+	NodeChanger(Be.alias.nameIs(IfThis.isIdentifier(identifierDataclassOld))
+			, Grab.nameAttribute(Then.replaceWith(identifierDataclassNumPy))
+		).visit(astModule)
+
+	# while (state.kOfMatrix > 0 and areIntegersWide(state)):  # noqa: ERA001
+	Call_areIntegersWide: ast.Call = Make.Call(Make.Name('areIntegersWide'), listParameters=[Make.Name('state')])
+	astCompare: ast.Compare = raiseIfNone(NodeTourist(
+		findThis=IfThis.isAttributeNamespaceIdentifierGreaterThan0(identifierDataclassInstance, 'kOfMatrix')
+		, doThat=Then.extractIt
+	).captureLastMatch(astModule))
+	newTest: ast.expr = Make.And.join([astCompare, Call_areIntegersWide])
+
+	NodeChanger(IfThis.isWhileAttributeNamespaceIdentifierGreaterThan0(identifierDataclassInstance, 'kOfMatrix')
+			, Grab.testAttribute(Then.replaceWith(newTest))
+	).visit(astModule)
+
+	# from mapFolding.algorithms.matrixMeandersBeDry import areIntegersWide  # noqa: ERA001
+	astModule.body.insert(0, Make.ImportFrom('mapFolding.algorithms.matrixMeandersBeDry', list_alias=[Make.alias('areIntegersWide')]))
+
+	pathFilename = getPathFilename(logicalPathInfix=logicalPathInfix, moduleIdentifier=moduleIdentifier)
+
+	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
+
+	return pathFilename
+
+if __name__ == '__main__':
+	astModule = getModule(logicalPathInfix='algorithms', moduleIdentifier='matrixMeanders')
+	pathFilename = makeCountBigInt(astModule, 'bigInt', 'countBigInt', logicalPathInfixMeanders, identifierCallableSourceDispatcherDEFAULT)
+
+

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
+import isort
+
+def findDataclass(ingredientsFunction: IngredientsFunction) -> tuple[identifierDotAttribute, str, str]:
+	"""Dynamically extract information about a `dataclass`: the instance identifier, the identifier, and the logical path module.
+
+	Like many things in the "IngredientsFunction/IngredientsModule" ecosystem, this has specific requirements.
+	`ingredientsFunction` must have the dataclass as its first parameter. The `LedgerOfImports` in `ingredientsFunction` must have
+	the import information for the dataclass. If you are not using `IngredientsFunction`, you can still use this function to get
+	the information you want.
+
+	```python
+	from astToolkit import astModuleToIngredientsFunction
+
+	tupleInformation = findDataclass(astModuleToIngredientsFunction(astAST, identifier))
+	```
+
+	Parameters
+	----------
+	ingredientsFunction : IngredientsFunction
+		Function container with AST and import information.
+
+	Returns
+	-------
+	logicalPathDataclass : identifierDotAttribute
+		Logical path from which the `dataclass` is imported, which might not be the real source of the `dataclass`.
+	identifierDataclass : str
+		Identifier of the `dataclass`.
+	identifierDataclassInstance : str
+		Identifier of the `dataclass` instance.
+	"""
+	dataclassName: ast.expr = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(ingredientsFunction.astFunctionDef))
+	identifierDataclass: str = raiseIfNone(NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName))
+	logicalPathDataclass = None
+	for moduleWithLogicalPath, listNameTuples in ingredientsFunction.imports._dictionaryImportFrom.items():  # noqa: SLF001
+		for nameTuple in listNameTuples:
+			if nameTuple[0] == identifierDataclass:
+				logicalPathDataclass = moduleWithLogicalPath
+				break
+		if logicalPathDataclass:
+			break
+	identifierDataclassInstance: identifierDotAttribute = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
+	return raiseIfNone(logicalPathDataclass), identifierDataclass, identifierDataclassInstance
+
+def getLogicalPath(identifierPackage: str | None = None, logicalPathInfix: identifierDotAttribute | 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: identifierDotAttribute | 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 that will likely be moved to astToolkit.
+
+	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)
+	pythonSource = isort.code(pythonSource)
+	writeStringToHere(pythonSource + '\n', 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/{algorithmA007822.py → A007822/algorithm.py}

@@ -18,8 +18,7 @@ def filterAsymmetricFolds(state: MapFoldingState) -> MapFoldingState:
                 ImaSymmetricFold = False
                 break
             leafConnectee += 1
-        if ImaSymmetricFold:
-            state.groupsOfFolds += 1
+        state.groupsOfFolds += ImaSymmetricFold
         state.indexMiniGap += 1
     return state
 
@@ -163,4 +162,4 @@ def count(state: MapFoldingState) -> MapFoldingState:
 
 def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
     state = count(state)
-    return state
+    return state

mapFolding/syntheticModules/{algorithmA007822Numba.py → A007822/algorithmNumba.py}

@@ -1,6 +1,4 @@
-from mapFolding.dataBaskets import (
-	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
-	MapFoldingState)
+from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
 from numba import jit
 
 @jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
@@ -25,8 +23,7 @@ def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1nde
                             ImaSymmetricFold = False
                             break
                         leafConnectee += 1
-                    if ImaSymmetricFold:
-                        groupsOfFolds += 1
+                    groupsOfFolds += ImaSymmetricFold
                     indexMiniGap += 1
             else:
                 dimensionsUnconstrained = dimensionsTotal
@@ -94,4 +91,4 @@ def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
     leavesTotal: DatatypeLeavesTotal = state.leavesTotal
     groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, leavesTotal)
     state = MapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, leafComparison=leafComparison)
-    return state
+    return state

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,66 @@
+from concurrent.futures import Future as ConcurrentFuture, ThreadPoolExecutor
+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 = ThreadPoolExecutor(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
+        groupsOfFolds += ImaSymmetricFold
+        indexDistance += 1
+    return groupsOfFolds
+
+def filterAsymmetricFolds(leafBelow: Array1DLeavesTotal) -> None:
+    global concurrencyManager, queueFutures
+    queueFutures.put_nowait(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

mapFolding/syntheticModules/A007822/asynchronousAnnexNumba.py

@@ -0,0 +1,85 @@
+from mapFolding import Array1DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
+from queue import Queue
+from threading import Lock, Thread
+import numba
+import numpy
+
+listThreads: list[Thread] = []
+queueFutures: Queue[Array1DLeavesTotal] = Queue()
+groupsOfFoldsTotal: int = 0
+groupsOfFoldsTotalLock = Lock()
+sentinelStop = object()
+
+def initializeConcurrencyManager(maxWorkers: int, groupsOfFolds: int=0) -> None:
+	global listThreads, groupsOfFoldsTotal, queueFutures  # noqa: PLW0603
+	listThreads = []
+	queueFutures = Queue()
+	groupsOfFoldsTotal = groupsOfFolds
+	indexThread = 0
+	while indexThread < maxWorkers:
+		thread = Thread(target=_threadDoesSomething, name=f"thread{indexThread}", daemon=True)
+		thread.start()
+		listThreads.append(thread)
+		indexThread += 1
+
+def _threadDoesSomething() -> None:
+	global groupsOfFoldsTotal  # noqa: PLW0603
+	while True:
+		leafBelow = queueFutures.get()
+		if leafBelow is sentinelStop:  # pyright: ignore[reportUnnecessaryComparison]
+			break
+		symmetricFolds = _filterAsymmetricFolds(leafBelow)
+		with groupsOfFoldsTotalLock:
+			groupsOfFoldsTotal += symmetricFolds
+
+@numba.jit(cache=True, error_model='numpy', fastmath=True)
+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
+		groupsOfFolds += ImaSymmetricFold
+		indexDistance += 1
+	return groupsOfFolds
+
+def _go(leafBelow: Array1DLeavesTotal) -> None:
+	queueFutures.put_nowait(leafBelow.copy())
+
+
+# @numba.jit(numba.int64(numba.int64[:]), cache=True, error_model='numpy', fastmath=True)
+def filterAsymmetricFolds(leafBelow: Array1DLeavesTotal) -> int:  # non-blocking submission
+	# Must not block caller; enqueue for background processing
+	_go(leafBelow)
+	return 60  # GO
+
+def _stop() -> DatatypeFoldsTotal:
+	global listThreads  # noqa: PLW0602
+	# Signal all workers to stop after queue drained
+	for _thread in listThreads:
+		queueFutures.put(sentinelStop)  # pyright: ignore[reportArgumentType]
+	for thread in listThreads:
+		thread.join()
+	return groupsOfFoldsTotal
+
+
+
+@numba.jit(numba.uint64(), cache=True, error_model='numpy', fastmath=True, forceobj=True)
+def getAsymmetricFoldsTotal() -> DatatypeFoldsTotal:
+	total = _stop()
+	return total

mapFolding/syntheticModules/A007822/asynchronousNumba.py

@@ -0,0 +1,52 @@
+from mapFolding.dataBaskets import (
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal)
+from mapFolding.syntheticModules.A007822.asynchronousAnnexNumba import filterAsymmetricFolds, getAsymmetricFoldsTotal
+from mapFolding.syntheticModules.dataPackingA007822 import unRePackDataclassAsynchronous
+from numba import jit
+
+@unRePackDataclassAsynchronous
+@jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
+def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1ndexCeiling: DatatypeElephino, indexDimension: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, connectionGraph: Array3DLeavesTotal, dimensionsTotal: DatatypeLeavesTotal, leavesTotal: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal]:
+    while leaf1ndex > 4:
+        if leafBelow[0] == 1:
+            if leaf1ndex > leavesTotal:
+                filterAsymmetricFolds(leafBelow)
+            else:
+                dimensionsUnconstrained = dimensionsTotal
+                gap1ndexCeiling = gapRangeStart[leaf1ndex - 1]
+                indexDimension = 0
+                while indexDimension < dimensionsTotal:
+                    leafConnectee = connectionGraph[indexDimension, leaf1ndex, leaf1ndex]
+                    if leafConnectee == leaf1ndex:
+                        dimensionsUnconstrained -= 1
+                    else:
+                        while leafConnectee != leaf1ndex:
+                            gapsWhere[gap1ndexCeiling] = leafConnectee
+                            if countDimensionsGapped[leafConnectee] == 0:
+                                gap1ndexCeiling += 1
+                            countDimensionsGapped[leafConnectee] += 1
+                            leafConnectee = connectionGraph[indexDimension, leaf1ndex, leafBelow[leafConnectee]]
+                    indexDimension += 1
+                indexMiniGap = gap1ndex
+                while indexMiniGap < gap1ndexCeiling:
+                    gapsWhere[gap1ndex] = gapsWhere[indexMiniGap]
+                    if countDimensionsGapped[gapsWhere[indexMiniGap]] == dimensionsUnconstrained:
+                        gap1ndex += 1
+                    countDimensionsGapped[gapsWhere[indexMiniGap]] = 0
+                    indexMiniGap += 1
+        while gap1ndex == gapRangeStart[leaf1ndex - 1]:
+            leaf1ndex -= 1
+            leafBelow[leafAbove[leaf1ndex]] = leafBelow[leaf1ndex]
+            leafAbove[leafBelow[leaf1ndex]] = leafAbove[leaf1ndex]
+        gap1ndex -= 1
+        leafAbove[leaf1ndex] = gapsWhere[gap1ndex]
+        leafBelow[leaf1ndex] = leafBelow[leafAbove[leaf1ndex]]
+        leafBelow[leafAbove[leaf1ndex]] = leaf1ndex
+        leafAbove[leafBelow[leaf1ndex]] = leaf1ndex
+        gapRangeStart[leaf1ndex] = gap1ndex
+        leaf1ndex += 1
+    else:
+        groupsOfFolds = getAsymmetricFoldsTotal()
+        groupsOfFolds *= 2
+    groupsOfFolds = (groupsOfFolds + 1) // 2
+    return (groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)