mapFolding 0.17.0__py3-none-any.whl → 0.18.0__py3-none-any.whl

mapFolding/beDRY.py

@@ -1,27 +1,103 @@
 """Oft-needed computations or actions, especially for multi-dimensional map folding."""
 
 from collections.abc import Sequence
-from hunterMakesPy import defineConcurrencyLimit, intInnit, oopsieKwargsie
-from mapFolding import NumPyIntegerType
+from functools import cache
+from hunterMakesPy.parseParameters import defineConcurrencyLimit, intInnit, oopsieKwargsie
+from mapFolding import Array1DLeavesTotal, Array2DLeavesTotal, Array3DLeavesTotal, inclusive, NumPyIntegerType
 from numpy import dtype as numpy_dtype, int64 as numpy_int64, ndarray
 from sys import maxsize as sysMaxsize
 from typing import Any
 import numpy
 
-def getLeavesTotal(mapShape: tuple[int, ...]) -> int:
-	"""Calculate the total number of leaves in a map with the given dimensions.
+#======== Flow control ======================================
+
+def defineProcessorLimit(CPUlimit: Any | None, concurrencyPackage: str | None = None) -> int:
+	"""Compute the CPU usage limit for concurrent operations; for `numba` managed concurrency, set the global limit.
+
+	Parameters
+	----------
+	CPUlimit : Any | None
+		Please see the documentation in `countFolds` for details. I know it is annoying, but I want to be sure you
+		have the most accurate information.
+	concurrencyPackage : str | None = None
+		Specifies which concurrency package to use.
+		- `None` or `'multiprocessing'`: Uses standard `multiprocessing`.
+		- `'numba'`: Uses Numba's threading system.
+
+	Returns
+	-------
+	concurrencyLimit : int
+		The actual concurrency limit that was set.
+
+	Raises
+	------
+	TypeError
+		If `CPUlimit` is not of the expected types.
+	NotImplementedError
+		If `concurrencyPackage` is not supported.
+
+	Notes
+	-----
+	If using `'numba'` as the concurrency package, the maximum number of processors is retrieved from
+	`numba.get_num_threads()` rather than by polling the hardware. If Numba environment variables limit available
+	processors, that will affect this function.
+
+	When using Numba, this function must be called before importing any Numba-jitted function for this processor limit
+	to affect the Numba-jitted function.
+
+	"""
+	# TODO How do I clarify the type and sanitize the value of CPUlimit?
+	if not (CPUlimit is None or isinstance(CPUlimit, (bool, int, float))):
+		CPUlimit = oopsieKwargsie(CPUlimit)
+
+	match concurrencyPackage:
+		case 'numba':
+			from numba import get_num_threads, set_num_threads  # noqa: PLC0415
+			concurrencyLimit: int = defineConcurrencyLimit(limit=CPUlimit, cpuTotal=get_num_threads())
+			set_num_threads(concurrencyLimit)
+			concurrencyLimit = get_num_threads()
+		case 'multiprocessing' | None | _:
+			concurrencyLimit = defineConcurrencyLimit(limit=CPUlimit)
+	return concurrencyLimit
 
-	The total number of leaves is the product of all dimensions in the map shape.
+#======== map folding ===================================
+
+def getConnectionGraph(mapShape: tuple[int, ...], leavesTotal: int, datatype: type[NumPyIntegerType]) -> ndarray[tuple[int, int, int], numpy_dtype[NumPyIntegerType]]:
+	"""Create a properly typed connection graph for the map folding algorithm.
 
 	Parameters
 	----------
 	mapShape : tuple[int, ...]
 		A tuple of integers representing the dimensions of the map.
+	leavesTotal : int
+		The total number of leaves in the map.
+	datatype : type[NumPyIntegerType]
+		The NumPy integer type to use for the array elements, ensuring proper memory usage and compatibility with the
+		computation state.
+
+	Returns
+	-------
+	connectionGraph : ndarray[tuple[int, int, int], numpy_dtype[NumPyIntegerType]]
+		A 3D NumPy array with shape (`dimensionsTotal`, `leavesTotal`+1, `leavesTotal`+1) with the specified `datatype`,
+		representing all possible connections between leaves.
+
+	"""
+	connectionGraph: Array3DLeavesTotal = _makeConnectionGraph(mapShape, leavesTotal)
+	return connectionGraph.astype(datatype)
+
+@cache
+def getLeavesTotal(mapShape: tuple[int, ...]) -> int:
+	"""The definitive calculation of the total number of leaves in a map with the given dimensions.
+
+	Parameters
+	----------
+	mapShape : tuple[int, ...]
+		A tuple of integers with the length of each dimension of the map.
 
 	Returns
 	-------
 	leavesTotal : int
-		The total number of leaves in the map, calculated as the product of all dimensions.
+		The definitive total number of leaves in the map.
 
 	Raises
 	------
@@ -29,12 +105,18 @@ def getLeavesTotal(mapShape: tuple[int, ...]) -> int:
 		If the product of dimensions would exceed the system's maximum integer size. This check prevents silent numeric
 		overflow issues that could lead to incorrect results.
 
+	Notes
+	-----
+	It is impossible to overstate the importance of `leavesTotal` in every algorithm for counting folds. Therefore, in this
+	package, this function is the ***only*** permissible way to compute `leavesTotal`.
+
+	The total number of leaves is the product of all dimensions in `mapShape`.
 	"""
 	productDimensions = 1
 	for dimension in mapShape:
 		# NOTE this check is one-degree short of absurd, but three lines of early absurdity is better than invalid output later. I'd add more checks if I could think of more.
 		if dimension > sysMaxsize // productDimensions:
-			message = f"I received `{dimension = }` in `{mapShape = }`, but the product of the dimensions exceeds the maximum size of an integer on this system."
+			message: str = f"I received `{dimension = }` in `{mapShape = }`, but the product of the dimensions exceeds the maximum size of an integer on this system."
 			raise OverflowError(message)
 		productDimensions *= dimension
 	return productDimensions
@@ -77,18 +159,18 @@ def getTaskDivisions(computationDivisions: int | str | None, concurrencyLimit: i
 			strComputationDivisions = strComputationDivisions.lower()
 			match strComputationDivisions:
 				case 'maximum':
-					taskDivisions = leavesTotal
+					taskDivisions: int = leavesTotal
 				case 'cpu':
 					taskDivisions = min(concurrencyLimit, leavesTotal)
 				case _:
-					message = f"I received '{strComputationDivisions}' for the parameter, `computationDivisions`, but the string value is not supported."
+					message: str = f"I received '{strComputationDivisions}' for the parameter, `computationDivisions`, but the string value is not supported."
 					raise ValueError(message)
 		case _:
 			message = f"I received {computationDivisions} for the parameter, `computationDivisions`, but the type {type(computationDivisions).__name__} is not supported."
 			raise ValueError(message)
 
 	if taskDivisions > leavesTotal:
-		message = f"Problem: `{taskDivisions = }`, is greater than `{leavesTotal = }`, which will cause duplicate counting of the folds.\n\nChallenge: you cannot directly set `taskDivisions` or `leavesTotal`: they are derived from parameters that may or may not be named `computationDivisions`, `CPUlimit` , and `listDimensions` and from my dubious-quality Python code."  # noqa: E501
+		message = f"Problem: `{taskDivisions = }`, is greater than `{leavesTotal = }`, which will cause duplicate counting of the folds.\n\nChallenge: you cannot directly set `taskDivisions` or `leavesTotal`: they are derived from parameters that may or may not be named `computationDivisions`, `CPUlimit` , and `listDimensions` and from my dubious-quality Python code."
 		raise ValueError(message)
 	return int(max(0, taskDivisions))
 
@@ -117,22 +199,22 @@ def _makeConnectionGraph(mapShape: tuple[int, ...], leavesTotal: int) -> ndarray
 	conditions, and dimensional constraints.
 
 	"""
-	dimensionsTotal = len(mapShape)
-	cumulativeProduct = numpy.multiply.accumulate([1, *list(mapShape)], dtype=numpy_int64)
-	arrayDimensions = numpy.array(mapShape, dtype=numpy_int64)
-	coordinateSystem = numpy.zeros((dimensionsTotal, leavesTotal + 1), dtype=numpy_int64)
+	dimensionsTotal: int = len(mapShape)
+	cumulativeProduct: Array1DLeavesTotal = numpy.multiply.accumulate([1, *list(mapShape)], dtype=numpy_int64)
+	arrayDimensions: Array1DLeavesTotal = numpy.array(mapShape, dtype=numpy_int64)
+	coordinateSystem: Array2DLeavesTotal = numpy.zeros((dimensionsTotal, leavesTotal + 1), dtype=numpy_int64)
 	for indexDimension in range(dimensionsTotal):
-		for leaf1ndex in range(1, leavesTotal + 1):
+		for leaf1ndex in range(1, leavesTotal + inclusive):
 			coordinateSystem[indexDimension, leaf1ndex] = (((leaf1ndex - 1) // cumulativeProduct[indexDimension]) % arrayDimensions[indexDimension] + 1)
 
-	connectionGraph = numpy.zeros((dimensionsTotal, leavesTotal + 1, leavesTotal + 1), dtype=numpy_int64)
+	connectionGraph: Array3DLeavesTotal = numpy.zeros((dimensionsTotal, leavesTotal + 1, leavesTotal + 1), dtype=numpy_int64)
 	for indexDimension in range(dimensionsTotal):
-		for activeLeaf1ndex in range(1, leavesTotal + 1):
-			for connectee1ndex in range(1, activeLeaf1ndex + 1):
-				isFirstCoord = coordinateSystem[indexDimension, connectee1ndex] == 1
-				isLastCoord = coordinateSystem[indexDimension, connectee1ndex] == arrayDimensions[indexDimension]
-				exceedsActive = connectee1ndex + cumulativeProduct[indexDimension] > activeLeaf1ndex
-				isEvenParity = (coordinateSystem[indexDimension, activeLeaf1ndex] & 1) == (coordinateSystem[indexDimension, connectee1ndex] & 1)
+		for activeLeaf1ndex in range(1, leavesTotal + inclusive):
+			for connectee1ndex in range(1, activeLeaf1ndex + inclusive):
+				isFirstCoord: bool = coordinateSystem[indexDimension, connectee1ndex] == 1
+				isLastCoord: bool = coordinateSystem[indexDimension, connectee1ndex] == arrayDimensions[indexDimension]
+				exceedsActive: bool = connectee1ndex + cumulativeProduct[indexDimension] > activeLeaf1ndex
+				isEvenParity: bool = (coordinateSystem[indexDimension, activeLeaf1ndex] & 1) == (coordinateSystem[indexDimension, connectee1ndex] & 1)
 
 				if (isEvenParity and isFirstCoord) or (not isEvenParity and (isLastCoord or exceedsActive)):
 					connectionGraph[indexDimension, activeLeaf1ndex, connectee1ndex] = connectee1ndex
@@ -142,29 +224,6 @@ def _makeConnectionGraph(mapShape: tuple[int, ...], leavesTotal: int) -> ndarray
 					connectionGraph[indexDimension, activeLeaf1ndex, connectee1ndex] = connectee1ndex + cumulativeProduct[indexDimension]
 	return connectionGraph
 
-def getConnectionGraph(mapShape: tuple[int, ...], leavesTotal: int, datatype: type[NumPyIntegerType]) -> ndarray[tuple[int, int, int], numpy_dtype[NumPyIntegerType]]:
-	"""Create a properly typed connection graph for the map folding algorithm.
-
-	Parameters
-	----------
-	mapShape : tuple[int, ...]
-		A tuple of integers representing the dimensions of the map.
-	leavesTotal : int
-		The total number of leaves in the map.
-	datatype : type[NumPyIntegerType]
-		The NumPy integer type to use for the array elements, ensuring proper memory usage and compatibility with the
-		computation state.
-
-	Returns
-	-------
-	connectionGraph : ndarray[tuple[int, int, int], numpy_dtype[NumPyIntegerType]]
-		A 3D NumPy array with shape (`dimensionsTotal`, `leavesTotal`+1, `leavesTotal`+1) with the specified `datatype`,
-		representing all possible connections between leaves.
-
-	"""
-	connectionGraph = _makeConnectionGraph(mapShape, leavesTotal)
-	return connectionGraph.astype(datatype)
-
 def makeDataContainer(shape: int | tuple[int, ...], datatype: type[NumPyIntegerType]) -> ndarray[Any, numpy_dtype[NumPyIntegerType]]:
 	"""Create any data container as long as it is a `numpy.ndarray` full of zeroes of type `numpy.integer`.
 
@@ -185,59 +244,6 @@ def makeDataContainer(shape: int | tuple[int, ...], datatype: type[NumPyIntegerT
 	"""
 	return numpy.zeros(shape, dtype=datatype)
 
-def setProcessorLimit(CPUlimit: Any | None, concurrencyPackage: str | None = None) -> int:
-	"""Set the CPU usage limit for concurrent operations.
-
-	Parameters
-	----------
-	CPUlimit : Any | None
-		Please see the documentation in `countFolds` for details. I know it is annoying, but I want to be sure you
-		have the most accurate information.
-	concurrencyPackage : str | None = None
-		Specifies which concurrency package to use.
-		- `None` or `'multiprocessing'`: Uses standard `multiprocessing`.
-		- `'numba'`: Uses Numba's threading system.
-
-	Returns
-	-------
-	concurrencyLimit : int
-		The actual concurrency limit that was set.
-
-	Raises
-	------
-	TypeError
-		If `CPUlimit` is not of the expected types.
-	NotImplementedError
-		If `concurrencyPackage` is not supported.
-
-	Notes
-	-----
-	If using `'numba'` as the concurrency package, the maximum number of processors is retrieved from
-	`numba.get_num_threads()` rather than by polling the hardware. If Numba environment variables limit available
-	processors, that will affect this function.
-
-	When using Numba, this function must be called before importing any Numba-jitted function for this processor limit
-	to affect the Numba-jitted function.
-
-	"""
-	if not (CPUlimit is None or isinstance(CPUlimit, (bool, int, float))):
-		CPUlimit = oopsieKwargsie(CPUlimit)
-
-	match concurrencyPackage:
-		case 'multiprocessing' | None:
-			# When to use multiprocessing.set_start_method
-			# https://github.com/hunterhogan/mapFolding/issues/6  # noqa: ERA001
-			concurrencyLimit: int = defineConcurrencyLimit(limit=CPUlimit)
-		case 'numba':
-			from numba import get_num_threads, set_num_threads  # noqa: PLC0415
-			concurrencyLimit = defineConcurrencyLimit(limit=CPUlimit, cpuTotal=get_num_threads())
-			set_num_threads(concurrencyLimit)
-			concurrencyLimit = get_num_threads()
-		case _:
-			message = f"I received `{concurrencyPackage = }` but I don't know what to do with that."
-			raise NotImplementedError(message)
-	return concurrencyLimit
-
 def validateListDimensions(listDimensions: Sequence[int]) -> tuple[int, ...]:
 	"""Validate and normalize dimensions for a map folding problem.
 
@@ -266,7 +272,7 @@ def validateListDimensions(listDimensions: Sequence[int]) -> tuple[int, ...]:
 
 	"""
 	if not listDimensions:
-		message = "`listDimensions` is a required parameter."
+		message: str = "`listDimensions` is a required parameter."
 		raise ValueError(message)
 	listOFint: list[int] = intInnit(listDimensions, 'listDimensions')
 	mapDimensions: list[int] = []
@@ -294,3 +300,6 @@ def validateListDimensions(listDimensions: Sequence[int]) -> tuple[int, ...]:
 	"""
 	# NOTE Do NOT sort the dimensions.
 	return tuple(mapDimensions)
+
+
+

mapFolding/filesystemToolkit.py

@@ -24,10 +24,14 @@ solutions to their map folding challenges.
 from mapFolding import packageSettings
 from os import PathLike
 from pathlib import Path, PurePath
-from sys import modules as sysModules
+from sys import modules as sysModules, stdout
+from typing import TYPE_CHECKING
 import os
 import platformdirs
 
+if TYPE_CHECKING:
+	from io import TextIOWrapper
+
 def getFilenameFoldsTotal(mapShape: tuple[int, ...]) -> str:
 	"""Create a standardized filename for a computed `foldsTotal` value.
 
@@ -173,18 +177,18 @@ def saveFoldsTotal(pathFilename: PathLike[str] | PurePath, foldsTotal: int) -> N
 		_saveFoldsTotal(pathFilename, foldsTotal)
 	except Exception as ERRORmessage:  # noqa: BLE001
 		try:
-			print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal = }\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")  # noqa: T201
-			print(ERRORmessage)  # noqa: T201
-			print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal = }\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")  # noqa: T201
-			randomnessPlanB = (int(str(foldsTotal).strip()[-1]) + 1) * ['YO_']
-			filenameInfixUnique = ''.join(randomnessPlanB)
-			pathFilenamePlanB = os.path.join(os.getcwd(), 'foldsTotal' + filenameInfixUnique + '.txt')  # noqa: PTH109, PTH118
-			writeStreamFallback = open(pathFilenamePlanB, 'w')  # noqa: PTH123, SIM115
+			stdout.write(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal = }\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
+			stdout.writelines(str(ERRORmessage))
+			stdout.write(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal = }\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
+			randomnessPlanB: list[str] = (int(str(foldsTotal).strip()[-1]) + 1) * ['YO_']
+			filenameInfixUnique: str = ''.join(randomnessPlanB)
+			pathFilenamePlanB: str = os.path.join(os.getcwd(), 'foldsTotal' + filenameInfixUnique + '.txt')  # noqa: PTH109, PTH118
+			writeStreamFallback: TextIOWrapper = open(pathFilenamePlanB, 'w')  # noqa: PTH123, SIM115
 			writeStreamFallback.write(str(foldsTotal))
 			writeStreamFallback.close()
-			print(str(pathFilenamePlanB))  # noqa: T201
+			stdout.write(str(pathFilenamePlanB))
 		except Exception:  # noqa: BLE001
-			print(foldsTotal)  # noqa: T201
+			stdout.write(str(foldsTotal))
 
 def saveFoldsTotalFAILearly(pathFilename: PathLike[str] | PurePath) -> None:
 	"""Preemptively test file write capabilities before beginning computation.
@@ -220,7 +224,7 @@ def saveFoldsTotalFAILearly(pathFilename: PathLike[str] | PurePath) -> None:
 
 	"""
 	if Path(pathFilename).exists():
-		message = f"`{pathFilename = }` exists: a battle of overwriting might cause tears."
+		message: str = f"`{pathFilename = }` exists: a battle of overwriting might cause tears."
 		raise FileExistsError(message)
 	if not Path(pathFilename).parent.exists():
 		message = f"I received `{pathFilename = }` 0.000139 seconds ago from a function that promised it created the parent directory, but the parent directory does not exist. Fix that now, so your computation doesn't get deleted later. And be compassionate to others."

mapFolding/oeis.py

@@ -25,21 +25,20 @@ completes the journey from configuration foundation to mathematical discovery.
 """
 
 from datetime import datetime, timedelta, UTC
-from hunterMakesPy import writeStringToHere
+from hunterMakesPy.filesystemToolkit import writeStringToHere
 from itertools import chain
-from mapFolding import countFolds, MetadataOEISid, MetadataOEISidMapFolding, packageSettings
+from mapFolding import MetadataOEISid, MetadataOEISidMapFolding, packageSettings
 from mapFolding._theSSOT import pathCache
+from mapFolding.basecamp import countFolds
 from pathlib import Path
 from typing import Final
+from urllib.error import HTTPError, URLError
 from urllib.request import urlopen
 import argparse
 import sys
 import time
 import warnings
 
-oeisIDsImplemented: Final[list[str]]  = sorted([oeisID.upper().strip() for oeisID in packageSettings.OEISidMapFoldingManuallySet])
-"""Directly implemented OEIS IDs; standardized, e.g., 'A001415'."""
-
 def _standardizeOEISid(oeisID: str) -> str:
 	"""Standardize an OEIS sequence ID to uppercase and without whitespace.
 
@@ -56,6 +55,9 @@ def _standardizeOEISid(oeisID: str) -> str:
 	"""
 	return str(oeisID).upper().strip()
 
+oeisIDsImplemented: Final[list[str]]  = sorted(map(_standardizeOEISid, packageSettings.OEISidMapFoldingManuallySet))
+"""Directly implemented OEIS IDs; standardized, e.g., 'A001415'."""
+
 def _getFilenameOEISbFile(oeisID: str) -> str:
 	"""Generate the filename for an OEIS b-file given a sequence ID.
 
@@ -145,10 +147,13 @@ def _getOEISofficial(pathFilenameCache: Path, url: str) -> None | str:
 			message = "URL must start with 'http:' or 'https:'"
 			raise ValueError(message)
 
-		with urlopen(url) as response:  # noqa: S310
-			oeisInformationRaw = response.read().decode('utf-8')
-		oeisInformation = str(oeisInformationRaw)
-		writeStringToHere(oeisInformation, pathFilenameCache)
+		try:
+			with urlopen(url) as response:  # noqa: S310
+				oeisInformationRaw = response.read().decode('utf-8')
+			oeisInformation = str(oeisInformationRaw)
+			writeStringToHere(oeisInformation, pathFilenameCache)
+		except (HTTPError, URLError):
+			oeisInformation = pathFilenameCache.read_text(encoding="utf-8")
 
 	if not oeisInformation:
 		warnings.warn(f"Failed to retrieve OEIS sequence information for {pathFilenameCache.stem}.", stacklevel=2)
@@ -230,7 +235,7 @@ def getOEISidInformation(oeisID: str) -> tuple[str, int]:
 	listDescriptionDeconstructed: list[str] = []
 	offset = None
 	for lineOEIS in oeisInformation.splitlines():
-		lineOEIS = lineOEIS.strip()  # noqa: PLW2901
+		lineOEIS = lineOEIS.strip()
 		if not lineOEIS or len(lineOEIS.split()) < 3:
 			continue
 		fieldCode, sequenceID, fieldData = lineOEIS.split(maxsplit=2)
@@ -279,9 +284,6 @@ def _makeDictionaryOEISMapFolding() -> dict[str, MetadataOEISidMapFolding]:
 			description=descriptionSherpa,
 			offset=offsetSherpa,
 			getMapShape=packageSettings.OEISidMapFoldingManuallySet[oeisID]['getMapShape'],
-			valuesBenchmark=packageSettings.OEISidMapFoldingManuallySet[oeisID]['valuesBenchmark'],
-			valuesTestParallelization=packageSettings.OEISidMapFoldingManuallySet[oeisID]['valuesTestParallelization'],
-			valuesTestValidation=packageSettings.OEISidMapFoldingManuallySet[oeisID]['valuesTestValidation'] + list(range(offsetSherpa, 2)),
 			valuesKnown=valuesKnownSherpa,
 			valueUnknown=max(valuesKnownSherpa.keys(), default=0) + 1
 		)
@@ -339,8 +341,8 @@ def _formatHelpText() -> str:
 		A formatted string containing complete usage information and examples.
 
 	"""
-	exampleOEISid: str = oeisIDsImplemented[0]
-	exampleN: int = dictionaryOEISMapFolding[exampleOEISid]['valuesTestValidation'][-1]
+	exampleOEISid: str = 'A001415'
+	exampleN: int = 6
 
 	return (
 		"\nAvailable OEIS sequences:\n"
@@ -485,7 +487,6 @@ def _makeDictionaryOEIS() -> dict[str, MetadataOEISid]:
 			description=descriptionSherpa,
 			offset=offsetSherpa,
 			valuesKnown=valuesKnownSherpa,
-			valuesTestValidation=[*(packageSettings.OEISidManuallySet[oeisID]['valuesTestValidation']), offsetSherpa],
 			valueUnknown=max(valuesKnownSherpa.keys(), default=0) + 1,
 		)
 	return dictionary

mapFolding/reference/matrixMeandersAnalysis/prefixNotationNotes.py

@@ -1,6 +1,6 @@
 # ruff: noqa
-# ================= analyze aligned ===================================================================================
-# ======= if bitsAlpha > 1 and bitsZulu > 1 and (bitsAlphaIsEven or bitsZuluIsEven) =====
+#================== analyze aligned ===================================================================================
+#======== if bitsAlpha > 1 and bitsZulu > 1 and (bitsAlphaIsEven or bitsZuluIsEven) =====
 """NOTE find `bitsAlpha > 1 and bitsZulu > 1 and (bitsAlphaIsEven or bitsZuluIsEven)` without bitsAlpha or bitsZulu.
 - `bitsAlpha` is even IFF `arcCode` is even.
 - `bitsAlpha` > 1, so arcCode's LSB is irrelevant; locatorBits ends with 0b101, so arcCode's 2° LSB is irrelevant.

mapFolding/reference/meandersDumpingGround/matrixMeandersBaselineV2.py

@@ -121,7 +121,6 @@ def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
 						bifurcationZulu ^= XOrHere2makePair
 
 					# Cases 1, 2, and 3 all compute curveLocationAnalysis
-# TODO https://github.com/hunterhogan/mapFolding/issues/19
 					curveLocationAnalysis = ((bifurcationZulu >> 2) << 1) | bifurcationAlphaShiftRight2 # pyright: ignore[reportPossiblyUnboundVariable]
 					if curveLocationAnalysis < curveLocationsMAXIMUM:
 						dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings

mapFolding/reference/meandersDumpingGround/matrixMeandersNumPyV1finalForm.py

@@ -169,7 +169,7 @@ def count64(bridges: int, arrayCurveGroups: DataArray3columns, bridgesMinimum: i
 
 		allocateBridgesAligned: int = int(numpy.count_nonzero(selectBridgesAligned))
 
-# ----------------------------------------------- bridgesSimple -------------------------------------------------------
+#------------------------------------------------ bridgesSimple -------------------------------------------------------
 		curveLocationsBridgesSimpleLessThanMaximum: DataArray1D = arrayCurveGroups[:, columnGroupZulu].copy()
 		numpy.left_shift(curveLocationsBridgesSimpleLessThanMaximum, 1, out=curveLocationsBridgesSimpleLessThanMaximum)
 		numpy.bitwise_or(curveLocationsBridgesSimpleLessThanMaximum, arrayCurveGroups[:, columnGroupAlpha], out=curveLocationsBridgesSimpleLessThanMaximum)
@@ -179,14 +179,14 @@ def count64(bridges: int, arrayCurveGroups: DataArray3columns, bridgesMinimum: i
 
 		allocateBridgesSimple: int = int(numpy.count_nonzero(curveLocationsBridgesSimpleLessThanMaximum))
 
-# ----------------------------------------------- arrayCurveLocations -------------------------------------------------
+#------------------------------------------------ arrayCurveLocations -------------------------------------------------
 		rowsAllocatedTotal: int = allocateGroupAlphaCurves + allocateGroupZuluCurves + allocateBridgesSimple + allocateBridgesAligned
 		arrayCurveLocations: DataArray2columns = numpy.zeros((rowsAllocatedTotal, columnsArrayCurveLocations), dtype=arrayCurveGroups.dtype)
 
 		rowsAggregatedTotal: int = 0
 		rowsDeallocatedTotal: int = 0
 
-# ----------------------------------------------- bridgesSimple -------------------------------------------------------
+#------------------------------------------------ bridgesSimple -------------------------------------------------------
 		rowsAggregatedTotal = aggregateBridgesSimple2CurveLocations(arrayCurveLocations
 			, rowsAggregatedTotal
 			, curveLocationsBridgesSimpleLessThanMaximum
@@ -200,7 +200,7 @@ def count64(bridges: int, arrayCurveGroups: DataArray3columns, bridgesMinimum: i
 		del allocateBridgesSimple
 		goByeBye()
 
-# ----------------------------------------------- groupAlpha ----------------------------------------------------------
+#------------------------------------------------ groupAlpha ----------------------------------------------------------
 		selectGroupAlphaCurves: SelectorBoolean = arrayCurveGroups[:, columnGroupAlpha] > numpy.uint64(1)
 		curveLocationsGroupAlpha: DataArray1D = arrayCurveGroups[selectGroupAlphaCurves, columnGroupAlpha].copy()
 
@@ -210,7 +210,6 @@ def count64(bridges: int, arrayCurveGroups: DataArray3columns, bridgesMinimum: i
 		numpy.bitwise_or(curveLocationsGroupAlpha, arrayCurveGroups[selectGroupAlphaCurves, columnGroupAlpha], out=curveLocationsGroupAlpha)
 		numpy.right_shift(curveLocationsGroupAlpha, 2, out=curveLocationsGroupAlpha)
 # NOTE (groupAlpha >> 2) | (groupZulu << 3) | ((1 - (groupAlpha & 1)) << 1)
-# TODO eliminate temporary arrayLockbox
 		arrayLockbox: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint8]] = numpy.full_like(a=curveLocationsGroupAlpha, fill_value=numpy.uint8(0b111), dtype=numpy.uint8)
 		numpy.bitwise_and(arrayLockbox, curveLocationsGroupAlpha, out=arrayLockbox, dtype=numpy.uint8)
 		numpy.right_shift(curveLocationsGroupAlpha, 3, out=curveLocationsGroupAlpha)
@@ -237,14 +236,13 @@ def count64(bridges: int, arrayCurveGroups: DataArray3columns, bridgesMinimum: i
 		selectGroupAlphaCurves = None; del selectGroupAlphaCurves # pyright: ignore[reportAssignmentType]  # noqa: E702
 		goByeBye()
 
-# ----------------------------------------------- groupZulu -----------------------------------------------------------
+#------------------------------------------------ groupZulu -----------------------------------------------------------
 		selectGroupZuluCurves: SelectorBoolean = arrayCurveGroups[:, columnGroupZulu] > numpy.uint64(1)
 		curveLocationsGroupZulu: DataArray1D = arrayCurveGroups[selectGroupZuluCurves, columnGroupAlpha].copy()
 		numpy.left_shift(curveLocationsGroupZulu, 2, out=curveLocationsGroupZulu)
 # NOTE (groupAlpha << 2)
 
 		numpy.bitwise_or(curveLocationsGroupZulu, numpy.subtract(numpy.uint64(1), numpy.bitwise_and(arrayCurveGroups[selectGroupZuluCurves, columnGroupZulu], 1)), out=curveLocationsGroupZulu)
-# TODO | (1 - (groupZulu & 1))
 
 # NOTE | (groupZulu >> 1)
 		numpy.left_shift(curveLocationsGroupZulu, 1, out=curveLocationsGroupZulu)
@@ -267,7 +265,7 @@ def count64(bridges: int, arrayCurveGroups: DataArray3columns, bridgesMinimum: i
 		selectGroupZuluCurves = None; del selectGroupZuluCurves # pyright: ignore[reportAssignmentType]  # noqa: E702
 		goByeBye()
 
-# ----------------------------------------------- bridgesAligned ------------------------------------------------------
+#------------------------------------------------ bridgesAligned ------------------------------------------------------
 # `bridgesAligned` = `bridgesGroupAlphaPairedToOdd` UNION WITH `bridgesGroupZuluPairedToOdd` UNION WITH `bridgesAlignedAtEven`
 
 # bridgesAligned -------------------------------- bridgesGroupAlphaPairedToOdd ----------------------------------------
@@ -301,7 +299,7 @@ def count64(bridges: int, arrayCurveGroups: DataArray3columns, bridgesMinimum: i
 
 # NOTE: All computations for `bridgesAlignedAtEven` are handled by the computations for `bridgesAligned`.
 
-# ----------------------------------------------- bridgesAligned ------------------------------------------------------
+#------------------------------------------------ bridgesAligned ------------------------------------------------------
 
 		curveLocationsBridgesAlignedLessThanMaximum: DataArray1D = numpy.zeros((selectBridgesAligned.sum(),), dtype=numpy.uint64)
 		numpy.right_shift(arrayCurveGroups[selectBridgesAligned, columnGroupZulu], 2, out=curveLocationsBridgesAlignedLessThanMaximum)
@@ -330,7 +328,7 @@ def count64(bridges: int, arrayCurveGroups: DataArray3columns, bridgesMinimum: i
 		selectBridgesAligned = None; del selectBridgesAligned  # pyright: ignore[reportAssignmentType] # noqa: E702
 		goByeBye()
 
-# ----------------------------------------------- aggregation ---------------------------------------------------------
+#------------------------------------------------ aggregation ---------------------------------------------------------
 		arrayCurveGroups = aggregateCurveLocations2CurveGroups(arrayCurveLocations)
 
 		arrayCurveLocations = None; del arrayCurveLocations # pyright: ignore[reportAssignmentType]  # noqa: E702

mapFolding/someAssemblyRequired/RecipeJob.py

@@ -3,7 +3,7 @@
 from astToolkit import identifierDotAttribute, parseLogicalPath2astModule
 from astToolkit.containers import IngredientsFunction, IngredientsModule, LedgerOfImports
 from astToolkit.transformationTools import pythonCode2ast_expr
-from hunterMakesPy import autoDecodingRLE
+from hunterMakesPy.dataStructures import autoDecodingRLE
 # TODO 'The____' identifiers are a vestigial semiotic system. Do I still need to import `asname`? If so, would different
 # identifiers better integrate into the current semiotics?
 from mapFolding import (
@@ -84,7 +84,7 @@ class RecipeJobTheorem2:
 	shatteredDataclass: ShatteredDataclass = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
 	"""Deconstructed dataclass metadata for code transformation."""
 
-# ------- Source -----------------------------------------
+#-------- Source -----------------------------------------
 	source_astModule: ast.Module = parseLogicalPath2astModule(f'{packageSettings.identifierPackage}.{default['logicalPath']['synthetic']}.theorem2Numba')  # noqa: RUF009
 	"""Parsed AST of the source module containing the generic algorithm."""
 	identifierCallableSource: str = default['function']['counting']
@@ -102,7 +102,7 @@ class RecipeJobTheorem2:
 	sourcePackageIdentifier: str | None = packageSettings.identifierPackage
 	"""Name of the source package."""
 
-# ------- Filesystem, names of physical objects ------------------------------------------
+#-------- Filesystem, names of physical objects ------------------------------------------
 	pathPackage: PurePosixPath | None = None
 	"""Override path for the target package."""
 	pathModule: PurePosixPath | None = PurePosixPath(getPathRootJobDEFAULT())  # noqa: RUF009
@@ -112,7 +112,7 @@ class RecipeJobTheorem2:
 	pathFilenameFoldsTotal: PurePosixPath = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
 	"""Path for writing fold count results."""
 
-# ------- Logical identifiers, as opposed to physical identifiers ------------------------
+#-------- Logical identifiers, as opposed to physical identifiers ------------------------
 	packageIdentifier: str | None = None
 	"""Target package identifier."""
 	logicalPathRoot: identifierDotAttribute | None = None
@@ -128,7 +128,7 @@ class RecipeJobTheorem2:
 	logicalPathModuleDataclass: identifierDotAttribute | None = sourceLogicalPathModuleDataclass
 	"""Logical path to target dataclass module."""
 
-# ------- Datatypes ------------------------------------------
+#-------- Datatypes ------------------------------------------
 	type DatatypeFoldsTotal = TheDatatypeFoldsTotal
 	"""Type alias for datatype linked to the magnitude of `foldsTotal`."""
 	type DatatypeElephino = TheDatatypeElephino

mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py

@@ -10,7 +10,7 @@ progress integration for long-running calculations, and launcher generation for
 
 from astToolkit import Be, Make, NodeChanger, NodeTourist, parseLogicalPath2astModule, Then
 from astToolkit.containers import astModuleToIngredientsFunction, IngredientsFunction, IngredientsModule
-from hunterMakesPy import autoDecodingRLE, identifierDotAttribute
+from hunterMakesPy.dataStructures import autoDecodingRLE
 from mapFolding import (
 	DatatypeLeavesTotal, dictionaryOEIS, getFoldsTotalKnown, getPathFilenameFoldsTotal, packageSettings)
 from mapFolding.dataBaskets import MapFoldingState, SymmetricFoldsState
@@ -19,9 +19,12 @@ from mapFolding.someAssemblyRequired.RecipeJob import customizeDatatypeViaImport
 from mapFolding.someAssemblyRequired.toolkitNumba import decorateCallableWithNumba, parametersNumbaLight, SpicesJobNumba
 from mapFolding.someAssemblyRequired.transformationTools import shatter_dataclassesDOTdataclass
 from pathlib import PurePosixPath
-from typing import cast
+from typing import cast, TYPE_CHECKING
 import ast
 
+if TYPE_CHECKING:
+	from hunterMakesPy import identifierDotAttribute
+
 # TODO More convergence with `makeJobTheorem2codon`
 
 # TODO Dynamically calculate the bitwidth of each datatype. NOTE I've delayed dynamic calculation because I don't know how to