mapFolding 0.3.12__py3-none-any.whl → 0.4.0__py3-none-any.whl

tests/test_tasks.py

@@ -1,44 +1,44 @@
 from tests.conftest import *
+from typing import List, Dict, Literal, Tuple
 import pytest
-from typing import List, Dict, Literal, Tuple, Any
 
 # TODO add a test. `C` = number of logical cores available. `n = C + 1`. Ensure that `[2,n]` is computed correctly.
 # Or, probably smarter: limit the number of cores, then run a test with C+1.
 
 def test_algorithmSourceParallel(listDimensionsTestParallelization: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int], useAlgorithmDirectly: None) -> None:
-    standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
+	standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
 
 def test_countFoldsComputationDivisionsInvalid(listDimensionsTestFunctionality: List[int]) -> None:
-    standardizedEqualTo(ValueError, countFolds, listDimensionsTestFunctionality, None, {"wrong": "value"})
+	standardizedEqualTo(ValueError, countFolds, listDimensionsTestFunctionality, None, {"wrong": "value"})
 
 def test_countFoldsComputationDivisionsMaximum(listDimensionsTestParallelization: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]) -> None:
-    standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
+	standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
 
 @pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_defineConcurrencyLimit())
 def test_defineConcurrencyLimit(nameOfTest: str, callablePytest: Callable[[], None]) -> None:
-    callablePytest()
+	callablePytest()
 
-# @pytest.mark.parametrize("CPUlimitParameter", [{"invalid": True}, ["weird"]])
-# def test_countFolds_cpuLimitOopsie(listDimensionsTestFunctionality: List[int], CPUlimitParameter: Dict[str, bool] | List[str]) -> None:
-#     standardizedEqualTo((AttributeError or ValueError), countFolds, listDimensionsTestFunctionality, None, 'cpu', CPUlimitParameter)
+@pytest.mark.parametrize("CPUlimitParameter", [{"invalid": True}, ["weird"]])
+def test_countFolds_cpuLimitOopsie(listDimensionsTestFunctionality: List[int], CPUlimitParameter: Dict[str, bool] | List[str]) -> None:
+	standardizedEqualTo(ValueError, countFolds, listDimensionsTestFunctionality, None, 'cpu', CPUlimitParameter)
 
 @pytest.mark.parametrize("computationDivisions, concurrencyLimit, listDimensions, expectedTaskDivisions", [
-    (None, 4, [9, 11], 0),
-    ("maximum", 4, [7, 11], 77),
-    ("cpu", 4, [3, 7], 4),
-    (["invalid"], 4, [19, 23], ValueError),
-    (20, 4, [3,5], ValueError)
+	(None, 4, [9, 11], 0),
+	("maximum", 4, [7, 11], 77),
+	("cpu", 4, [3, 7], 4),
+	(["invalid"], 4, [19, 23], ValueError),
+	(20, 4, [3,5], ValueError)
 ])
 def test_getTaskDivisions(computationDivisions: None | List[str] | Literal['maximum'] | Literal['cpu'] | Literal[20], concurrencyLimit: Literal[4], listDimensions: List[int], expectedTaskDivisions: type[ValueError] | Literal[0] | Literal[77] | Literal[4]) -> None:
-    standardizedEqualTo(expectedTaskDivisions, getTaskDivisions, computationDivisions, concurrencyLimit, None, listDimensions)
+	standardizedEqualTo(expectedTaskDivisions, getTaskDivisions, computationDivisions, concurrencyLimit, None, listDimensions)
 
 @pytest.mark.parametrize("expected,parameter", [
-    (2, "2"),  # string
-    (ValueError, [4]),  # list
-    (ValueError, (2,)), # tuple
-    (ValueError, {2}),  # set
-    (ValueError, {"cores": 2}),  # dict
+	(2, "2"),  # string
+	(ValueError, [4]),  # list
+	(ValueError, (2,)), # tuple
+	(ValueError, {2}),  # set
+	(ValueError, {"cores": 2}),  # dict
 ])
 def test_setCPUlimitMalformedParameter(expected: type[ValueError] | Literal[2], parameter: List[int] | Tuple[int] | set[int] | Dict[str, int] | Literal['2']) -> None:
-    """Test that invalid CPUlimit types are properly handled."""
-    standardizedEqualTo(expected, setCPUlimit, parameter)
+	"""Test that invalid CPUlimit types are properly handled."""
+	standardizedEqualTo(expected, setCPUlimit, parameter)

tests/test_types.py

@@ -1,5 +1,5 @@
 """Type checking tests for mapFolding package."""
 
 def test_static_typing() -> None:
-    """This is a placeholder. pytest-mypy will run type checking automatically."""
-    pass
+	"""This is a placeholder. pytest-mypy will run type checking automatically."""
+	pass

mapFolding/someAssemblyRequired/synthesizeNumbaHardcoding.py

@@ -1,188 +0,0 @@
-from synthesizeNumba import *
-
-def makeNumbaOptimizedFlow(listCallablesInline: List[str], callableDispatcher: Optional[str] = None, algorithmSource: Optional[ModuleType] = None) -> None:
-    if not algorithmSource:
-        algorithmSource = getAlgorithmSource()
-
-    formatModuleNameDEFAULT = "numba_{callableTarget}"
-
-    # When I am a more competent programmer, I will make getPathFilenameWrite dependent on makeAstImport or vice versa,
-    # so the name of the physical file doesn't get out of whack with the name of the logical module.
-    def getPathFilenameWrite(callableTarget: str
-                            , pathWrite: Optional[pathlib.Path] = None
-                            , formatFilenameWrite: Optional[str] = None
-                            ) -> pathlib.Path:
-        if not pathWrite:
-            pathWrite = getPathSyntheticModules()
-        if not formatFilenameWrite:
-            formatFilenameWrite = formatModuleNameDEFAULT + '.py'
-
-        pathFilename = pathWrite  / formatFilenameWrite.format(callableTarget=callableTarget)
-        return pathFilename
-
-    def makeAstImport(callableTarget: str
-                        , packageName: Optional[str] = None
-                        , subPackageName: Optional[str] = None
-                        , moduleName: Optional[str] = None
-                        , astNodeLogicalPathThingy: Optional[ast.AST] = None
-                        ) -> ast.ImportFrom:
-        """Creates import AST node for synthetic modules."""
-        if astNodeLogicalPathThingy is None:
-            if packageName is None:
-                packageName = myPackageNameIs
-            if subPackageName is None:
-                subPackageName = moduleOfSyntheticModules
-            if moduleName is None:
-                moduleName = formatModuleNameDEFAULT.format(callableTarget=callableTarget)
-            module=f'{packageName}.{subPackageName}.{moduleName}'
-        else:
-            module = str(astNodeLogicalPathThingy)
-        return ast.ImportFrom(
-            module=module,
-            names=[ast.alias(name=callableTarget, asname=None)],
-            level=0
-        )
-
-    listStuffYouOughtaKnow: List[youOughtaKnow] = []
-
-    for callableTarget in listCallablesInline:
-        pythonSource = inspect.getsource(algorithmSource)
-        parametersNumba = None
-        unpackArrays = False
-        match callableTarget:
-            case 'countParallel':
-                parametersNumba = parametersNumbaSuperJitParallel
-            case 'countSequential':
-                parametersNumba = parametersNumbaSuperJit
-                unpackArrays = True
-            case 'countInitialize':
-                parametersNumba = parametersNumbaDEFAULT
-        pythonSource = inlineOneCallable(pythonSource, callableTarget, parametersNumba, unpackArrays)
-        if not pythonSource:
-            raise Exception("Pylance, OMG! The sky is falling!")
-
-        pathFilename = getPathFilenameWrite(callableTarget)
-
-        listStuffYouOughtaKnow.append(youOughtaKnow(
-            callableSynthesized=callableTarget,
-            pathFilenameForMe=pathFilename,
-            astForCompetentProgrammers=makeAstImport(callableTarget)
-        ))
-        pythonSource = autoflake.fix_code(pythonSource, ['mapFolding', 'numba', 'numpy'])
-        pathFilename.write_text(pythonSource)
-
-    # Generate dispatcher if requested
-    if callableDispatcher:
-        pythonSource = inspect.getsource(algorithmSource)
-        pythonSource = makeDispatcherNumba(pythonSource, callableDispatcher, listStuffYouOughtaKnow)
-        if not pythonSource:
-            raise FREAKOUT
-
-        pathFilename = getPathFilenameWrite(callableDispatcher)
-
-        listStuffYouOughtaKnow.append(youOughtaKnow(
-            callableSynthesized=callableDispatcher,
-            pathFilenameForMe=pathFilename,
-            astForCompetentProgrammers=makeAstImport(callableDispatcher)
-        ))
-        pythonSource = autoflake.fix_code(pythonSource, ['mapFolding', 'numba', 'numpy'])
-        pathFilename.write_text(pythonSource)
-
-def writeJobNumba(listDimensions: Sequence[int], callableTarget: str, algorithmSource: ModuleType, parametersNumba: Optional[ParametersNumba]=None, pathFilenameWriteJob: Optional[Union[str, os.PathLike[str]]] = None, **keywordArguments: Optional[Any]) -> pathlib.Path:
-    """ Parameters: **keywordArguments: most especially for `computationDivisions` if you want to make a parallel job. Also `CPUlimit`. """
-    """Notes about the existing logic:
-    - the synthesized module must run well as a standalone interpreted Python script
-    - `writeJobNumba` synthesizes a parameter-specific module by starting with code synthesized by `makeNumbaOptimizedFlow`, which improves the optimization
-    - similarly, `writeJobNumba` should be a solid foundation for more optimizations, most especially compiling to a standalone executable, but the details of the next optimization step are unknown
-    - the minimum runtime (on my computer) to compute a value unknown to mathematicians is 26 hours, therefore, we ant to ensure the value is seen by the user, but we must have ultra-light overhead.
-    - perf_counter is for testing. When I run a real job, I delete those lines
-    - avoid `with` statement
-    """
-    stateJob = makeStateJob(listDimensions, writeJob=False, **keywordArguments)
-    pythonSource = inspect.getsource(algorithmSource)
-    astModule = ast.parse(pythonSource)
-
-    allImports = UniversalImportTracker()
-
-    for statement in astModule.body:
-        if isinstance(statement, (ast.Import, ast.ImportFrom)):
-            allImports.addAst(statement)
-
-    FunctionDefTarget = next((node for node in astModule.body if isinstance(node, ast.FunctionDef) and node.name == callableTarget), None)
-    if not FunctionDefTarget: raise ValueError(f"I received `{callableTarget=}` and {algorithmSource.__name__=}, but I could not find that function in that source.")
-
-    for pirateScowl in FunctionDefTarget.args.args.copy():
-        match pirateScowl.arg:
-            case 'my':
-                FunctionDefTarget, allImports = evaluate_argIn_body(FunctionDefTarget, pirateScowl, stateJob[pirateScowl.arg], ['taskIndex', 'dimensionsTotal'], allImports)
-            case 'track':
-                FunctionDefTarget, allImports = evaluateArrayIn_body(FunctionDefTarget, pirateScowl, stateJob[pirateScowl.arg], allImports)
-            # TODO remove this after implementing `unrollWhileLoop`
-            case 'connectionGraph':
-                FunctionDefTarget, allImports = moveArrayTo_body(FunctionDefTarget, pirateScowl, stateJob[pirateScowl.arg], allImports)
-            case 'gapsWhere':
-                FunctionDefTarget, allImports = moveArrayTo_body(FunctionDefTarget, pirateScowl, stateJob[pirateScowl.arg], allImports)
-            case 'foldGroups':
-                FunctionDefTarget = removeIdentifierFrom_body(FunctionDefTarget, pirateScowl)
-
-    # Move function parameters to the function body,
-    # initialize identifiers with their state types and values,
-    # and replace static-valued identifiers with their values.
-    FunctionDefTarget, allImports = evaluateAnnAssignIn_body(FunctionDefTarget, allImports)
-    FunctionDefTarget = astNameToAstConstant(FunctionDefTarget, 'dimensionsTotal', int(stateJob['my'][indexMy.dimensionsTotal]))
-    FunctionDefTarget = astObjectToAstConstant(FunctionDefTarget, 'foldGroups[-1]', int(stateJob['foldGroups'][-1]))
-
-    FunctionDefTarget = unrollWhileLoop(FunctionDefTarget, 'indexDimension', stateJob['my'][indexMy.dimensionsTotal], stateJob['connectionGraph'])
-
-    FunctionDefTarget, allImports = addReturnJobNumba(FunctionDefTarget, stateJob, allImports)
-    FunctionDefTarget, allImports = makeDecoratorJobNumba(FunctionDefTarget, allImports, parametersNumba)
-
-    pathFilenameFoldsTotal = getPathFilenameFoldsTotal(stateJob['mapShape'])
-    # TODO consider: 1) launcher is a function, 2) if __name__ calls the launcher function, and 3) the launcher is "jitted", even just a light jit, then 4) `FunctionDefTarget` could be superJit.
-    astLauncher = makeLauncherJobNumba(FunctionDefTarget.name, pathFilenameFoldsTotal)
-
-    astImports = allImports.makeListAst()
-
-    astModule = ast.Module(body=cast(List[ast.stmt], astImports + [FunctionDefTarget] + [astLauncher]), type_ignores=[])
-    ast.fix_missing_locations(astModule)
-
-    pythonSource = ast.unparse(astModule)
-    pythonSource = autoflake.fix_code(pythonSource, ['mapFolding', 'numba', 'numpy'])
-
-    if pathFilenameWriteJob is None:
-        filename = getFilenameFoldsTotal(stateJob['mapShape'])
-        pathRoot = getPathJobRootDEFAULT()
-        pathFilenameWriteJob = pathlib.Path(pathRoot, pathlib.Path(filename).stem, pathlib.Path(filename).with_suffix('.py'))
-    else:
-        pathFilenameWriteJob = pathlib.Path(pathFilenameWriteJob)
-    pathFilenameWriteJob.parent.mkdir(parents=True, exist_ok=True)
-
-    pathFilenameWriteJob.write_text(pythonSource)
-    return pathFilenameWriteJob
-
-def mainBig():
-    setDatatypeModule('numpy', sourGrapes=True)
-    setDatatypeFoldsTotal('int64', sourGrapes=True)
-    setDatatypeElephino('uint8', sourGrapes=True)
-    setDatatypeLeavesTotal('uint8', sourGrapes=True)
-    listCallablesInline: List[str] = ['countInitialize', 'countParallel', 'countSequential']
-    Z0Z_setDatatypeModuleScalar('numba')
-    Z0Z_setDecoratorCallable('jit')
-    callableDispatcher = 'doTheNeedful'
-    makeNumbaOptimizedFlow(listCallablesInline, callableDispatcher)
-
-def mainSmall():
-    listDimensions = [6,6]
-    setDatatypeFoldsTotal('int64', sourGrapes=True)
-    setDatatypeElephino('uint8', sourGrapes=True)
-    setDatatypeLeavesTotal('uint8', sourGrapes=True)
-    from mapFolding.syntheticModules import numba_countSequential
-    algorithmSource: ModuleType = numba_countSequential
-    Z0Z_setDatatypeModuleScalar('numba')
-    Z0Z_setDecoratorCallable('jit')
-    writeJobNumba(listDimensions, 'countSequential', algorithmSource, parametersNumbaDEFAULT)
-
-if __name__ == '__main__':
-    mainBig()
-
-    mainSmall()

mapFolding-0.3.12.dist-info/METADATA

@@ -1,155 +0,0 @@
-Metadata-Version: 2.2
-Name: mapFolding
-Version: 0.3.12
-Summary: Count distinct ways to fold a map (or a strip of stamps)
-Author-email: Hunter Hogan <HunterHogan@pm.me>
-License: CC-BY-NC-4.0
-Project-URL: Donate, https://www.patreon.com/integrated
-Project-URL: Homepage, https://github.com/hunterhogan/mapFolding
-Project-URL: Repository, https://github.com/hunterhogan/mapFolding.git
-Keywords: A001415,A001416,A001417,A001418,A195646,folding,map folding,OEIS,stamp folding
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Education
-Classifier: Intended Audience :: End Users/Desktop
-Classifier: Intended Audience :: Other Audience
-Classifier: Intended Audience :: Science/Research
-Classifier: Natural Language :: English
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Topic :: Scientific/Engineering :: Mathematics
-Classifier: Typing :: Typed
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numba
-Requires-Dist: numpy
-Requires-Dist: Z0Z_tools
-Provides-Extra: testing
-Requires-Dist: autoflake; extra == "testing"
-Requires-Dist: more_itertools; extra == "testing"
-Requires-Dist: mypy; extra == "testing"
-Requires-Dist: pytest-cov; extra == "testing"
-Requires-Dist: pytest-env; extra == "testing"
-Requires-Dist: pytest-mypy; extra == "testing"
-Requires-Dist: pytest-xdist; extra == "testing"
-Requires-Dist: pytest; extra == "testing"
-Requires-Dist: python_minifier; extra == "testing"
-Requires-Dist: types-setuptools; extra == "testing"
-Requires-Dist: updateCitation; extra == "testing"
-
-# Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
-
-The function `mapFolding.countFolds()` counts distinct ways to fold maps and strips of stamps. The function accepts two or more dimensions:
-
-```python
-from mapFolding import countFolds
-foldsTotal = countFolds( [2,10] )
-```
-
-The directory [mapFolding/reference](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/reference) has
-
-- a verbatim transcription of Lunnon's "procedure" published in 1971 by _The Computer Journal_,
-- multiple referential versions of the procedure with explanatory comments including
-- [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.
-
-[![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/) [![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/pythonTests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/pythonTests.yml) [![Static Badge](https://img.shields.io/badge/stinkin'%20badges-don't%20need-b98e5e)](https://youtu.be/g6f_miE91mk&t=4) ![PyPI - Downloads](https://img.shields.io/pypi/dd/mapFolding) ![Static Badge](https://img.shields.io/badge/issues-I%20have%20them-brightgreen) ![GitHub repo size](https://img.shields.io/github/repo-size/hunterhogan/mapFolding)
-
-## Simple, easy usage based on OEIS IDs
-
-`mapFolding` directly implements some IDs from _The On-Line Encyclopedia of Integer Sequences_ ([BibTex](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/citations/oeis.bibtex) citation).
-
-### Usage: command line
-
-After installing (see below), `OEIS_for_n` will run a computation from the command line.
-
-```cmd
-(mapFolding) C:\apps\mapFolding> OEIS_for_n A001418 5
-186086600 distinct folding patterns.
-Time elapsed: 1.605 seconds
-```
-
-Use `getOEISids` to get the most up-to-date list of available OEIS IDs.
-
-```cmd
-(mapFolding) C:\apps\mapFolding> getOEISids
-
-Available OEIS sequences:
-  A001415: Number of ways of folding a 2 X n strip of stamps.
-  A001416: Number of ways of folding a 3 X n strip of stamps.
-  A001417: Number of ways of folding a 2 X 2 X ... X 2 n-dimensional map.
-  A001418: Number of ways of folding an n X n sheet of stamps.
-  A195646: Number of ways of folding a 3 X 3 X ... X 3 n-dimensional map.
-
-Usage examples:
-  Command line:
-    OEIS_for_n A001415 8
-  Python:
-    from mapFolding import oeisIDfor_n
-    foldsTotal = oeisIDfor_n('A001415', 8)
-```
-
-### Usage: Python module or REPL
-
-Use `mapFolding.oeisIDfor_n()` to compute a(n) for an OEIS ID.
-
-```python
-from mapFolding import oeisIDfor_n
-foldsTotal = oeisIDfor_n( 'A001418', 4 )
-```
-
-### An "advanced" and likely unnecessary feature: clear `mapFolding`'s cache of OEIS data
-
-Clear _The On-Line Encyclopedia of Integer Sequences_ data from the `mapFolding` cache:
-
-```sh
-(mapFolding) C:\apps\mapFolding> clearOEIScache
-Cache cleared from C:\apps\mapFolding\mapFolding\.cache
-```
-
-## Connections to "Multi-dimensional map-folding" by W. F. Lunnon
-
-### 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](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`](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](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/citations/jOEIS.bibtex) citation) says about the Java code:
-
-```java
-/**
- * A001415 Number of ways of folding a 2 X n strip of stamps.
- * @author Fred Lunnon (ALGOL68, C versions)
- * @author Sean A. Irvine (Java port)
- */
-...
-  // Implements algorithm as described in "Multi-dimensional map-folding",
-  // by W. F. Lunnon, The Computer J, 14, 1, pp. 75--80.  Note the original
-  // paper contains a few omissions, so this actual code is based on a C
-  // implementation by Fred Lunnon.
-```
-
-## Map-folding Video
-
-~~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](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)
-
-## Installation
-
-```sh
-pip install mapFolding
-```
-
-## My recovery
-
-[![Static Badge](https://img.shields.io/badge/2011_August-Homeless_since-blue?style=flat)](https://HunterThinks.com/support)
-[![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UC3Gx7kz61009NbhpRtPP7tw)](https://www.youtube.com/@HunterHogan)
-
-[![CC-BY-NC-4.0](https://github.com/hunterhogan/mapFolding/blob/main/CC-BY-NC-4.0.svg)](https://creativecommons.org/licenses/by-nc/4.0/)

mapFolding-0.3.12.dist-info/RECORD

@@ -1,40 +0,0 @@
-mapFolding/__init__.py,sha256=XYw6cd3gQLFxoMuSSHwScp9-uFUU5B22Edy2pHNULJ8,1384
-mapFolding/basecamp.py,sha256=DISWQIzAF7o7WPUn2QZxMu3Ruwc0zkVPgceeUTUcfqo,3988
-mapFolding/beDRY.py,sha256=Gsj7NEBztbPoKszPibhW6pO9xwjAIPgaW411A_Quwz8,18654
-mapFolding/oeis.py,sha256=2kFIAnBu0Bs4rHceXqs1RyyEBM6A_5fR5562B4ShxVg,12311
-mapFolding/theDao.py,sha256=qzZgXqI68NeKevMNZSFTnar4NsyploGTl-_Wwo8P-2s,14274
-mapFolding/theSSOT.py,sha256=hl6VUR3P7e6JF3L4rHI_icnmNR1gJJUAI2rCvlQmCDs,10577
-mapFolding/theSSOTnumba.py,sha256=SXPa9Qkr0IUFBb3k5__088IAS0imWHG8Aui2S27XbuE,5689
-mapFolding/reference/flattened.py,sha256=6blZ2Y9G8mu1F3gV8SKndPE398t2VVFlsgKlyeJ765A,16538
-mapFolding/reference/hunterNumba.py,sha256=HWndRgsajOf76rbb2LDNEZ6itsdYbyV-k3wgOFjeR6c,7104
-mapFolding/reference/irvineJavaPort.py,sha256=Sj-63Z-OsGuDoEBXuxyjRrNmmyl0d7Yz_XuY7I47Oyg,4250
-mapFolding/reference/jax.py,sha256=rojyK80lOATtbzxjGOHWHZngQa47CXCLJHZwIdN2MwI,14955
-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
-mapFolding/someAssemblyRequired/__init__.py,sha256=3JnAKXfaYPtmxV_4AnZ6KpCosT_0GFV5Nw7K8sz4-Uo,34
-mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=FtJzw2pZS3A4NimWdZsegXaU-vKeCw8m67kcfb5wvGM,894
-mapFolding/someAssemblyRequired/makeJob.py,sha256=2RtRAHBMDAiOsJpnj1-J1Yso3beQu5hk8bUfgE367Zs,2592
-mapFolding/someAssemblyRequired/synthesizeModuleJAX.py,sha256=TU8lgoMr77pctvvmlfbT-XstQk4j6Jo8JcIuvAiCuMU,1316
-mapFolding/someAssemblyRequired/synthesizeNumba.py,sha256=6wQnKLj2hbj-z4enypYoDpS6LcrE6lMDYUQ8eXquv_o,33476
-mapFolding/someAssemblyRequired/synthesizeNumbaHardcoding.py,sha256=aOATx1_cUcd7pb6YhdDe9ydL0QB6538NoFgyPKXzYpg,9994
-mapFolding/syntheticModules/numba_countInitialize.py,sha256=Cpk3HETqlQhyX431RzmvBSgKOx7nX9ZC4iCyBYHldMA,4274
-mapFolding/syntheticModules/numba_countParallel.py,sha256=5qrYl8InirBjzQKQh9eny7ajCU-pHk-oZS11alOxhJs,5517
-mapFolding/syntheticModules/numba_countSequential.py,sha256=oMJ9W_ob9sIE-7xfFkFCjG83MeylJJCjmL3_xWHMUdk,3732
-mapFolding/syntheticModules/numba_doTheNeedful.py,sha256=xbKeYWACpbVMNitWPQeTr8l-YY6Y228Lu_JRDjsAPfE,1369
-tests/__init__.py,sha256=eg9smg-6VblOr0kisM40CpGnuDtU2JgEEWGDTFVOlW8,57
-tests/conftest.py,sha256=tGRYkHfwVKGoMklBSQiTD8cTu-QL1wUSZd-52Xlnm50,7676
-tests/conftest_tmpRegistry.py,sha256=0XpGe7s2aJcjdEAqKs10vceW0_JAaK-Rp1UoPaL-BIo,2450
-tests/conftest_uniformTests.py,sha256=2v9UJbKgbrus3UyWXsanEHLksBskbnP0MD8iKVPaIBo,2178
-tests/test_oeis.py,sha256=F89HJ27y54NXcR2wMeBS4ea6R7EaEqpF_GkcU-BrsK4,5694
-tests/test_other.py,sha256=UpS0_WUfWA3wONuZwip5AMmzNmmBwYD7reQDZ9ziL_o,12224
-tests/test_tasks.py,sha256=ap_tKjHUN95vjzKo3xzBAQ3kMbdMJ_XXbOv9YIBJ5pY,2826
-tests/test_types.py,sha256=HklNCGThFiqQ89AOMkE7YkcfAPiZE32DpD3GMDUPQVc,177
-mapFolding-0.3.12.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-mapFolding-0.3.12.dist-info/METADATA,sha256=y4-lXqgLwjgfGI3mlRHcNsaz3VjiGAsF3RpIFNLcj7g,7785
-mapFolding-0.3.12.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapFolding-0.3.12.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapFolding-0.3.12.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapFolding-0.3.12.dist-info/RECORD,,

tests/conftest_tmpRegistry.py

@@ -1,62 +0,0 @@
-from typing import Any, Generator, Set
-import pathlib
-import pytest
-import shutil
-import uuid
-
-# 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."""
-    # TODO I got rid of this shit. how the fuck is it back?
-    # 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 pathFilenameFoldsTotalTesting(pathTempTesting: pathlib.Path) -> pathlib.Path:
-    return pathTempTesting.joinpath("foldsTotalTest.txt")

tests/conftest_uniformTests.py

@@ -1,53 +0,0 @@
-from typing import Any, Callable, Sequence, Type, Union
-import pytest
-
-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}"