mapFolding 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

mapFolding/reference/total_countPlus1vsPlusN.py

@@ -0,0 +1,211 @@
+from numba import njit
+import numpy
+
+@njit(cache=True)
+def foldings_plus_1(p: list[int], computationDivisions: int = 0, computationIndex: int = 0) -> int:
+    n: int = 1  # Total number of leaves
+    for dimension in p:
+        n *= dimension
+
+    d = len(p)  # Number of dimensions
+    # Compute arrays P, C, D as per the algorithm
+    P = numpy.ones(d + 1, dtype=numpy.int64)
+    for i in range(1, d + 1):
+        P[i] = P[i - 1] * p[i - 1]
+
+    # C[i][m] holds the i-th coordinate of leaf m
+    C = numpy.zeros((d + 1, n + 1), dtype=numpy.int64)
+    for i in range(1, d + 1):
+        for m in range(1, n + 1):
+            C[i][m] = ((m - 1) // P[i - 1]) - ((m - 1) // P[i]) * p[i - 1] + 1
+
+    # D[i][l][m] computes the leaf connected to m in section i when inserting l
+    D = numpy.zeros((d + 1, n + 1, n + 1), dtype=numpy.int64)
+    for i in range(1, d + 1):
+        for l in range(1, n + 1):
+            for m in range(1, l + 1):
+                delta = C[i][l] - C[i][m]
+                if delta % 2 == 0:
+                    # If delta is even
+                    if C[i][m] == 1:
+                        D[i][l][m] = m
+                    else:
+                        D[i][l][m] = m - P[i - 1]
+                else:
+                    # If delta is odd
+                    if C[i][m] == p[i - 1] or m + P[i - 1] > l:
+                        D[i][l][m] = m
+                    else:
+                        D[i][l][m] = m + P[i - 1]
+    # Initialize arrays/lists
+    A = numpy.zeros(n + 1, dtype=numpy.int64)       # Leaf above leaf m
+    B = numpy.zeros(n + 1, dtype=numpy.int64)       # Leaf below leaf m
+    count = numpy.zeros(n + 1, dtype=numpy.int64)   # Counts for potential gaps
+    gapter = numpy.zeros(n + 1, dtype=numpy.int64)  # Indices for gap stack per leaf
+    gap = numpy.zeros(n * n + 1, dtype=numpy.int64) # Stack of potential gaps
+
+
+    # Initialize variables for backtracking
+    total_count = 0  # Total number of foldings
+    g = 0            # Gap index
+    l = 1            # Current leaf
+
+    # Start backtracking loop
+    while l > 0:
+        # If we have processed all leaves, increment total count
+        if l > n:
+            total_count += 1
+        else:
+            dd = 0     # Number of sections where leaf l is unconstrained
+            gg = g     # Temporary gap index
+            g = gapter[l - 1]  # Reset gap index for current leaf
+
+            # Count possible gaps for leaf l in each section
+            for i in range(1, d + 1):
+                if D[i][l][l] == l:
+                    dd += 1
+                else:
+                    m = D[i][l][l]
+                    while m != l:
+                        if computationDivisions == 0 or l != computationDivisions or m % computationDivisions == computationIndex:
+                            gap[gg] = m
+                            if count[m] == 0:
+                                gg += 1
+                            count[m] += 1
+                        m = D[i][l][B[m]]
+
+            # If leaf l is unconstrained in all sections, it can be inserted anywhere
+            if dd == d:
+                for m in range(l):
+                    gap[gg] = m
+                    gg += 1
+
+            # Filter gaps that are common to all sections
+            for j in range(g, gg):
+                gap[g] = gap[j]
+                if count[gap[j]] == d - dd:
+                    g += 1
+                count[gap[j]] = 0  # Reset count for next iteration
+
+        # Recursive backtracking steps
+        while l > 0 and g == gapter[l - 1]:
+            l -= 1
+            B[A[l]] = B[l]
+            A[B[l]] = A[l]
+
+        if l > 0:
+            g -= 1
+            A[l] = gap[g]
+            B[l] = B[A[l]]
+            B[A[l]] = l
+            A[B[l]] = l
+            gapter[l] = g  # Save current gap index
+            l += 1         # Move to next leaf
+
+    return total_count
+
+@njit(cache=True)
+def foldings(p: list[int], computationDivisions: int = 0, computationIndex: int = 0) -> int:
+    n: int = 1  # Total number of leaves
+    for dimension in p:
+        n *= dimension
+
+    d = len(p)  # Number of dimensions
+    # Compute arrays P, C, D as per the algorithm
+    P = numpy.ones(d + 1, dtype=numpy.int64)
+    for i in range(1, d + 1):
+        P[i] = P[i - 1] * p[i - 1]
+
+    # C[i][m] holds the i-th coordinate of leaf m
+    C = numpy.zeros((d + 1, n + 1), dtype=numpy.int64)
+    for i in range(1, d + 1):
+        for m in range(1, n + 1):
+            C[i][m] = ((m - 1) // P[i - 1]) - ((m - 1) // P[i]) * p[i - 1] + 1
+            # C[i][m] = ((m - 1) // P[i - 1]) % p[i - 1] + 1 # NOTE different, but either one works
+
+    # D[i][l][m] computes the leaf connected to m in section i when inserting l
+    D = numpy.zeros((d + 1, n + 1, n + 1), dtype=numpy.int64)
+    for i in range(1, d + 1):
+        for l in range(1, n + 1):
+            for m in range(1, l + 1):
+                delta = C[i][l] - C[i][m]
+                if delta % 2 == 0:
+                    # If delta is even
+                    if C[i][m] == 1:
+                        D[i][l][m] = m
+                    else:
+                        D[i][l][m] = m - P[i - 1]
+                else:
+                    # If delta is odd
+                    if C[i][m] == p[i - 1] or m + P[i - 1] > l:
+                        D[i][l][m] = m
+                    else:
+                        D[i][l][m] = m + P[i - 1]
+    # Initialize arrays/lists
+    A = numpy.zeros(n + 1, dtype=numpy.int64)       # Leaf above leaf m
+    B = numpy.zeros(n + 1, dtype=numpy.int64)       # Leaf below leaf m
+    count = numpy.zeros(n + 1, dtype=numpy.int64)   # Counts for potential gaps
+    gapter = numpy.zeros(n + 1, dtype=numpy.int64)  # Indices for gap stack per leaf
+    gap = numpy.zeros(n * n + 1, dtype=numpy.int64) # Stack of potential gaps
+
+
+    # Initialize variables for backtracking
+    total_count = 0  # Total number of foldings
+    g = 0            # Gap index
+    l = 1            # Current leaf
+
+    # Start backtracking loop
+    while l > 0:
+        if l <= 1 or B[0] == 1: # NOTE different
+            # NOTE the above `if` statement encloses the the if/else block below
+            # NOTE these changes increase the throughput by more than an order of magnitude
+            if l > n:
+                total_count += n
+            else:
+                dd = 0     # Number of sections where leaf l is unconstrained
+                gg = gapter[l - 1]  # Track possible gaps # NOTE different, but not important
+                g = gg # NOTE different, but not important
+
+                # Count possible gaps for leaf l in each section
+                for i in range(1, d + 1):
+                    if D[i][l][l] == l:
+                        dd += 1
+                    else:
+                        m = D[i][l][l]
+                        while m != l:
+                            if computationDivisions == 0 or l != computationDivisions or m % computationDivisions == computationIndex:
+                                gap[gg] = m
+                                if count[m] == 0:
+                                    gg += 1
+                                count[m] += 1
+                            m = D[i][l][B[m]]
+
+                # If leaf l is unconstrained in all sections, it can be inserted anywhere
+                if dd == d:
+                    for m in range(l):
+                        gap[gg] = m
+                        gg += 1
+
+                # Filter gaps that are common to all sections
+                for j in range(g, gg):
+                    gap[g] = gap[j]
+                    if count[gap[j]] == d - dd:
+                        g += 1
+                    count[gap[j]] = 0  # Reset count for next iteration
+
+        # Recursive backtracking steps
+        while l > 0 and g == gapter[l - 1]:
+            l -= 1
+            B[A[l]] = B[l]
+            A[B[l]] = A[l]
+
+        if l > 0:
+            g -= 1
+            A[l] = gap[g]
+            B[l] = B[A[l]]
+            B[A[l]] = l
+            A[B[l]] = l
+            gapter[l] = g  # Save current gap index
+            l += 1         # Move to next leaf
+
+    return total_count

mapFolding/startHere.py

@@ -1,27 +1,38 @@
-from numpy import integer
-from numpy.typing import NDArray
-from typing import Any, Tuple
-import numba
-import numpy
 from mapFolding import outfitFoldings
-# from mapFolding.benchmarks.benchmarking import recordBenchmarks
-from typing import Optional, Union, Sequence, Type
+from typing import Optional, Sequence, Type, Union
 import os
 import pathlib
 
-# TODO the current tests expect positional `listDimensions, computationDivisions`, so after restructuring you can arrange the parameters however you want.
-def countFolds(
-    listDimensions: Sequence[int],
-    computationDivisions: Optional[Union[int, str]] = None,
-    CPUlimit: Optional[Union[int, float, bool]] = None,
-    writeFoldsTotal: Optional[Union[str, os.PathLike[str]]] = None,
-    **keywordArguments: Optional[Type]
-    ):
-    """keywordArguments:
-    dtypeDefault: Optional[Type]
-    dtypeLarge: Optional[Type]
-
-    writeFoldsTotal: path, filename, or pathFilename
+def countFolds(listDimensions: Sequence[int], writeFoldsTotal: Optional[Union[str, os.PathLike[str]]] = None, computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[int, float, bool]] = None, **keywordArguments: Optional[Type]) -> int:
+    """Count the total number of possible foldings for a given map dimensions.
+
+    Parameters:
+        listDimensions: List of integers representing the dimensions of the map to be folded.
+        writeFoldsTotal (None): Path or filename to write the total fold count.
+            If a directory is provided, creates a file with default name based on map dimensions.
+        computationDivisions (None):
+            Whether and how to divide the computational work. See notes for details.
+        CPUlimit (None): This is only relevant if there are `computationDivisions`: whether and how to limit the CPU usage. See notes for details.
+        **keywordArguments: Additional arguments including `dtypeDefault` and `dtypeLarge` for data type specifications.
+    Returns:
+        foldsTotal: Total number of distinct ways to fold a map of the given dimensions.
+
+    Computation divisions:
+        - None: no division of the computation into tasks; sets task divisions to 0
+        - int: direct set the number of task divisions; cannot exceed the map's total leaves
+        - "maximum": divides into `leavesTotal`-many `taskDivisions`
+        - "cpu": limits the divisions to the number of available CPUs, i.e. `concurrencyLimit`
+
+    Limits on CPU usage `CPUlimit`:
+        - `False`, `None`, or `0`: No limits on CPU usage; uses all available CPUs. All other values will potentially limit CPU usage.
+        - `True`: Yes, limit the CPU usage; limits to 1 CPU.
+        - Integer `>= 1`: Limits usage to the specified number of CPUs.
+        - Decimal value (`float`) between 0 and 1: Fraction of total CPUs to use.
+        - Decimal value (`float`) between -1 and 0: Fraction of CPUs to *not* use.
+        - Integer `<= -1`: Subtract the absolute value from total CPUs.
+
+    N.B.: You probably don't want to divide the computation into tasks.
+        If you want to compute a large `foldsTotal`, dividing the computation into tasks is usually a bad idea. Dividing the algorithm into tasks is inherently inefficient: efficient division into tasks means there would be no overlap in the work performed by each task. When dividing this algorithm, the amount of overlap is between 50% and 90% by all tasks: at least 50% of the work done by every task must be done by _all_ tasks. If you improve the computation time, it will only change by -10 to -50% depending on (at the very least) the ratio of the map dimensions and the number of leaves. If an undivided computation would take 10 hours on your computer, for example, the computation will still take at least 5 hours but you might reduce the time to 9 hours. Most of the time, however, you will increase the computation time. If logicalCores >= leavesTotal, it will probably be faster. If logicalCores <= 2 * leavesTotal, it will almost certainly be slower for all map dimensions.
     """
     stateUniversal = outfitFoldings(listDimensions, computationDivisions=computationDivisions, CPUlimit=CPUlimit, **keywordArguments)
 
@@ -33,6 +44,7 @@ def countFolds(
             pathFilenameFoldsTotal = pathFilenameFoldsTotal / filenameFoldsTotalDEFAULT
         pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
 
+    # NOTE Don't import a module with a numba.jit function until you want the function to compile and to freeze all settings for that function.
     from mapFolding.babbage import _countFolds
     foldsTotal = _countFolds(**stateUniversal)
     # foldsTotal = benchmarkSherpa(**stateUniversal)
@@ -42,12 +54,14 @@ def countFolds(
             pathFilenameFoldsTotal.write_text(str(foldsTotal))
         except Exception as ERRORmessage:
             print(ERRORmessage)
-            print("\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal")
-            print(f"{foldsTotal=}")
-            print("\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal")
+            print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal")
 
     return foldsTotal
 
+# from numpy import integer
+# from numpy.typing import NDArray
+# from typing import Any, Tuple
+# from mapFolding.benchmarks.benchmarking import recordBenchmarks
 # @recordBenchmarks()
 # def benchmarkSherpa(connectionGraph: NDArray[integer[Any]], foldsTotal: NDArray[integer[Any]], mapShape: Tuple[int, ...], my: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]):
 #     from mapFolding.babbage import _countFolds

mapFolding/theSSOT.py

@@ -5,6 +5,10 @@ import numpy.typing
 import pathlib
 import sys
 
+dtypeLarge = numpy.int64
+dtypeDefault = dtypeLarge
+dtypeSmall = dtypeDefault
+
 try:
     _pathModule = pathlib.Path(__file__).parent
 except NameError:
@@ -24,7 +28,8 @@ class EnumIndices(enum.IntEnum):
         return count
 
     def __index__(self) -> int:
-        """Make the enum work with array indexing."""
+        """Adapt enum to the ultra-rare event of indexing a NumPy 'ndarray', which is not the
+        same as `array.array`. See NumPy.org; I think it will be very popular someday."""
         return self.value
 
 class indexMy(EnumIndices):

{mapFolding-0.2.0.dist-info → mapFolding-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.2.0
+Version: 0.2.2
 Summary: Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 Project-URL: homepage, https://github.com/hunterhogan/mapFolding
@@ -32,11 +32,11 @@ from mapFolding import countFolds
 foldsTotal = countFolds( [2,10] )
 ```
 
-The directory `mapFolding/reference` has
+The directory [mapFolding/reference](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/reference) has
 
 - a verbatim transcription of the "procedure" published in _The Computer Journal_,
 - multiple referential versions of the procedure with explanatory comments including
-- `hunterNumba.py` a one-size-fits-all, self-contained, reasonably fast, contemporary algorithm that is nevertheless infected by _noobaceae ignorancium_, and
+- [hunterNumba.py](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/reference), a one-size-fits-all, self-contained, reasonably fast, contemporary algorithm that is nevertheless infected by _noobaceae ignorancium_, and
 - miscellaneous notes.
 
 [![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml)
@@ -97,13 +97,13 @@ Cache cleared from C:\apps\mapFolding\mapFolding\.cache
 
 ### The typo-laden algorithm published in 1971
 
-The full paper, W. F. Lunnon, Multi-dimensional map-folding, _The Computer Journal_, Volume 14, Issue 1, 1971, Pages 75–80, [https://doi.org/10.1093/comjnl/14.1.75](https://doi.org/10.1093/comjnl/14.1.75) ([BibTex](mapFolding/citations/Lunnon.bibtex) citation) is available at the DOI link. (As of 3 January 2025, the paper is a PDF of images, not text, and can be accessed without cost or login.)
+The full paper, W. F. Lunnon, Multi-dimensional map-folding, _The Computer Journal_, Volume 14, Issue 1, 1971, Pages 75–80, [https://doi.org/10.1093/comjnl/14.1.75](https://doi.org/10.1093/comjnl/14.1.75) ([BibTex](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/citations/Lunnon.bibtex) citation) is available at the DOI link. (As of 3 January 2025, the paper is a PDF of images, not text, and can be accessed without cost or login.)
 
-In [`foldings.txt`](mapFolding/reference/foldings.txt), you can find a text transcription of the algorithm as it was printed in 1971. In [`foldings.AA`](mapFolding/reference/foldings.AA), I have corrected obvious transcription errors, documented with comments, and I have reformatted line breaks and indentation. For contemporary readers, the result is likely easier to read than the text transcription or the original paper are easy to read. This is especially true if you view the document with semantic highlighting, such as with [Algol 60 syntax highlighter](https://github.com/PolariTOON/language-algol60).
+In [`foldings.txt`](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/reference/foldings.txt), you can find a text transcription of the algorithm as it was printed in 1971. In [`foldings.AA`](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/reference/foldings.AA), I have corrected obvious transcription errors, documented with comments, and I have reformatted line breaks and indentation. For contemporary readers, the result is likely easier to read than the text transcription or the original paper are easy to read. This is especially true if you view the document with semantic highlighting, such as with [Algol 60 syntax highlighter](https://github.com/PolariTOON/language-algol60).
 
 ### Java implementation(s) and improvements
 
-[archmageirvine](https://github.com/archmageirvine/joeis/blob/80e3e844b11f149704acbab520bc3a3a25ac34ff/src/irvine/oeis/a001/A001415.java) ([BibTex](mapFolding/citations/jOEIS.bibtex) citation) says about the Java code:
+[archmageirvine](https://github.com/archmageirvine/joeis/blob/80e3e844b11f149704acbab520bc3a3a25ac34ff/src/irvine/oeis/a001/A001415.java) ([BibTex](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/citations/jOEIS.bibtex) citation) says about the Java code:
 
 ```java
 /**
@@ -122,49 +122,12 @@ In [`foldings.txt`](mapFolding/reference/foldings.txt), you can find a text tran
 
 ~~This caused my neurosis:~~ I enjoyed the following video, which is what introduced me to map folding.
 
-"How Many Ways Can You Fold a Map?" by Physics for the Birds, 2024 November 13 ([BibTex](mapFolding/citations/Physics_for_the_Birds.bibtex) citation)
+"How Many Ways Can You Fold a Map?" by Physics for the Birds, 2024 November 13 ([BibTex](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/citations/Physics_for_the_Birds.bibtex) citation)
 
 [![How Many Ways Can You Fold a Map?](https://i.ytimg.com/vi/sfH9uIY3ln4/hq720.jpg)](https://www.youtube.com/watch?v=sfH9uIY3ln4)
 
-## Install this package
-
-### From Github
-
-```sh
-pip install mapFolding@git+https://github.com/hunterhogan/mapFolding.git
-```
-
-### From a local directory
-
-#### Windows
-
-```powershell
-git clone https://github.com/hunterhogan/mapFolding.git \path\to\mapFolding
-pip install mapFolding@file:\path\to\mapFolding
-```
-
-#### POSIX
-
-```bash
-git clone https://github.com/hunterhogan/mapFolding.git /path/to/mapFolding
-pip install mapFolding@file:/path/to/mapFolding
-```
-
-## Install updates
-
-```sh
-pip install --upgrade mapFolding@git+https://github.com/hunterhogan/mapFolding.git
-```
-
-## Creating a virtual environment before installation
-
-You can isolate `mapFolding` in a virtual environment. For example, use the following commands to create a directory for the virtual environment, activate the virtual environment, and install the package. In the future, you will likely need to activate the virtual environment before using `mapFolding` again. From the command line, in a directory you want to install in.
+## Installation
 
 ```sh
-py -m venv mapFolding
-cd mapFolding
-cd Scripts
-activate
-cd ..
-pip install mapFolding@git+https://github.com/hunterhogan/mapFolding.git
+pip install mapFolding
 ```

mapFolding-0.2.2.dist-info/RECORD

@@ -0,0 +1,28 @@
+mapFolding/__init__.py,sha256=POxXTSE6Qu1G8k-YlSXHzbe-_JGuHk-L9p5SLRng4vA,439
+mapFolding/babbage.py,sha256=3D1qcntoiJm2tqgbiCAMc7GpGA0SZTdGORNEnensyxk,1882
+mapFolding/beDRY.py,sha256=ZrUXCNqnumTQ1XX8RT5gGdRr-a-o8QxEiGrerUxKtYg,12784
+mapFolding/lovelace.py,sha256=qcyGpVEPP3n0r-RNrSUgPRP3yZJfBEfmok7jYMm1OI0,11473
+mapFolding/oeis.py,sha256=_-fLGc1ybZ2eFxoiBrSmojMexeg6ROxtrLaBF2BzMn4,12144
+mapFolding/startHere.py,sha256=RGdFoJJdrJ_0tmLIKZn1WnHP0NCZwvQG7C2p4EUHOe4,5034
+mapFolding/theSSOT.py,sha256=yRW6aHyJxheL-Znk537LQA6xUPHz6FfoXY-0Ayh3Lsg,2178
+mapFolding/JAX/lunnanJAX.py,sha256=xMZloN47q-MVfjdYOM1hi9qR4OnLq7qALmGLMraevQs,14819
+mapFolding/JAX/taskJAX.py,sha256=yJNeH0rL6EhJ6ppnATHF0Zf81CDMC10bnPnimVxE1hc,20037
+mapFolding/benchmarks/benchmarking.py,sha256=kv85F6V9pGhZvTOImArOuxyg5rywA_T6JLH_qFXM8BM,3018
+mapFolding/benchmarks/test_benchmarks.py,sha256=c4ANeR3jgqpKXFoxDeZkmAHxSuenMwsjmrhKJ1_XPqY,3659
+mapFolding/reference/hunterNumba.py,sha256=0giUyqAFzP-XKcq3Kz8wIWCK0BVFhjABVJ1s-w4Jhu0,7109
+mapFolding/reference/irvineJavaPort.py,sha256=Sj-63Z-OsGuDoEBXuxyjRrNmmyl0d7Yz_XuY7I47Oyg,4250
+mapFolding/reference/lunnan.py,sha256=XEcql_gxvCCghb6Or3qwmPbn4IZUbZTaSmw_fUjRxZE,5037
+mapFolding/reference/lunnanNumpy.py,sha256=HqDgSwTOZA-G0oophOEfc4zs25Mv4yw2aoF1v8miOLk,4653
+mapFolding/reference/lunnanWhile.py,sha256=7NY2IKO5XBgol0aWWF_Fi-7oTL9pvu_z6lB0TF1uVHk,4063
+mapFolding/reference/rotatedEntryPoint.py,sha256=z0QyDQtnMvXNj5ntWzzJUQUMFm1-xHGLVhtYzwmczUI,11530
+mapFolding/reference/total_countPlus1vsPlusN.py,sha256=usenM8Yn_G1dqlPl7NKKkcnbohBZVZBXTQRm2S3_EDA,8106
+tests/__init__.py,sha256=PGYVr7r23gATgcvZ3Sfph9D_g1MVvhgzMNWXBs_9tmY,52
+tests/conftest.py,sha256=VFYSd7-tHWd-LUKnTY24PIJhq9quP9S3sK2SYusNNog,12875
+tests/test_oeis.py,sha256=vxnwO-cSR68htkyMh9QMVv-lvxBo6qlwPg1Rbx4JylY,7963
+tests/test_other.py,sha256=cf8DbkZxm_DHNq9lkMe7auXye_XspruU9qiNZATkxr4,6930
+tests/test_tasks.py,sha256=Nwe4iuSjwGZvsw5CXCcic7tkBxgM5JX9mrGZMDYhAwE,1785
+mapFolding-0.2.2.dist-info/METADATA,sha256=BSCXcKZDhAtOWr8A5pZMG8bZnm5YBLf-6uMN9qs8JDk,5914
+mapFolding-0.2.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapFolding-0.2.2.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapFolding-0.2.2.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapFolding-0.2.2.dist-info/RECORD,,

tests/conftest.py

@@ -3,31 +3,33 @@ Other test modules must not import directly from the package being tested."""
 
 # TODO learn how to run tests and coverage analysis without `env = ["NUMBA_DISABLE_JIT=1"]`
 
-from typing import Any, Callable, Dict, Generator, List, Optional, Sequence, Tuple, Type, Union
+from typing import Any, Callable, Dict, Generator, List, Optional, Sequence, Set, Tuple, Type, Union
 import pathlib
 import pytest
 import random
+import shutil
 import unittest.mock
-
-from mapFolding import clearOEIScache
-from mapFolding import countFolds, pathJobDEFAULT
+import uuid
+from Z0Z_tools.pytest_parseParameters import makeTestSuiteConcurrencyLimit
+from Z0Z_tools.pytest_parseParameters import makeTestSuiteIntInnit
+from Z0Z_tools.pytest_parseParameters import makeTestSuiteOopsieKwargsie
+from mapFolding import countFolds, pathJobDEFAULT, indexMy, indexThe, indexTrack
+from mapFolding import defineConcurrencyLimit, intInnit, oopsieKwargsie
 from mapFolding import getLeavesTotal, parseDimensions, validateListDimensions
-from mapFolding.importPackages import makeTestSuiteConcurrencyLimit, defineConcurrencyLimit
-from mapFolding.importPackages import makeTestSuiteIntInnit, intInnit
-from mapFolding.importPackages import makeTestSuiteOopsieKwargsie, oopsieKwargsie
+from mapFolding import getTaskDivisions, makeConnectionGraph, outfitFoldings, setCPUlimit
+from mapFolding import oeisIDfor_n, getOEISids, clearOEIScache
+from mapFolding.beDRY import makeDataContainer
 from mapFolding.oeis import OEIS_for_n
-from mapFolding.oeis import _formatFilenameCache
+from mapFolding.oeis import _getFilenameOEISbFile
 from mapFolding.oeis import _getOEISidValues
 from mapFolding.oeis import _parseBFileOEIS
 from mapFolding.oeis import _validateOEISid
-from mapFolding.oeis import getOEISids
-from mapFolding.oeis import oeisIDfor_n
 from mapFolding.oeis import oeisIDsImplemented
 from mapFolding.oeis import settingsOEIS
 
 __all__ = [
     'OEIS_for_n',
-    '_formatFilenameCache',
+    '_getFilenameOEISbFile',
     '_getOEISidValues',
     '_parseBFileOEIS',
     '_validateOEISid',
@@ -37,14 +39,20 @@ __all__ = [
     'expectSystemExit',
     'getLeavesTotal',
     'getOEISids',
+    'indexThe',
+    'getTaskDivisions',
     'intInnit',
+    'makeConnectionGraph',
+    'makeDataContainer',
     'makeTestSuiteConcurrencyLimit',
     'makeTestSuiteIntInnit',
     'makeTestSuiteOopsieKwargsie',
     'oeisIDfor_n',
     'oeisIDsImplemented',
     'oopsieKwargsie',
+    'outfitFoldings',
     'parseDimensions',
+    'setCPUlimit',
     'settingsOEIS',
     'standardCacheTest',
     'standardComparison',
@@ -91,6 +99,75 @@ def makeDictionaryFoldsTotalKnown() -> Dict[Tuple[int,...], int]:
 
     return dictionaryMapDimensionsToFoldsTotalKnown
 
+"""
+Section: temporary paths and pathFilenames"""
+
+# SSOT for test data paths
+pathDataSamples = pathlib.Path("tests/dataSamples")
+pathTempRoot = pathDataSamples / "tmp"
+
+# The registrar maintains the register of temp files
+registerOfTempFiles: Set[pathlib.Path] = set()
+
+def addTempFileToRegister(path: pathlib.Path) -> None:
+    """The registrar adds a temp file to the register."""
+    registerOfTempFiles.add(path)
+
+def cleanupTempFileRegister() -> None:
+    """The registrar cleans up temp files in the register."""
+    for pathTemp in sorted(registerOfTempFiles, reverse=True):
+        try:
+            if pathTemp.is_file():
+                pathTemp.unlink(missing_ok=True)
+            elif pathTemp.is_dir():
+                shutil.rmtree(pathTemp, ignore_errors=True)
+        except Exception as ERRORmessage:
+            print(f"Warning: Failed to clean up {pathTemp}: {ERRORmessage}")
+    registerOfTempFiles.clear()
+
+@pytest.fixture(scope="session", autouse=True)
+def setupTeardownTestData() -> Generator[None, None, None]:
+    """Auto-fixture to setup test data directories and cleanup after."""
+    pathDataSamples.mkdir(exist_ok=True)
+    pathTempRoot.mkdir(exist_ok=True)
+    yield
+    cleanupTempFileRegister()
+
+@pytest.fixture
+def pathTempTesting(request: pytest.FixtureRequest) -> pathlib.Path:
+    """Create a unique temp directory for each test function."""
+    # Sanitize test name for filesystem compatibility
+    sanitizedName = request.node.name.replace('[', '_').replace(']', '_').replace('/', '_')
+    uniqueDirectory = f"{sanitizedName}_{uuid.uuid4()}"
+    pathTemp = pathTempRoot / uniqueDirectory
+    pathTemp.mkdir(parents=True, exist_ok=True)
+
+    addTempFileToRegister(pathTemp)
+    return pathTemp
+
+@pytest.fixture
+def pathCacheTesting(pathTempTesting: pathlib.Path) -> Generator[pathlib.Path, Any, None]:
+    """Temporarily replace the OEIS cache directory with a test directory."""
+    from mapFolding import oeis as there_must_be_a_better_way
+    pathCacheOriginal = there_must_be_a_better_way._pathCache
+    there_must_be_a_better_way._pathCache = pathTempTesting
+    yield pathTempTesting
+    there_must_be_a_better_way._pathCache = pathCacheOriginal
+
+@pytest.fixture
+def pathFilenameBenchmarksTesting(pathTempTesting: pathlib.Path) -> Generator[pathlib.Path, Any, None]:
+    """Temporarily replace the benchmarks directory with a test directory."""
+    from mapFolding.benchmarks import benchmarking
+    pathFilenameOriginal = benchmarking.pathFilenameRecordedBenchmarks
+    pathFilenameTest = pathTempTesting / "benchmarks.npy"
+    benchmarking.pathFilenameRecordedBenchmarks = pathFilenameTest
+    yield pathFilenameTest
+    benchmarking.pathFilenameRecordedBenchmarks = pathFilenameOriginal
+
+@pytest.fixture
+def pathFilenameFoldsTotalTesting(pathTempTesting: pathlib.Path) -> pathlib.Path:
+    return pathTempTesting.joinpath("foldsTotalTest.txt")
+
 """
 Section: Fixtures"""
 
@@ -150,28 +227,15 @@ def oeisID_1random() -> str:
     """Return one random valid OEIS ID."""
     return random.choice(oeisIDsImplemented)
 
-@pytest.fixture
-def pathCacheTesting(tmp_path: pathlib.Path) -> Generator[pathlib.Path, Any, None]:
-    """Temporarily replace the OEIS cache directory with a test directory."""
-    from mapFolding import oeis as there_must_be_a_better_way
-    pathCacheOriginal = there_must_be_a_better_way._pathCache
-    there_must_be_a_better_way._pathCache = tmp_path
-    yield tmp_path
-    there_must_be_a_better_way._pathCache = pathCacheOriginal
-
-@pytest.fixture
-def pathBenchmarksTesting(tmp_path: pathlib.Path) -> Generator[pathlib.Path, Any, None]:
-    """Temporarily replace the benchmarks directory with a test directory."""
-    from mapFolding.benchmarks import benchmarking
-    pathOriginal = benchmarking.pathFilenameRecordedBenchmarks
-    pathTest = tmp_path / "benchmarks.npy"
-    benchmarking.pathFilenameRecordedBenchmarks = pathTest
-    yield pathTest
-    benchmarking.pathFilenameRecordedBenchmarks = pathOriginal
-
 """
 Section: Standardized test structures"""
 
+def formatTestMessage(expected: Any, actual: Any, functionName: str, *arguments: Any) -> str:
+    """Format assertion message for any test comparison."""
+    return (f"\nTesting: `{functionName}({', '.join(str(parameter) for parameter in arguments)})`\n"
+            f"Expected: {expected}\n"
+            f"Got: {actual}")
+
 def standardComparison(expected: Any, functionTarget: Callable, *arguments: Any) -> None:
     """Template for tests expecting an error."""
     if type(expected) == Type[Exception]:
@@ -217,12 +281,6 @@ def expectSystemExit(expected: Union[str, int, Sequence[int]], functionTarget: C
         assert exitCode == expected, \
             f"Expected exit code {expected} but got {exitCode}"
 
-def formatTestMessage(expected: Any, actual: Any, functionName: str, *arguments: Any) -> str:
-    """Format assertion message for any test comparison."""
-    return (f"\nTesting: `{functionName}({', '.join(str(parameter) for parameter in arguments)})`\n"
-            f"Expected: {expected}\n"
-            f"Got: {actual}")
-
 def standardCacheTest(
     expected: Any,
     setupCacheFile: Optional[Callable[[pathlib.Path, str], None]],
@@ -237,7 +295,7 @@ def standardCacheTest(
         oeisID: OEIS ID to test
         pathCache: Temporary cache directory path
     """
-    pathFilenameCache = pathCache / _formatFilenameCache.format(oeisID=oeisID)
+    pathFilenameCache = pathCache / _getFilenameOEISbFile(oeisID)
 
     # Setup cache file if provided
     if setupCacheFile: