mapFolding 0.4.3__py3-none-any.whl → 0.5.1__py3-none-any.whl

mapFolding/syntheticModules/numbaCount.py

@@ -1,158 +0,0 @@
-from mapFolding import indexMy, indexTrack
-from numba import jit, int64, prange, uint16
-from numpy import ndarray, dtype, integer
-from typing import Tuple, Any
-
-@jit((uint16[:, :, ::1], uint16[::1], uint16[::1], uint16[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
-def countInitialize(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
-    while my[indexMy.leaf1ndex.value] > 0:
-        if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
-            my[indexMy.dimensionsUnconstrained.value] = my[indexMy.dimensionsTotal.value]
-            my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
-            my[indexMy.indexDimension.value] = 0
-            while my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]:
-                if connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]:
-                    my[indexMy.dimensionsUnconstrained.value] -= 1
-                else:
-                    my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
-                    while my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]:
-                        gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.leafConnectee.value]
-                        if track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] == 0:
-                            my[indexMy.gap1ndexCeiling.value] += 1
-                        track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
-                        my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
-                my[indexMy.indexDimension.value] += 1
-            if not my[indexMy.dimensionsUnconstrained.value]:
-                my[indexMy.indexLeaf.value] = 0
-                while my[indexMy.indexLeaf.value] < my[indexMy.leaf1ndex.value]:
-                    gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.indexLeaf.value]
-                    my[indexMy.gap1ndexCeiling.value] += 1
-                    my[indexMy.indexLeaf.value] += 1
-            my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
-            while my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]:
-                gapsWhere[my[indexMy.gap1ndex.value]] = gapsWhere[my[indexMy.indexMiniGap.value]]
-                if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == my[indexMy.dimensionsUnconstrained.value]:
-                    my[indexMy.gap1ndex.value] += 1
-                track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
-                my[indexMy.indexMiniGap.value] += 1
-        if my[indexMy.leaf1ndex.value] > 0:
-            my[indexMy.gap1ndex.value] -= 1
-            track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]] = gapsWhere[my[indexMy.gap1ndex.value]]
-            track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]] = track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]]
-            track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
-            track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
-            track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value]] = my[indexMy.gap1ndex.value]
-            my[indexMy.leaf1ndex.value] += 1
-        if my[indexMy.gap1ndex.value] > 0:
-            return
-
-@jit((uint16[:, :, ::1], int64[::1], uint16[::1], uint16[::1], uint16[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=True)
-def countParallel(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[Tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
-    gapsWherePARALLEL = gapsWhere.copy()
-    myPARALLEL = my.copy()
-    trackPARALLEL = track.copy()
-    taskDivisionsPrange = myPARALLEL[indexMy.taskDivisions.value]
-    for indexSherpa in prange(taskDivisionsPrange):
-        groupsOfFolds: int = 0
-        gapsWhere = gapsWherePARALLEL.copy()
-        my = myPARALLEL.copy()
-        track = trackPARALLEL.copy()
-        my[indexMy.taskIndex.value] = indexSherpa
-        while my[indexMy.leaf1ndex.value] > 0:
-            if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
-                if my[indexMy.leaf1ndex.value] > foldGroups[-1]:
-                    groupsOfFolds += 1
-                else:
-                    my[indexMy.dimensionsUnconstrained.value] = my[indexMy.dimensionsTotal.value]
-                    my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
-                    my[indexMy.indexDimension.value] = 0
-                    while my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]:
-                        if connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]:
-                            my[indexMy.dimensionsUnconstrained.value] -= 1
-                        else:
-                            my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
-                            while my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]:
-                                if my[indexMy.leaf1ndex.value] != my[indexMy.taskDivisions.value] or my[indexMy.leafConnectee.value] % my[indexMy.taskDivisions.value] == my[indexMy.taskIndex.value]:
-                                    gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.leafConnectee.value]
-                                    if track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] == 0:
-                                        my[indexMy.gap1ndexCeiling.value] += 1
-                                    track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
-                                my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
-                        my[indexMy.indexDimension.value] += 1
-                    my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
-                    while my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]:
-                        gapsWhere[my[indexMy.gap1ndex.value]] = gapsWhere[my[indexMy.indexMiniGap.value]]
-                        if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == my[indexMy.dimensionsUnconstrained.value]:
-                            my[indexMy.gap1ndex.value] += 1
-                        track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
-                        my[indexMy.indexMiniGap.value] += 1
-            while my[indexMy.leaf1ndex.value] > 0 and my[indexMy.gap1ndex.value] == track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]:
-                my[indexMy.leaf1ndex.value] -= 1
-                track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]
-                track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]
-            if my[indexMy.leaf1ndex.value] > 0:
-                my[indexMy.gap1ndex.value] -= 1
-                track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]] = gapsWhere[my[indexMy.gap1ndex.value]]
-                track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]] = track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]]
-                track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
-                track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
-                track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value]] = my[indexMy.gap1ndex.value]
-                my[indexMy.leaf1ndex.value] += 1
-        foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds
-
-@jit((uint16[:, :, ::1], int64[::1], uint16[::1], uint16[::1], uint16[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=False)
-def countSequential(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[Tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
-    leafBelow = track[indexTrack.leafBelow.value]
-    gapRangeStart = track[indexTrack.gapRangeStart.value]
-    countDimensionsGapped = track[indexTrack.countDimensionsGapped.value]
-    leafAbove = track[indexTrack.leafAbove.value]
-    leaf1ndex = my[indexMy.leaf1ndex.value]
-    dimensionsUnconstrained = my[indexMy.dimensionsUnconstrained.value]
-    dimensionsTotal = my[indexMy.dimensionsTotal.value]
-    gap1ndexCeiling = my[indexMy.gap1ndexCeiling.value]
-    indexDimension = my[indexMy.indexDimension.value]
-    leafConnectee = my[indexMy.leafConnectee.value]
-    indexMiniGap = my[indexMy.indexMiniGap.value]
-    gap1ndex = my[indexMy.gap1ndex.value]
-    taskIndex = my[indexMy.taskIndex.value]
-    groupsOfFolds: int = 0
-    while leaf1ndex > 0:
-        if leaf1ndex <= 1 or leafBelow[0] == 1:
-            if leaf1ndex > foldGroups[-1]:
-                groupsOfFolds += 1
-            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 leaf1ndex > 0 and gap1ndex == gapRangeStart[leaf1ndex - 1]:
-            leaf1ndex -= 1
-            leafBelow[leafAbove[leaf1ndex]] = leafBelow[leaf1ndex]
-            leafAbove[leafBelow[leaf1ndex]] = leafAbove[leaf1ndex]
-        if leaf1ndex > 0:
-            gap1ndex -= 1
-            leafAbove[leaf1ndex] = gapsWhere[gap1ndex]
-            leafBelow[leaf1ndex] = leafBelow[leafAbove[leaf1ndex]]
-            leafBelow[leafAbove[leaf1ndex]] = leaf1ndex
-            leafAbove[leafBelow[leaf1ndex]] = leaf1ndex
-            gapRangeStart[leaf1ndex] = gap1ndex
-            leaf1ndex += 1
-    foldGroups[taskIndex] = groupsOfFolds

mapFolding/syntheticModules/numba_doTheNeedful.py

@@ -1,13 +0,0 @@
-from mapFolding import indexMy
-from mapFolding.syntheticModules.numbaCount import countParallel, countSequential, countInitialize
-from numba import jit, int64, uint16
-from numpy import ndarray, dtype, integer
-from typing import Tuple, Any
-
-@jit((uint16[:, :, ::1], int64[::1], uint16[::1], uint16[::1], uint16[::1], uint16[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
-def doTheNeedful(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[Tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], mapShape: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
-    countInitialize(connectionGraph, gapsWhere, my, track)
-    if my[indexMy.taskDivisions.value] > 0:
-        countParallel(connectionGraph, foldGroups, gapsWhere, my, track)
-    else:
-        countSequential(connectionGraph, foldGroups, gapsWhere, my, track)

mapFolding-0.4.3.dist-info/RECORD

@@ -1,40 +0,0 @@
-mapFolding/__init__.py,sha256=1-iO5PCGKlW81fhMDjSLrsKxuSeV-UMcU1NlKW352FM,1347
-mapFolding/basecamp.py,sha256=MyrkAbJZawW6CPVEJ_7iPfCYjngdFHmicSs8Ylq5S1E,3787
-mapFolding/beDRY.py,sha256=tDLddJzQoGvbcttJro8ML2B59KspMkZwIeZdm4hOy_4,16785
-mapFolding/oeis.py,sha256=8c6q3STjgp-c4Reode9PLLYS3c00wCsJW-yfte7NI60,11103
-mapFolding/theDao.py,sha256=PZgx_0X7QfdIpLpEO5mbdVNFMCRuP8PD-f62xU7C4U0,12618
-mapFolding/theSSOT.py,sha256=RQmSsjmysc9izjGLsVseZ0J0nDzG_rKY7QkrOF-47SU,5794
-mapFolding/theSSOTdatatypes.py,sha256=H0d1vAn59VCRPMhn28PtlBEZnjmQjEKofiefgvpBFsg,5955
-mapFolding/reference/flattened.py,sha256=S6D9wiFTlbeoetEqaMLOcA-R22BHOzjqPRujffNxxUM,14875
-mapFolding/reference/hunterNumba.py,sha256=jDS0ORHkIhcJ1rzA5hT49sZHKf3rgJOoGesUCcbKFFY,6054
-mapFolding/reference/irvineJavaPort.py,sha256=7GvBU0tnS6wpFgkYad3465do9jBQW-2bYvbCYyABPHM,3341
-mapFolding/reference/jax.py,sha256=7ji9YWia6Kof0cjcNdiS1GG1rMbC5SBjcyVr_07AeUk,13845
-mapFolding/reference/lunnan.py,sha256=iAbJELfW6RKNMdPcBY9b6rGQ-z1zoRf-1XCurCRMOo8,3951
-mapFolding/reference/lunnanNumpy.py,sha256=rwVP3WIDXimpAuaxhRIuBYU56nVDTKlfGiclw_FkgUU,3765
-mapFolding/reference/lunnanWhile.py,sha256=uRrMT23jTJvoQDlD_FzeIQe_pfMXJG6_bRvs7uhC8z0,3271
-mapFolding/reference/rotatedEntryPoint.py,sha256=USZY3n3zwhSE68ATscUuN66t1qShuEbMI790Gz9JFTw,9352
-mapFolding/reference/total_countPlus1vsPlusN.py,sha256=wpgay-uqPOBd64Z4Pg6tg40j7-4pzWHGMM6v0bnmjhE,6288
-mapFolding/someAssemblyRequired/__init__.py,sha256=wtec_hIz-AKz0_hGdXsWnCKTcCxdMV9-WK6SiIriAeU,396
-mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=nX8tghZClYt7zJd6RpZBXhE_h-CGRHOS17biqiEdf-o,855
-mapFolding/someAssemblyRequired/makeJob.py,sha256=c9sTRUK90snTCcXCvs86VKBH6z_nt3OVFjNs_WgCoIg,2422
-mapFolding/someAssemblyRequired/synthesizeModuleJAX.py,sha256=jatvtYhK5ZJK-YmCKATt7w3icFXXO79cZDAYVrU9bgA,1258
-mapFolding/someAssemblyRequired/synthesizeNumba.py,sha256=eJRZ8ttfaONMq-s3BawswJrHu_m0DUHp4dGpx6uVpuk,16920
-mapFolding/someAssemblyRequired/synthesizeNumbaGeneralized.py,sha256=3FiD6fDGzam6uvgTg7YEsGlLftbBOol2ajvEa4GNTec,16698
-mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=pknX6CeH9iuDTs9tp0gz33T2U5gjO8NMpPnQnnBU2gA,9138
-mapFolding/someAssemblyRequired/synthesizeNumbaModules.py,sha256=V9xpM1r4MQlhXoKLkF2PTg69gid7Ec64pbMc2ZZ2xXo,5590
-mapFolding/syntheticModules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mapFolding/syntheticModules/numbaCount.py,sha256=VkTHk97gIBRZg7FwX7hCgfunSBK2Gyr4pp3fzHNrLhw,12907
-mapFolding/syntheticModules/numba_doTheNeedful.py,sha256=9syuZEc1KwH3BFp2TmK7-pBuT2N4lVJTiUhqu7ahaKY,1157
-tests/__init__.py,sha256=eg9smg-6VblOr0kisM40CpGnuDtU2JgEEWGDTFVOlW8,57
-tests/conftest.py,sha256=qP-ZCyyqXC4E9W_psMVbHPlXE-8Ue01fBckGqhzlhGQ,11972
-tests/test_computations.py,sha256=WO28l9AmrFY6kbcx9iJr6YNoqLbZ8Lgs7FryH5DG0BI,2856
-tests/test_oeis.py,sha256=C2F6XrI5oRPjc29lykN3e83rIcgl01UwBLB6L-Qz2pE,4733
-tests/test_other.py,sha256=u0vINT5EyVsXTNTR2DZIMpWCg4FH471jjHLRzC2JX7U,8351
-tests/test_tasks.py,sha256=iq6_dh43JQkC2vAWXua0Xe915BKFGbvRJAkmbco854A,2389
-tests/test_types.py,sha256=58tmPG9WOeGGAQbdQK_h_7t4SnENnZugH4WXlI8-L-M,171
-mapFolding-0.4.3.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-mapFolding-0.4.3.dist-info/METADATA,sha256=52v3PWTTXMbJwXFaUQFAnJilfn29HFiESW83sPFUL1M,7633
-mapFolding-0.4.3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapFolding-0.4.3.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapFolding-0.4.3.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapFolding-0.4.3.dist-info/RECORD,,

tests/__init__.py

@@ -1 +0,0 @@
-from tests.conftest import makeDictionaryFoldsTotalKnown

tests/conftest.py

@@ -1,306 +0,0 @@
-"""SSOT for Pytest"""
-
-# TODO learn how to run tests and coverage analysis without `env = ["NUMBA_DISABLE_JIT=1"]`
-
-from mapFolding import *
-from mapFolding import basecamp, getAlgorithmDispatcher, getDispatcherCallable
-from mapFolding.beDRY import *
-from mapFolding.someAssemblyRequired import *
-from mapFolding.oeis import *
-from types import ModuleType
-from typing import Any, Callable, ContextManager, Dict, Generator, List, Literal, NoReturn, Optional, Sequence, Set, Tuple, Type, Union
-from Z0Z_tools.pytestForYourUse import PytestFor_defineConcurrencyLimit, PytestFor_intInnit, PytestFor_oopsieKwargsie
-import importlib.util
-import pathlib
-import pytest
-import random
-import shutil
-import unittest.mock
-import uuid
-
-# SSOT for test data paths and filenames
-pathDataSamples = pathlib.Path("tests/dataSamples")
-# NOTE `tmp` is not a diminutive form of temporary: it signals a technical term. And "temp" is strongly disfavored.
-pathTmpRoot = pathDataSamples / "tmp"
-
-# The registrar maintains the register of temp files
-registerOfTemporaryFilesystemObjects: Set[pathlib.Path] = set()
-
-def registrarRecordsTmpObject(path: pathlib.Path) -> None:
-	"""The registrar adds a tmp file to the register."""
-	registerOfTemporaryFilesystemObjects.add(path)
-
-def registrarDeletesTmpObjects() -> None:
-	"""The registrar cleans up tmp files in the register."""
-	for pathTmp in sorted(registerOfTemporaryFilesystemObjects, reverse=True):
-		try:
-			if pathTmp.is_file():
-				pathTmp.unlink(missing_ok=True)
-			elif pathTmp.is_dir():
-				shutil.rmtree(pathTmp, ignore_errors=True)
-		except Exception as ERRORmessage:
-			print(f"Warning: Failed to clean up {pathTmp}: {ERRORmessage}")
-	registerOfTemporaryFilesystemObjects.clear()
-
-@pytest.fixture(scope="session", autouse=True)
-def setupTeardownTmpObjects() -> Generator[None, None, None]:
-	"""Auto-fixture to setup test data directories and cleanup after."""
-	pathDataSamples.mkdir(exist_ok=True)
-	pathTmpRoot.mkdir(exist_ok=True)
-	yield
-	registrarDeletesTmpObjects()
-
-@pytest.fixture
-def pathTmpTesting(request: pytest.FixtureRequest) -> pathlib.Path:
-	# "Z0Z_" ensures the directory name does not start with a number, which would make it an invalid Python identifier
-	pathTmp = pathTmpRoot / ("Z0Z_" + str(uuid.uuid4().hex))
-	pathTmp.mkdir(parents=True, exist_ok=False)
-
-	registrarRecordsTmpObject(pathTmp)
-	return pathTmp
-
-@pytest.fixture
-def pathFilenameTmpTesting(request: pytest.FixtureRequest) -> pathlib.Path:
-	try:
-		extension = request.param
-	except AttributeError:
-		extension = ".txt"
-
-	# "Z0Z_" ensures the name does not start with a number, which would make it an invalid Python identifier
-	uuidHex = uuid.uuid4().hex
-	subpath = "Z0Z_" + uuidHex[0:-8]
-	filenameStem = "Z0Z_" + uuidHex[-8:None]
-
-	pathFilenameTmp = pathlib.Path(pathTmpRoot, subpath, filenameStem + extension)
-	pathFilenameTmp.parent.mkdir(parents=True, exist_ok=False)
-
-	registrarRecordsTmpObject(pathFilenameTmp)
-	return pathFilenameTmp
-
-@pytest.fixture
-def pathCacheTesting(pathTmpTesting: 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 = pathTmpTesting
-	yield pathTmpTesting
-	there_must_be_a_better_way._pathCache = pathCacheOriginal
-
-@pytest.fixture
-def pathFilenameFoldsTotalTesting(pathTmpTesting: pathlib.Path) -> pathlib.Path:
-	return pathTmpTesting.joinpath("foldsTotalTest.txt")
-
-def makeDictionaryFoldsTotalKnown() -> Dict[Tuple[int,...], int]:
-	"""Returns a dictionary mapping dimension tuples to their known folding totals."""
-	dictionaryMapDimensionsToFoldsTotalKnown: Dict[Tuple[int, ...], int] = {}
-
-	for settings in settingsOEIS.values():
-		sequence = settings['valuesKnown']
-
-		for n, foldingsTotal in sequence.items():
-			dimensions = settings['getMapShape'](n)
-			dimensions.sort()
-			dictionaryMapDimensionsToFoldsTotalKnown[tuple(dimensions)] = foldingsTotal
-	return dictionaryMapDimensionsToFoldsTotalKnown
-
-"""
-Section: Fixtures"""
-
-@pytest.fixture(autouse=True)
-def setupWarningsAsErrors() -> Generator[None, Any, None]:
-	"""Convert all warnings to errors for all tests."""
-	import warnings
-	warnings.filterwarnings("error")
-	yield
-	warnings.resetwarnings()
-
-@pytest.fixture
-def foldsTotalKnown() -> Dict[Tuple[int,...], int]:
-	"""Returns a dictionary mapping dimension tuples to their known folding totals.
-	NOTE I am not convinced this is the best way to do this.
-	Advantage: I call `makeDictionaryFoldsTotalKnown()` from modules other than test modules.
-	Preference: I _think_ I would prefer a SSOT function available to any module
-	similar to `foldsTotalKnown = getFoldsTotalKnown(listDimensions)`."""
-	return makeDictionaryFoldsTotalKnown()
-
-@pytest.fixture
-def listDimensionsTestCountFolds(oeisID: str) -> List[int]:
-	"""For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestValidation`
-	if `validateListDimensions` approves. Each `listDimensions` is suitable for testing counts."""
-	while True:
-		n = random.choice(settingsOEIS[oeisID]['valuesTestValidation'])
-		if n < 2:
-			continue
-		listDimensionsCandidate = settingsOEIS[oeisID]['getMapShape'](n)
-
-		try:
-			return validateListDimensions(listDimensionsCandidate)
-		except (ValueError, NotImplementedError):
-			pass
-
-@pytest.fixture
-def listDimensionsTestFunctionality(oeisID_1random: str) -> List[int]:
-	"""To test functionality, get one `listDimensions` from `valuesTestValidation` if
-	`validateListDimensions` approves. The algorithm can count the folds of the returned
-	`listDimensions` in a short enough time suitable for testing."""
-	while True:
-		n = random.choice(settingsOEIS[oeisID_1random]['valuesTestValidation'])
-		if n < 2:
-			continue
-		listDimensionsCandidate = settingsOEIS[oeisID_1random]['getMapShape'](n)
-
-		try:
-			return validateListDimensions(listDimensionsCandidate)
-		except (ValueError, NotImplementedError):
-			pass
-
-@pytest.fixture
-def listDimensionsTestParallelization(oeisID: str) -> List[int]:
-	"""For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestParallelization`"""
-	n = random.choice(settingsOEIS[oeisID]['valuesTestParallelization'])
-	return settingsOEIS[oeisID]['getMapShape'](n)
-
-@pytest.fixture
-def mockBenchmarkTimer() -> Generator[unittest.mock.MagicMock | unittest.mock.AsyncMock, Any, None]:
-	"""Mock time.perf_counter_ns for consistent benchmark timing."""
-	with unittest.mock.patch('time.perf_counter_ns') as mockTimer:
-		mockTimer.side_effect = [0, 1e9]  # Start and end times for 1 second
-		yield mockTimer
-
-@pytest.fixture
-def mockFoldingFunction() -> Callable[..., Callable[..., None]]:
-	"""Creates a mock function that simulates _countFolds behavior."""
-	def make_mock(foldsValue: int, listDimensions: List[int]) -> Callable[..., None]:
-		mock_array = makeDataContainer(2)
-		mock_array[0] = foldsValue
-		mock_array[-1] = getLeavesTotal(listDimensions)
-
-		def mock_countFolds(**keywordArguments: Any) -> None:
-			keywordArguments['foldGroups'][:] = mock_array
-			return None
-
-		return mock_countFolds
-	return make_mock
-
-@pytest.fixture
-def mockDispatcher() -> Callable[[Any], ContextManager[Any]]:
-	"""Context manager for mocking dispatcher callable."""
-	def wrapper(mockFunction: Any) -> ContextManager[Any]:
-		dispatcherCallable = getDispatcherCallable()
-		return unittest.mock.patch(
-			f"{dispatcherCallable.__module__}.{dispatcherCallable.__name__}",
-			side_effect=mockFunction
-		)
-	return wrapper
-
-@pytest.fixture(params=oeisIDsImplemented)
-def oeisID(request: pytest.FixtureRequest) -> Any:
-	return request.param
-
-@pytest.fixture
-def oeisID_1random() -> str:
-	"""Return one random valid OEIS ID."""
-	return random.choice(oeisIDsImplemented)
-
-@pytest.fixture
-def useThisDispatcher():
-	"""A fixture providing a context manager for temporarily replacing the dispatcher.
-
-	Returns
-		A context manager for patching the dispatcher
-	"""
-	dispatcherOriginal = basecamp.getDispatcherCallable
-
-	def patchDispatcher(callableTarget: Callable) -> None:
-		def callableParameterized(*arguments: Any, **keywordArguments: Any) -> Callable:
-			return callableTarget
-		basecamp.getDispatcherCallable = callableParameterized
-
-	yield patchDispatcher
-	basecamp.getDispatcherCallable = dispatcherOriginal
-
-@pytest.fixture
-def useAlgorithmSourceDispatcher(useThisDispatcher: Callable) -> Generator[None, None, None]:
-	"""Temporarily patches getDispatcherCallable to return the algorithm dispatcher."""
-	useThisDispatcher(getAlgorithmDispatcher())
-	yield
-
-@pytest.fixture
-def syntheticDispatcherFixture(useThisDispatcher):
-	listCallablesInlineHARDCODED: List[str] = ['countInitialize', 'countParallel', 'countSequential']
-	listCallablesInline = listCallablesInlineHARDCODED
-	callableDispatcher = True
-	algorithmSource = None
-	relativePathWrite = None
-	filenameModuleWrite = 'pytestCount.py'
-	formatFilenameWrite = "pytest_{callableTarget}.py"
-	listSynthesizedModules: List[youOughtaKnow] = makeFlowNumbaOptimized(listCallablesInline, callableDispatcher, algorithmSource, relativePathWrite, filenameModuleWrite, formatFilenameWrite)
-	dispatcherSynthetic = youOughtaKnow('','','')
-	for stuff in listSynthesizedModules:
-		registrarRecordsTmpObject(stuff.pathFilenameForMe)
-		if stuff.callableSynthesized not in listCallablesInline:
-			dispatcherSynthetic: youOughtaKnow = stuff
-
-	dispatcherSpec = importlib.util.spec_from_file_location(dispatcherSynthetic.callableSynthesized, dispatcherSynthetic.pathFilenameForMe)
-	if dispatcherSpec is None:
-		raise ImportError(f"{dispatcherSynthetic.pathFilenameForMe=}")
-	if dispatcherSpec.loader is None:
-		raise ImportError(f"Failed to get loader for module {dispatcherSynthetic.pathFilenameForMe}")
-
-	dispatcherModule = importlib.util.module_from_spec(dispatcherSpec)
-	dispatcherSpec.loader.exec_module(dispatcherModule)
-	callableDispatcherSynthetic = getattr(dispatcherModule, dispatcherSynthetic.callableSynthesized)
-
-	useThisDispatcher(callableDispatcherSynthetic)
-	return callableDispatcherSynthetic
-
-def uniformTestMessage(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 standardizedEqualTo(expected: Any, functionTarget: Callable, *arguments: Any) -> None:
-	"""Template for tests expecting an error."""
-	if type(expected) is Type[Exception]:
-		messageExpected = expected.__name__
-	else:
-		messageExpected = expected
-
-	try:
-		messageActual = actual = functionTarget(*arguments)
-	except Exception as actualError:
-		messageActual = type(actualError).__name__
-		actual = type(actualError)
-
-	assert actual == expected, uniformTestMessage(messageExpected, messageActual, functionTarget.__name__, *arguments)
-
-def standardizedSystemExit(expected: Union[str, int, Sequence[int]], functionTarget: Callable, *arguments: Any) -> None:
-	"""Template for tests expecting SystemExit.
-
-	Parameters
-		expected: Exit code expectation:
-			- "error": any non-zero exit code
-			- "nonError": specifically zero exit code
-			- int: exact exit code match
-			- Sequence[int]: exit code must be one of these values
-		functionTarget: The function to test
-		arguments: Arguments to pass to the function
-	"""
-	with pytest.raises(SystemExit) as exitInfo:
-		functionTarget(*arguments)
-
-	exitCode = exitInfo.value.code
-
-	if expected == "error":
-		assert exitCode != 0, \
-			f"Expected error exit (non-zero) but got code {exitCode}"
-	elif expected == "nonError":
-		assert exitCode == 0, \
-			f"Expected non-error exit (0) but got code {exitCode}"
-	elif isinstance(expected, (list, tuple)):
-		assert exitCode in expected, \
-			f"Expected exit code to be one of {expected} but got {exitCode}"
-	else:
-		assert exitCode == expected, \
-			f"Expected exit code {expected} but got {exitCode}"

tests/test_computations.py

@@ -1,43 +0,0 @@
-from pathlib import Path
-from tests.conftest import *
-import importlib.util
-import pytest
-
-def test_algorithmSourceParallel(listDimensionsTestParallelization: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int], useAlgorithmSourceDispatcher: None) -> None:
-	standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
-
-def test_algorithmSourceSequential(listDimensionsTestCountFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int], useAlgorithmSourceDispatcher: None) -> None:
-	standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestCountFolds)], countFolds, listDimensionsTestCountFolds)
-
-def test_aOFn_calculate_value(oeisID: str) -> None:
-	for n in settingsOEIS[oeisID]['valuesTestValidation']:
-		standardizedEqualTo(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
-
-@pytest.mark.parametrize('pathFilenameTmpTesting', ['.py'], indirect=True)
-def test_writeJobNumba(listDimensionsTestCountFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int], pathFilenameTmpTesting: Path) -> None:
-	from mapFolding.syntheticModules import numbaCount
-	algorithmSourceHARDCODED: ModuleType = numbaCount
-	algorithmSource = algorithmSourceHARDCODED
-	callableTargetHARDCODED = 'countSequential'
-	callableTarget = callableTargetHARDCODED
-	pathFilenameModule = writeJobNumba(listDimensionsTestCountFolds, algorithmSource, callableTarget, pathFilenameWriteJob=pathFilenameTmpTesting.absolute())
-
-	Don_Lapre_Road_to_Self_Improvement = importlib.util.spec_from_file_location("__main__", pathFilenameModule)
-	if Don_Lapre_Road_to_Self_Improvement is None:
-		raise ImportError(f"Failed to create module specification from {pathFilenameModule}")
-	if Don_Lapre_Road_to_Self_Improvement.loader is None:
-		raise ImportError(f"Failed to get loader for module {pathFilenameModule}")
-	module = importlib.util.module_from_spec(Don_Lapre_Road_to_Self_Improvement)
-
-	module.__name__ = "__main__"
-	Don_Lapre_Road_to_Self_Improvement.loader.exec_module(module)
-
-	pathFilenameFoldsTotal = getPathFilenameFoldsTotal(listDimensionsTestCountFolds)
-	registrarRecordsTmpObject(pathFilenameFoldsTotal)
-	standardizedEqualTo(str(foldsTotalKnown[tuple(listDimensionsTestCountFolds)]), pathFilenameFoldsTotal.read_text().strip)
-
-def test_syntheticParallel(syntheticDispatcherFixture, listDimensionsTestParallelization: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]):
-	standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
-
-def test_syntheticSequential(syntheticDispatcherFixture, listDimensionsTestCountFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]):
-	standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestCountFolds)], countFolds, listDimensionsTestCountFolds)