mapFolding 0.16.2__py3-none-any.whl → 0.16.4__py3-none-any.whl

mapFolding/dataBaskets.py

@@ -21,8 +21,8 @@ integrity throughout the recursive analysis while providing the structured data
 access patterns that enable efficient result persistence and retrieval.
 """
 from mapFolding import (
-	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
-	getConnectionGraph, getLeavesTotal, makeDataContainer)
+	Array1DElephino, Array1DLeavesTotal, Array2DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal,
+	DatatypeLeavesTotal, getConnectionGraph, getLeavesTotal, makeDataContainer)
 from numpy.typing import NDArray
 from typing import TypeAlias
 import dataclasses
@@ -111,8 +111,6 @@ class MapFoldingState:
 	"""Array tracking the leaves above to the current leaf, `leaf1ndex`, during computation."""
 	leafBelow: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
 	"""Array tracking the leaves below to the current leaf, `leaf1ndex`, during computation."""
-	leafComparison: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
-	"""Array for finding symmetric folds."""
 
 	connectionGraph: Array3DLeavesTotal = dataclasses.field(init=False, metadata={'dtype': Array3DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
 	"""Unchanging array representing connections between all leaves."""
@@ -126,7 +124,7 @@ class MapFoldingState:
 
 		Returns
 		-------
-		totalFoldings : DatatypeFoldsTotal
+		foldsTotal : DatatypeFoldsTotal
 			The complete count of distinct folding patterns achievable with the current map configuration.
 
 		"""
@@ -154,6 +152,126 @@ class MapFoldingState:
 		if self.gapRangeStart is None: self.gapRangeStart = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['gapRangeStart'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
 		if self.leafAbove is None: self.leafAbove = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafAbove'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
 		if self.leafBelow is None: self.leafBelow = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafBelow'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
+
+@dataclasses.dataclass(slots=True)
+class SymmetricFoldsState:
+	"""Core computational state for symmetric map folding algorithms.
+
+	Attributes
+	----------
+	mapShape : tuple[DatatypeLeavesTotal, ...]
+		Dimensions of the map being analyzed for folding patterns.
+	groupsOfFolds : DatatypeFoldsTotal = DatatypeFoldsTotal(0)
+		Current count of distinct folding pattern groups: each group has `leavesTotal`-many foldings.
+	gap1ndex : DatatypeElephino = DatatypeElephino(0)
+		The current 1-indexed position of the 'gap' during computation: 1-indexed as opposed to 0-indexed.
+	gap1ndexCeiling : DatatypeElephino = DatatypeElephino(0)
+		The upper bound of `gap1ndex`.
+	indexDimension : DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+		The current 0-indexed position of the dimension during computation.
+	indexLeaf : DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+		The current 0-indexed position of a leaf in a loop during computation: not to be confused with `leaf1ndex`.
+	indexMiniGap : DatatypeElephino = DatatypeElephino(0)
+		The current 0-indexed position of a 'gap' in a loop during computation.
+	leaf1ndex : DatatypeLeavesTotal = DatatypeLeavesTotal(1)
+		The current 1-indexed position of the leaf during computation: 1-indexed as opposed to 0-indexed.
+	leafConnectee : DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+		Target leaf for connection operations.
+	dimensionsUnconstrained : DatatypeLeavesTotal = None
+		Count of dimensions not subject to folding constraints.
+	countDimensionsGapped : Array1DLeavesTotal = None
+		Array tracking computed number of dimensions with gaps.
+	gapRangeStart : Array1DElephino = None
+		Array tracking computed starting positions of gap ranges.
+	gapsWhere : Array1DLeavesTotal = None
+		Array indicating locations of gaps in the folding pattern.
+	leafAbove : Array1DLeavesTotal = None
+		Array tracking the leaves above to the current leaf, `leaf1ndex`, during computation.
+	leafBelow : Array1DLeavesTotal = None
+		Array tracking the leaves below to the current leaf, `leaf1ndex`, during computation.
+	leafComparison : Array1DLeavesTotal = None
+		Array for finding symmetric folds.
+	connectionGraph : Array3DLeavesTotal
+		Unchanging array representing connections between all leaves.
+	dimensionsTotal : DatatypeLeavesTotal
+		Unchanging total number of dimensions in the map.
+	leavesTotal : DatatypeLeavesTotal
+		Unchanging total number of leaves in the map.
+
+	"""
+
+	mapShape: tuple[DatatypeLeavesTotal, ...] = dataclasses.field(init=True, metadata={'elementConstructor': 'DatatypeLeavesTotal'})
+	"""Dimensions of the map being analyzed for folding patterns."""
+
+	groupsOfFolds: DatatypeFoldsTotal = dataclasses.field(default=DatatypeFoldsTotal(0), metadata={'theCountingIdentifier': True})
+	"""Current count of symmetric folds."""
+
+	gap1ndex: DatatypeElephino = DatatypeElephino(0)  # noqa: RUF009
+	"""The current 1-indexed position of the 'gap' during computation: 1-indexed as opposed to 0-indexed."""
+	gap1ndexCeiling: DatatypeElephino = DatatypeElephino(0)  # noqa: RUF009
+	"""The upper bound of `gap1ndex`."""
+	indexDimension: DatatypeLeavesTotal = DatatypeLeavesTotal(0)  # noqa: RUF009
+	"""The current 0-indexed position of the dimension during computation."""
+	indexLeaf: DatatypeLeavesTotal = DatatypeLeavesTotal(0)  # noqa: RUF009
+	"""The current 0-indexed position of a leaf in a loop during computation: not to be confused with `leaf1ndex`."""
+	indexMiniGap: DatatypeElephino = DatatypeElephino(0)  # noqa: RUF009
+	"""The current 0-indexed position of a 'gap' in a loop during computation."""
+	leaf1ndex: DatatypeLeavesTotal = DatatypeLeavesTotal(1)  # noqa: RUF009
+	"""The current 1-indexed position of the leaf during computation: 1-indexed as opposed to 0-indexed."""
+	leafConnectee: DatatypeLeavesTotal = DatatypeLeavesTotal(0)  # noqa: RUF009
+	"""Target leaf for connection operations."""
+
+	dimensionsUnconstrained: DatatypeLeavesTotal = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	"""Count of dimensions not subject to folding constraints."""
+
+	countDimensionsGapped: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	"""Array tracking computed number of dimensions with gaps."""
+	gapRangeStart: Array1DElephino = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DElephino.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	"""Array tracking computed starting positions of gap ranges."""
+	gapsWhere: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	"""Array indicating locations of gaps in the folding pattern."""
+	leafAbove: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	"""Array tracking the leaves above to the current leaf, `leaf1ndex`, during computation."""
+	leafBelow: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	"""Array tracking the leaves below to the current leaf, `leaf1ndex`, during computation."""
+	leafComparison: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	"""Array for finding symmetric folds."""
+
+	arrayGroupOfFolds: Array2DLeavesTotal = dataclasses.field(init=False, metadata={'dtype': Array2DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
+	connectionGraph: Array3DLeavesTotal = dataclasses.field(init=False, metadata={'dtype': Array3DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
+	"""Unchanging array representing connections between all leaves."""
+	dimensionsTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
+	"""Unchanging total number of dimensions in the map."""
+	indicesArrayGroupOfFolds: Array2DLeavesTotal = dataclasses.field(init=False, metadata={'dtype': Array2DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
+	leavesTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
+	"""Unchanging total number of leaves in the map."""
+
+	def __post_init__(self) -> None:
+		"""Ensure all fields have a value.
+
+		Notes
+		-----
+		Arrays that are not explicitly provided (None) are automatically allocated with appropriate sizes based on the map
+		dimensions. `dimensionsTotal`, `leavesTotal`, and `connectionGraph` cannot be set: they are calculated.
+
+		"""
+		self.dimensionsTotal = DatatypeLeavesTotal(len(self.mapShape))
+		self.leavesTotal = DatatypeLeavesTotal(getLeavesTotal(self.mapShape))
+
+		leavesTotalAsInt = int(self.leavesTotal)
+
+		self.connectionGraph = getConnectionGraph(self.mapShape, leavesTotalAsInt, self.__dataclass_fields__['connectionGraph'].metadata['dtype'])
+
+		self.indicesArrayGroupOfFolds = (numpy.arange(leavesTotalAsInt + 1)[:, None] + numpy.arange(leavesTotalAsInt)[None, :]) % (leavesTotalAsInt + 1)
+		self.indicesArrayGroupOfFolds[..., leavesTotalAsInt // 2:None] = self.indicesArrayGroupOfFolds[..., leavesTotalAsInt - 1: leavesTotalAsInt - leavesTotalAsInt // 2 - 1: -1]
+		self.arrayGroupOfFolds = numpy.zeros_like(self.indicesArrayGroupOfFolds)
+
+		if self.dimensionsUnconstrained is None: self.dimensionsUnconstrained = DatatypeLeavesTotal(int(self.dimensionsTotal)) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
+		if self.gapsWhere is None: self.gapsWhere = makeDataContainer(leavesTotalAsInt * leavesTotalAsInt + 1, self.__dataclass_fields__['gapsWhere'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
+		if self.countDimensionsGapped is None: self.countDimensionsGapped = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['countDimensionsGapped'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
+		if self.gapRangeStart is None: self.gapRangeStart = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['gapRangeStart'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
+		if self.leafAbove is None: self.leafAbove = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafAbove'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
+		if self.leafBelow is None: self.leafBelow = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafBelow'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
 		if self.leafComparison is None: self.leafComparison = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafComparison'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
 
 @dataclasses.dataclass

mapFolding/filesystemToolkit.py

@@ -56,12 +56,10 @@ def getFilenameFoldsTotal(mapShape: tuple[int, ...]) -> str:
 	return 'p' + 'x'.join(str(dimension) for dimension in sorted(mapShape)) + '.foldsTotal'
 
 def getPathFilenameFoldsTotal(mapShape: tuple[int, ...], pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None) -> Path:
-	"""Get a standardized path and filename for the computed `foldsTotal` value.
+	"""Get a standardized filename and create a configurable path to store the computed `foldsTotal` value.
 
-	(AI generated docstring)
-
-	This function resolves paths for storing computation results, handling different input types including directories,
-	absolute paths, or relative paths. It ensures that all parent directories exist in the resulting path.
+	To help reduce duplicate code and to increase predictability, this function creates a standardized filename, has a default but
+	configurable path, and creates the path.
 
 	Parameters
 	----------
@@ -78,10 +76,9 @@ def getPathFilenameFoldsTotal(mapShape: tuple[int, ...], pathLikeWriteFoldsTotal
 	Notes
 	-----
 	The function creates any necessary directories in the path if they don't exist.
-
 	"""
 	if pathLikeWriteFoldsTotal is None:
-		pathFilenameFoldsTotal = getPathRootJobDEFAULT() / getFilenameFoldsTotal(mapShape)
+		pathFilenameFoldsTotal: Path = getPathRootJobDEFAULT() / getFilenameFoldsTotal(mapShape)
 	else:
 		pathLikeSherpa = Path(pathLikeWriteFoldsTotal)
 		if pathLikeSherpa.is_dir():
@@ -237,28 +234,3 @@ def saveFoldsTotalFAILearly(pathFilename: PathLike[str] | PurePath) -> None:
 	if foldsTotalRead != foldsTotal:
 		message = f"I wrote a test file to `{pathFilename = }` with contents of `{str(foldsTotal) = }`, but I read `{foldsTotalRead = }` from the file. Python says the values are not equal. Fix that now, so your computation doesn't get corrupted later. And be pro-social."
 		raise FileNotFoundError(message)
-
-def writeStringToHere(this: str, pathFilename: PathLike[str] | PurePath) -> None:
-	"""Write a string to a file, creating parent directories if needed.
-
-	(AI generated docstring)
-
-	This utility function provides a consistent interface for writing string content to files across the package. It
-	handles path creation and ensures proper string conversion.
-
-	Parameters
-	----------
-	this : str
-		The string content to write to the file.
-	pathFilename : PathLike[str] | PurePath
-		The target file path where the string should be written.
-
-	Notes
-	-----
-	This function creates all parent directories in the path if they don't exist, making it safe to use with newly
-	created directory structures.
-
-	"""
-	pathFilename = Path(pathFilename)
-	pathFilename.parent.mkdir(parents=True, exist_ok=True)
-	pathFilename.write_text(str(this))

mapFolding/oeis.py

@@ -306,12 +306,6 @@ def makeDictionaryFoldsTotalKnown() -> dict[tuple[int, ...], int]:
 def getFoldsTotalKnown(mapShape: tuple[int, ...]) -> int:
 	"""Retrieve the known total number of distinct folding patterns for a given map shape.
 
-	(AI generated docstring)
-
-	This function provides rapid access to precalculated folding totals from OEIS sequences without
-	requiring computation. It serves as a validation reference for algorithm results and enables
-	quick lookup of known values across all implemented sequences.
-
 	Parameters
 	----------
 	mapShape : tuple[int, ...]
@@ -320,17 +314,16 @@ def getFoldsTotalKnown(mapShape: tuple[int, ...]) -> int:
 	Returns
 	-------
 	foldingsTotal : int
-		The known total number of distinct folding patterns for the given map shape,
-		or -1 if the map shape does not match any known values in the OEIS sequences.
+		The known total number of distinct folding patterns for the given map shape, or 0 if the map shape does not match any
+		known values in the OEIS sequences.
 
 	Notes
 	-----
-	The function uses a cached dictionary for efficient retrieval without repeatedly processing
-	OEIS data. Map shapes are matched exactly as provided without internal sorting or normalization.
+	Map shapes are matched exactly as provided without internal sorting or normalization.
 
 	"""
-	lookupFoldsTotal = makeDictionaryFoldsTotalKnown()
-	return lookupFoldsTotal.get(tuple(mapShape), -1)
+	lookupFoldsTotal: dict[tuple[int, ...], int] = makeDictionaryFoldsTotalKnown()
+	return lookupFoldsTotal.get(tuple(mapShape), 0)
 
 def _formatHelpText() -> str:
 	"""Format comprehensive help text for both command-line and interactive use.

mapFolding/reference/A086345Wu.py

@@ -0,0 +1,25 @@
+# ruff: noqa: ANN001, T201, D103, D100, ANN201, ANN202
+# pyright: standard
+from fractions import Fraction
+from functools import cache
+from itertools import combinations
+from math import factorial, gcd, prod
+from sympy import divisors
+from sympy.functions.combinatorial.numbers import mobius
+from sympy.utilities.iterables import partitions
+import time
+
+# NOTE Because `b` and `c` are inside `A086345` instead of peers, the run time is increased by a factor of 6.
+
+def A086345(n):
+	@cache
+	def b(n): return int(sum(Fraction(3**(sum(p[r]*p[s]*gcd(r, s) for r, s in combinations(p.keys(), 2))+sum((q-1>>1)*r+(q*r*(r-1)>>1) for q, r in p.items())), prod(q**r*factorial(r) for q, r in p.items())) for p in partitions(n))) # pyright: ignore[reportAttributeAccessIssue, reportOperatorIssue]
+	@cache
+	def c(n): return n*b(n)-sum(c(k)*b(n-k) for k in range(1, n))
+	return sum(mobius(d)*c(n//d) for d in divisors(n, generator=True))//n if n else 1 # Chai Wah Wu, Jul 15 2024
+
+if __name__ == "__main__":
+	timeStart = time.perf_counter()
+	for n in range(51):
+		print(n, A086345(n))
+	print(time.perf_counter() - timeStart)

mapFolding/reference/matrixMeandersAnalysis/signatures.py

@@ -1,3 +1,6 @@
+"""buckets and signatures."""
+bucketsTotalMaximumBy_boundary: dict[int, int] = {1:3, 2:12, 3:40, 4:125, 5:392, 6:1254, 7:4087, 8:13623, 9:46181, 10:159137, 11:555469, 12:1961369, 13:6991893, 14:25134208}
+
 signatures: dict[str, dict[int, dict[int, int]]] = {'A000682': {2: {1: 1, 2: 3},
 3: {1: 1, 2: 3, 3: 3},
 4: {1: 1, 2: 3, 3: 4, 4: 4},

mapFolding/someAssemblyRequired/A007822/A007822rawMaterials.py

@@ -1,54 +1,19 @@
-from astToolkit import extractFunctionDef, identifierDotAttribute, Make  # noqa: D100
+from astToolkit import extractFunctionDef, Make  # noqa: D100
 from hunterMakesPy import raiseIfNone
-from mapFolding.someAssemblyRequired import (
-	identifierCallableSourceDEFAULT, identifierCallableSourceDispatcherDEFAULT, identifierCountingDEFAULT,
-	identifierDataclassInstanceDEFAULT, logicalPathInfixDEFAULT)
+from mapFolding.someAssemblyRequired import defaultA007822
+from mapFolding.someAssemblyRequired.toolkitMakeModules import getModule
 import ast
 
-identifierDataclass: str = identifierDataclassInstanceDEFAULT
-identifierCounting: str = identifierCountingDEFAULT
-logicalPathInfixA007822: identifierDotAttribute = logicalPathInfixDEFAULT + '.A007822'
-sourceCallableDispatcherA007822: str = identifierCallableSourceDispatcherDEFAULT
-sourceCallableIdentifierA007822: str = identifierCallableSourceDEFAULT
+FunctionDef_filterAsymmetricFolds: ast.FunctionDef = raiseIfNone(extractFunctionDef(getModule(logicalPathInfix='algorithms', identifierModule='symmetricFolds'), defaultA007822['function']['filterAsymmetricFolds']))
 
-identifier_filterAsymmetricFolds = 'filterAsymmetricFolds'
-
-ImaString = f"""
-def {identifier_filterAsymmetricFolds}({identifierDataclass}: MapFoldingState) -> MapFoldingState:
-	{identifierDataclass}.indexLeaf = 0
-	leafConnectee = 0
-	while leafConnectee < {identifierDataclass}.leavesTotal + 1:
-		leafNumber = int({identifierDataclass}.leafBelow[{identifierDataclass}.indexLeaf])
-		{identifierDataclass}.leafComparison[leafConnectee] = (leafNumber - {identifierDataclass}.indexLeaf + {identifierDataclass}.leavesTotal) % {identifierDataclass}.leavesTotal
-		{identifierDataclass}.indexLeaf = leafNumber
-		leafConnectee += 1
-
-	indexInMiddle = {identifierDataclass}.leavesTotal // 2
-	{identifierDataclass}.indexMiniGap = 0
-	while {identifierDataclass}.indexMiniGap < {identifierDataclass}.leavesTotal + 1:
-		ImaSymmetricFold = True
-		leafConnectee = 0
-		while leafConnectee < indexInMiddle:
-			if {identifierDataclass}.leafComparison[({identifierDataclass}.indexMiniGap + leafConnectee) % ({identifierDataclass}.leavesTotal + 1)] != {identifierDataclass}.leafComparison[({identifierDataclass}.indexMiniGap + {identifierDataclass}.leavesTotal - 1 - leafConnectee) % ({identifierDataclass}.leavesTotal + 1)]:
-				ImaSymmetricFold = False
-				break
-			leafConnectee += 1
-		{identifierDataclass}.{identifierCounting} += ImaSymmetricFold
-		{identifierDataclass}.indexMiniGap += 1
-
-	return {identifierDataclass}
-"""  # noqa: E501
-
-FunctionDef_filterAsymmetricFolds: ast.FunctionDef = raiseIfNone(extractFunctionDef(ast.parse(ImaString), identifier_filterAsymmetricFolds))
-del ImaString
-
-ImaString = f"{identifierDataclass} = {identifier_filterAsymmetricFolds}({identifierDataclass})"
+ImaString: str = f"{defaultA007822['variable']['stateInstance']} = {defaultA007822['function']['filterAsymmetricFolds']}({defaultA007822['variable']['stateInstance']})"
 A007822incrementCount = ast.parse(ImaString).body[0]
 del ImaString
 
-ImaString = f'{identifierDataclass}.{identifierCounting} = ({identifierDataclass}.{identifierCounting} + 1) // 2'
-A007822adjustFoldsTotal = ast.parse(ImaString).body[0]
+ImaString = f'{defaultA007822['variable']['stateInstance']}.{defaultA007822['variable']['counting']} = ({defaultA007822['variable']['stateInstance']}.{defaultA007822['variable']['counting']} + 1) // 2'
+A007822adjustFoldsTotal: ast.stmt = ast.parse(ImaString).body[0]
 del ImaString
 
-astExprCall_filterAsymmetricFoldsDataclass: ast.Expr = Make.Expr(Make.Call(Make.Name(identifier_filterAsymmetricFolds), listParameters=[Make.Attribute(Make.Name(identifierDataclass), 'leafBelow')]))
-astExprCall_filterAsymmetricFoldsLeafBelow: ast.Expr = Make.Expr(Make.Call(Make.Name(identifier_filterAsymmetricFolds), listParameters=[Make.Name('leafBelow')]))
+ExprCallFilterAsymmetricFolds_leafBelow: ast.Expr = Make.Expr(Make.Call(Make.Name(defaultA007822['function']['filterAsymmetricFolds']), listParameters=[Make.Name('leafBelow')]))
+ExprCallFilterAsymmetricFoldsState: ast.Expr = Make.Expr(Make.Call(Make.Name(defaultA007822['function']['filterAsymmetricFolds']), listParameters=[Make.Name(defaultA007822['variable']['stateInstance'])]))
+ExprCallFilterAsymmetricFoldsStateDot_leafBelow: ast.Expr = Make.Expr(Make.Call(Make.Name(defaultA007822['function']['filterAsymmetricFolds']), listParameters=[Make.Attribute(Make.Name(defaultA007822['variable']['stateInstance']), 'leafBelow')]))

mapFolding/someAssemblyRequired/A007822/_asynchronousAnnex.py

@@ -0,0 +1,51 @@
+# NOTE The real module is generated from this incomplete module. Comments are not preserved.
+# ruff: noqa: PLW0603
+from copy import deepcopy
+from mapFolding import DatatypeFoldsTotal
+from mapFolding.dataBaskets import SymmetricFoldsState
+from queue import Queue
+from threading import Lock, Thread
+
+listThreads: list[Thread] = []
+queueFutures: Queue[SymmetricFoldsState] = Queue()
+symmetricFoldsTotal: int = 0
+LOCKsymmetricFoldsTotal = Lock()
+# TODO There isn't a better way to do this?
+STOPsignal = object()
+
+def initializeConcurrencyManager(maxWorkers: int, symmetricFolds: int=0) -> None:
+	global listThreads, symmetricFoldsTotal, queueFutures
+	listThreads = []
+	queueFutures = Queue()
+	symmetricFoldsTotal = symmetricFolds
+
+	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 symmetricFoldsTotal
+	while True:
+		state = queueFutures.get()
+		if state is STOPsignal:
+			break
+		state = _filterAsymmetricFolds(state)
+		with LOCKsymmetricFoldsTotal:
+			symmetricFoldsTotal += state.groupsOfFolds
+
+def _filterAsymmetricFolds(state: SymmetricFoldsState) -> SymmetricFoldsState:
+	"""Add real function during generation; the signature is here to preview its interactions with the module."""
+	return state
+
+def filterAsymmetricFolds(state: SymmetricFoldsState) -> None:
+	queueFutures.put_nowait(deepcopy(state))
+
+def getSymmetricFoldsTotal() -> DatatypeFoldsTotal:
+	for _thread in listThreads:
+		queueFutures.put(STOPsignal)  # pyright: ignore[reportArgumentType]
+	for thread in listThreads:
+		thread.join()
+	return symmetricFoldsTotal