mapFolding 0.2.6__tar.gz → 0.3.0__tar.gz

{mapfolding-0.2.6 → mapfolding-0.3.0}/PKG-INFO

@@ -1,24 +1,40 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.2.6
+Version: 0.3.0
 Summary: Count 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
-Requires-Python: <3.13,>=3.10
+License: CC-BY-NC-4.0
+Project-URL: Homepage, https://github.com/hunterhogan/mapFolding
+Project-URL: Donate, https://www.patreon.com/integrated
+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.14,>=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: numba
 Requires-Dist: numpy
-Requires-Dist: Z0Z-tools
+Requires-Dist: Z0Z_tools
 Provides-Extra: benchmark
-Requires-Dist: pandas; extra == "benchmark"
-Requires-Dist: jupyter; extra == "benchmark"
 Requires-Dist: ipywidgets; extra == "benchmark"
+Requires-Dist: jupyter; extra == "benchmark"
+Requires-Dist: pandas; extra == "benchmark"
 Requires-Dist: tqdm; extra == "benchmark"
 Provides-Extra: testing
+Requires-Dist: more_itertools; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: pytest-env; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
+Requires-Dist: python_minifier; extra == "testing"
 
 # Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
 
@@ -40,7 +56,7 @@ The directory [mapFolding/reference](https://github.com/hunterhogan/mapFolding/b
 
 ## Simple, easy usage based on OEIS IDs
 
-`mapFolding` directly implements some IDs from _The On-Line Encyclopedia of Integer Sequences_.
+`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
 

{mapfolding-0.2.6 → mapfolding-0.3.0}/README.md

@@ -18,7 +18,7 @@ The directory [mapFolding/reference](https://github.com/hunterhogan/mapFolding/b
 
 ## Simple, easy usage based on OEIS IDs
 
-`mapFolding` directly implements some IDs from _The On-Line Encyclopedia of Integer Sequences_.
+`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
 

{mapfolding-0.2.6 → mapfolding-0.3.0/mapFolding}/mapFolding.egg-info/PKG-INFO

@@ -1,24 +1,40 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.2.6
+Version: 0.3.0
 Summary: Count 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
-Requires-Python: <3.13,>=3.10
+License: CC-BY-NC-4.0
+Project-URL: Homepage, https://github.com/hunterhogan/mapFolding
+Project-URL: Donate, https://www.patreon.com/integrated
+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.14,>=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: numba
 Requires-Dist: numpy
-Requires-Dist: Z0Z-tools
+Requires-Dist: Z0Z_tools
 Provides-Extra: benchmark
-Requires-Dist: pandas; extra == "benchmark"
-Requires-Dist: jupyter; extra == "benchmark"
 Requires-Dist: ipywidgets; extra == "benchmark"
+Requires-Dist: jupyter; extra == "benchmark"
+Requires-Dist: pandas; extra == "benchmark"
 Requires-Dist: tqdm; extra == "benchmark"
 Provides-Extra: testing
+Requires-Dist: more_itertools; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: pytest-env; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
+Requires-Dist: python_minifier; extra == "testing"
 
 # Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
 
@@ -40,7 +56,7 @@ The directory [mapFolding/reference](https://github.com/hunterhogan/mapFolding/b
 
 ## Simple, easy usage based on OEIS IDs
 
-`mapFolding` directly implements some IDs from _The On-Line Encyclopedia of Integer Sequences_.
+`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
 

mapfolding-0.3.0/mapFolding/mapFolding.egg-info/SOURCES.txt

@@ -0,0 +1,26 @@
+README.md
+pyproject.toml
+mapFolding/benchmarks/benchmarking.py
+mapFolding/mapFolding.egg-info/PKG-INFO
+mapFolding/mapFolding.egg-info/SOURCES.txt
+mapFolding/mapFolding.egg-info/dependency_links.txt
+mapFolding/mapFolding.egg-info/entry_points.txt
+mapFolding/mapFolding.egg-info/requires.txt
+mapFolding/mapFolding.egg-info/top_level.txt
+mapFolding/reference/flattened.py
+mapFolding/reference/hunterNumba.py
+mapFolding/reference/irvineJavaPort.py
+mapFolding/reference/jax.py
+mapFolding/reference/lunnan.py
+mapFolding/reference/lunnanNumpy.py
+mapFolding/reference/lunnanWhile.py
+mapFolding/reference/rotatedEntryPoint.py
+mapFolding/reference/total_countPlus1vsPlusN.py
+mapFolding/someAssemblyRequired/__init__.py
+mapFolding/someAssemblyRequired/countInitialize.py
+mapFolding/someAssemblyRequired/countParallel.py
+mapFolding/someAssemblyRequired/countSequential.py
+mapFolding/someAssemblyRequired/synthesizeModules.py
+tests/test_oeis.py
+tests/test_other.py
+tests/test_tasks.py

{mapfolding-0.2.6 → mapfolding-0.3.0/mapFolding}/mapFolding.egg-info/requires.txt

@@ -1,15 +1,17 @@
 numba
 numpy
-Z0Z-tools
+Z0Z_tools
 
 [benchmark]
-pandas
-jupyter
 ipywidgets
+jupyter
+pandas
 tqdm
 
 [testing]
+more_itertools
 pytest
 pytest-cov
 pytest-env
 pytest-xdist
+python_minifier

mapfolding-0.3.0/mapFolding/mapFolding.egg-info/top_level.txt

@@ -0,0 +1,4 @@
+benchmarks
+citations
+reference
+someAssemblyRequired

mapfolding-0.3.0/mapFolding/someAssemblyRequired/__init__.py

@@ -0,0 +1,3 @@
+from .countSequential import countSequential
+from .countParallel import countParallel
+from .countInitialize import countInitialize

mapfolding-0.3.0/mapFolding/someAssemblyRequired/countInitialize.py

@@ -0,0 +1,45 @@
+from mapFolding import indexMy, indexTrack
+import numba
+
+@numba.jit((numba.uint8[:,:,::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:,::1]), parallel=False, boundscheck=False, cache=True, error_model="numpy", fastmath=True, looplift=False, nogil=True, nopython=True)
+def countInitialize(connectionGraph, gapsWhere, my, track):
+    while my[7] > 0:
+        if my[7] <= 1 or track[1, 0] == 1:
+            my[1] = my[0]
+            my[3] = track[3, my[7] - 1]
+            my[4] = 0
+            while my[4] < my[0]:
+                if connectionGraph[my[4], my[7], my[7]] == my[7]:
+                    my[1] -= 1
+                else:
+                    my[8] = connectionGraph[my[4], my[7], my[7]]
+                    while my[8] != my[7]:
+                        gapsWhere[my[3]] = my[8]
+                        if track[2, my[8]] == 0:
+                            my[3] += 1
+                        track[2, my[8]] += 1
+                        my[8] = connectionGraph[my[4], my[7], track[1, my[8]]]
+                my[4] += 1
+            if not my[1]:
+                my[5] = 0
+                while my[5] < my[7]:
+                    gapsWhere[my[3]] = my[5]
+                    my[3] += 1
+                    my[5] += 1
+            my[6] = my[2]
+            while my[6] < my[3]:
+                gapsWhere[my[2]] = gapsWhere[my[6]]
+                if track[2, gapsWhere[my[6]]] == my[1]:
+                    my[2] += 1
+                track[2, gapsWhere[my[6]]] = 0
+                my[6] += 1
+        if my[7] > 0:
+            my[2] -= 1
+            track[0, my[7]] = gapsWhere[my[2]]
+            track[1, my[7]] = track[1, track[0, my[7]]]
+            track[1, track[0, my[7]]] = my[7]
+            track[0, track[1, my[7]]] = my[7]
+            track[3, my[7]] = my[2]
+            my[7] += 1
+        if my[2] > 0:
+            return

mapfolding-0.3.0/mapFolding/someAssemblyRequired/countParallel.py

@@ -0,0 +1,52 @@
+from mapFolding import indexMy, indexTrack
+import numba
+
+@numba.jit((numba.uint8[:,:,::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:,::1]), parallel=True, boundscheck=False, cache=True, error_model="numpy", fastmath=True, looplift=False, nogil=True, nopython=True)
+def countParallel(connectionGraph, foldGroups, gapsWherePARALLEL, myPARALLEL, trackPARALLEL):
+    for indexSherpa in numba.prange(myPARALLEL[9]):
+        gapsWhere = gapsWherePARALLEL.copy()
+        my = myPARALLEL.copy()
+        my[10] = indexSherpa
+        track = trackPARALLEL.copy()
+        groupsOfFolds: int = 0
+        while my[7] > 0:
+            if my[7] <= 1 or track[1, 0] == 1:
+                if my[7] > foldGroups[-1]:
+                    groupsOfFolds = groupsOfFolds + 1
+                else:
+                    my[1] = my[0]
+                    my[3] = track[3, my[7] - 1]
+                    my[4] = 0
+                    while my[4] < my[0]:
+                        if connectionGraph[my[4], my[7], my[7]] == my[7]:
+                            my[1] -= 1
+                        else:
+                            my[8] = connectionGraph[my[4], my[7], my[7]]
+                            while my[8] != my[7]:
+                                if my[7] != my[9] or my[8] % my[9] == my[10]:
+                                    gapsWhere[my[3]] = my[8]
+                                    if track[2, my[8]] == 0:
+                                        my[3] += 1
+                                    track[2, my[8]] += 1
+                                my[8] = connectionGraph[my[4], my[7], track[1, my[8]]]
+                        my[4] += 1
+                    my[6] = my[2]
+                    while my[6] < my[3]:
+                        gapsWhere[my[2]] = gapsWhere[my[6]]
+                        if track[2, gapsWhere[my[6]]] == my[1]:
+                            my[2] += 1
+                        track[2, gapsWhere[my[6]]] = 0
+                        my[6] += 1
+            while my[7] > 0 and my[2] == track[3, my[7] - 1]:
+                my[7] -= 1
+                track[1, track[0, my[7]]] = track[1, my[7]]
+                track[0, track[1, my[7]]] = track[0, my[7]]
+            if my[7] > 0:
+                my[2] -= 1
+                track[0, my[7]] = gapsWhere[my[2]]
+                track[1, my[7]] = track[1, track[0, my[7]]]
+                track[1, track[0, my[7]]] = my[7]
+                track[0, track[1, my[7]]] = my[7]
+                track[3, my[7]] = my[2]
+                my[7] += 1
+        foldGroups[my[10]] = groupsOfFolds

mapfolding-0.3.0/mapFolding/someAssemblyRequired/countSequential.py

@@ -0,0 +1,59 @@
+from mapFolding import indexMy, indexTrack
+import numba
+
+@numba.jit((numba.uint8[:,:,::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:,::1]), parallel=False, boundscheck=False, cache=True, error_model="numpy", fastmath=True, looplift=False, nogil=True, nopython=True)
+def countSequential(connectionGraph, foldGroups, gapsWhere, my, track):
+    doFindGaps = True
+    dimensionsTotal = my[indexMy.dimensionsTotal.value]
+    dimensionsUnconstrained = my[indexMy.dimensionsUnconstrained.value]
+    gap1ndex = my[indexMy.gap1ndex.value]
+    gap1ndexCeiling = my[indexMy.gap1ndexCeiling.value]
+    indexDimension = my[indexMy.indexDimension.value]
+    indexMiniGap = my[indexMy.indexMiniGap.value]
+    leaf1ndex = my[indexMy.leaf1ndex.value]
+    leafConnectee = my[indexMy.leafConnectee.value]
+    taskIndex = my[indexMy.taskIndex.value]
+    leafAbove = track[indexTrack.leafAbove.value]
+    leafBelow = track[indexTrack.leafBelow.value]
+    countDimensionsGapped = track[indexTrack.countDimensionsGapped.value]
+    gapRangeStart = track[indexTrack.gapRangeStart.value]
+    groupsOfFolds: int = 0
+    while leaf1ndex > 0:
+        if (doFindGaps := (leaf1ndex <= 1 or leafBelow[0] == 1)) and leaf1ndex > foldGroups[-1]:
+            groupsOfFolds = groupsOfFolds + 1
+        elif doFindGaps:
+            dimensionsUnconstrained = dimensionsTotal
+            gap1ndexCeiling = gapRangeStart[leaf1ndex - 1]
+            indexDimension = 0
+            while indexDimension < dimensionsTotal:
+                if connectionGraph[indexDimension, leaf1ndex, leaf1ndex] == leaf1ndex:
+                    dimensionsUnconstrained -= 1
+                else:
+                    leafConnectee = connectionGraph[indexDimension, leaf1ndex, leaf1ndex]
+                    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-0.2.6/mapFolding/someAssemblyRequired/inlineAfunction.py → mapfolding-0.3.0/mapFolding/someAssemblyRequired/synthesizeModules.py

@@ -1,20 +1,34 @@
-from mapFolding import indexMy, indexThe, indexTrack
+from mapFolding import indexMy, indexTrack, theDao, datatypeDefault, datatypeLarge, datatypeSmall
 import ast
-import copy
 import pathlib
+import inspect
+
+algorithmSource = theDao
+
+dictionaryDecorators={
+    'countInitialize':
+    f'@numba.jit((numba.{datatypeSmall}[:,:,::1], numba.{datatypeDefault}[::1], numba.{datatypeSmall}[::1], numba.{datatypeDefault}[:,::1]), parallel=False, boundscheck=False, cache=True, error_model="numpy", fastmath=True, looplift=False, nogil=True, nopython=True)\n',
+    'countParallel':
+    f'@numba.jit((numba.{datatypeSmall}[:,:,::1], numba.{datatypeLarge}[::1], numba.{datatypeDefault}[::1], numba.{datatypeSmall}[::1], numba.{datatypeDefault}[:,::1]), parallel=True, boundscheck=False, cache=True, error_model="numpy", fastmath=True, looplift=False, nogil=True, nopython=True)\n',
+    'countSequential':
+    f'@numba.jit((numba.{datatypeSmall}[:,:,::1], numba.{datatypeLarge}[::1], numba.{datatypeDefault}[::1], numba.{datatypeSmall}[::1], numba.{datatypeDefault}[:,::1]), parallel=False, boundscheck=False, cache=True, error_model="numpy", fastmath=True, looplift=False, nogil=True, nopython=True)\n',
+    }
 
 def getDictionaryEnumValues():
     dictionaryEnumValues = {}
-    for enumIndex in [indexMy, indexThe, indexTrack]:
+    for enumIndex in [indexMy, indexTrack]:
         for memberName, memberValue in enumIndex._member_map_.items():
             dictionaryEnumValues[f"{enumIndex.__name__}.{memberName}.value"] = memberValue.value
     return dictionaryEnumValues
 
 class RecursiveInlinerWithEnum(ast.NodeTransformer):
+    """Process AST nodes to inline functions and substitute enum values.
+    Also handles function decorators during inlining."""
+
     def __init__(self, dictionaryFunctions, dictionaryEnumValues):
         self.dictionaryFunctions = dictionaryFunctions
         self.dictionaryEnumValues = dictionaryEnumValues
-        self.processed = set()  # Track processed functions to avoid infinite recursion
+        self.processed = set()
 
     def inlineFunctionBody(self, functionName):
         if functionName in self.processed:
@@ -39,7 +53,7 @@ class RecursiveInlinerWithEnum(ast.NodeTransformer):
         callNode = self.generic_visit(node)
         if isinstance(callNode, ast.Call) and isinstance(callNode.func, ast.Name) and callNode.func.id in self.dictionaryFunctions:
             inlineDefinition = self.inlineFunctionBody(callNode.func.id)
-            if inlineDefinition and inlineDefinition.body:
+            if (inlineDefinition and inlineDefinition.body):
                 lastStmt = inlineDefinition.body[-1]
                 if isinstance(lastStmt, ast.Return) and lastStmt.value is not None:
                     return self.visit(lastStmt.value)
@@ -78,20 +92,21 @@ def findRequiredImports(node):
 
 def generateImports(requiredImports):
     """Generate import statements based on required modules."""
-    importStatements = []
+    importStatements = {'import numba', 'from mapFolding import indexMy, indexTrack'}
 
-    # Map of module names to their import statements
     importMapping = {
         'numba': 'import numba',
     }
 
     for moduleName in sorted(requiredImports):
         if moduleName in importMapping:
-            importStatements.append(importMapping[moduleName])
+            importStatements.add(importMapping[moduleName])
 
     return '\n'.join(importStatements)
 
-def inlineFunctions(sourceCode, targetFunctionName, dictionaryEnumValues):
+def inlineFunctions(sourceCode, targetFunctionName, dictionaryEnumValues, skipEnum=False):
+    if skipEnum:
+        dictionaryEnumValues = {}
     dictionaryParsed = ast.parse(sourceCode)
     dictionaryFunctions = {
         element.name: element
@@ -103,50 +118,70 @@ def inlineFunctions(sourceCode, targetFunctionName, dictionaryEnumValues):
     nodeInlined = nodeInliner.visit(nodeTarget)
     ast.fix_missing_locations(nodeInlined)
 
-    # Generate imports
     requiredImports = findRequiredImports(nodeInlined)
     importStatements = generateImports(requiredImports)
 
-    # Combine imports with inlined code
-    inlinedCode = importStatements + '\n\n' + ast.unparse(ast.Module(body=[nodeInlined], type_ignores=[]))
+    lineNumbaDecorator = dictionaryDecorators[targetFunctionName]
+    inlinedCode = importStatements + '\n\n' + lineNumbaDecorator + ast.unparse(ast.Module(body=[nodeInlined], type_ignores=[]))
     return inlinedCode
 
+def unpackArrays(codeInlined: str, callableTarget: str) -> str:
+    dictionaryReplaceScalars = {
+        'my[indexMy.dimensionsTotal.value]': 'dimensionsTotal',
+        'my[indexMy.dimensionsUnconstrained.value]': 'dimensionsUnconstrained',
+        'my[indexMy.gap1ndex.value]': 'gap1ndex',
+        'my[indexMy.gap1ndexCeiling.value]': 'gap1ndexCeiling',
+        'my[indexMy.indexDimension.value]': 'indexDimension',
+        # 'my[indexMy.indexLeaf.value]': 'indexLeaf',
+        'my[indexMy.indexMiniGap.value]': 'indexMiniGap',
+        'my[indexMy.leaf1ndex.value]': 'leaf1ndex',
+        'my[indexMy.leafConnectee.value]': 'leafConnectee',
+        # 'my[indexMy.taskDivisions.value]': 'taskDivisions',
+        'my[indexMy.taskIndex.value]': 'taskIndex',
+        # 'foldGroups[-1]': 'leavesTotal',
+    }
+
+    dictionaryReplaceArrays = {
+        "track[indexTrack.leafAbove.value, ": 'leafAbove[',
+        "track[indexTrack.leafBelow.value, ": 'leafBelow[',
+        'track[indexTrack.countDimensionsGapped.value, ': 'countDimensionsGapped[',
+        'track[indexTrack.gapRangeStart.value, ': 'gapRangeStart[',
+    }
+
+    ImaIndent = "    "
+    linesInitialize = """"""
+
+    for find, replace in dictionaryReplaceScalars.items():
+        linesInitialize += f"{ImaIndent}{replace} = {find}\n"
+        codeInlined = codeInlined.replace(find, replace)
+
+    for find, replace in dictionaryReplaceArrays.items():
+        linesInitialize += f"{ImaIndent}{replace[0:-1]} = {find[0:-2]}]\n"
+        codeInlined = codeInlined.replace(find, replace)
+
+    ourGuyOnTheInside = "    doFindGaps = True\n"
+    linesInitialize = ourGuyOnTheInside + linesInitialize
+
+    codeInlined = codeInlined.replace(ourGuyOnTheInside, linesInitialize)
+
+    return codeInlined
+
 def Z0Z_inlineMapFolding():
     dictionaryEnumValues = getDictionaryEnumValues()
+    codeSource = inspect.getsource(algorithmSource)
+    pathFilenameAlgorithm = pathlib.Path(inspect.getfile(algorithmSource))
 
-    pathFilenameSource = pathlib.Path("/apps/mapFolding/mapFolding/lovelace.py")
-    codeSource = pathFilenameSource.read_text()
-
-    listCallables = [
-        'countInitialize',
-        'countParallel',
-        'countSequential',
-    ]
+    listCallables = [ 'countInitialize', 'countParallel', 'countSequential', ]
 
     listPathFilenamesDestination: list[pathlib.Path] = []
     for callableTarget in listCallables:
-        pathFilenameDestination = pathFilenameSource.parent / "someAssemblyRequired" / pathFilenameSource.with_stem(callableTarget).name
-        codeInlined = inlineFunctions(codeSource, callableTarget, dictionaryEnumValues)
-        pathFilenameDestination.write_text(codeInlined)
+        skipEnum = (callableTarget == 'countInitialize')
+        skipEnum = (callableTarget == 'countSequential')
+        pathFilenameDestination = pathFilenameAlgorithm.parent / "someAssemblyRequired" / pathFilenameAlgorithm.with_stem(callableTarget).name
+        codeInlined = inlineFunctions(codeSource, callableTarget, dictionaryEnumValues, skipEnum)
+        codeUnpacked = unpackArrays(codeInlined, callableTarget)
+        pathFilenameDestination.write_text(codeUnpacked)
         listPathFilenamesDestination.append(pathFilenameDestination)
 
-    listNoNumba = [
-        'countInitialize',
-        'countSequential',
-    ]
-
-    listPathFilenamesNoNumba = []
-    for pathFilename in listPathFilenamesDestination:
-        if pathFilename.stem in listNoNumba:
-            pathFilenameNoNumba = pathFilename.with_name(pathFilename.stem + 'NoNumba' + pathFilename.suffix)
-        else:
-            continue
-        codeNoNumba = pathFilename.read_text()
-        for codeLine in copy.copy(codeNoNumba.splitlines()):
-            if 'numba' in codeLine:
-                codeNoNumba = codeNoNumba.replace(codeLine, '')
-        pathFilenameNoNumba.write_text(codeNoNumba)
-        listPathFilenamesNoNumba.append(pathFilenameNoNumba)
-
 if __name__ == '__main__':
     Z0Z_inlineMapFolding()

mapfolding-0.3.0/pyproject.toml

@@ -0,0 +1,78 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+authors = [{ name = "Hunter Hogan", email = "HunterHogan@pm.me" }]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Console",
+    "Intended Audience :: Education",
+    "Intended Audience :: End Users/Desktop",
+    "Intended Audience :: Other Audience",
+    "Intended Audience :: Science/Research",
+    "Natural Language :: English",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Topic :: Scientific/Engineering :: Mathematics",
+    "Typing :: Typed",
+]
+dependencies = ["numba", "numpy", "Z0Z_tools"]
+description = "Count distinct ways to fold a map (or a strip of stamps)"
+keywords = [
+    "A001415",
+    "A001416",
+    "A001417",
+    "A001418",
+    "A195646",
+    "folding",
+    "map folding",
+    "OEIS",
+    "stamp folding",
+]
+license = { text = "CC-BY-NC-4.0" }
+name = "mapFolding"
+optional-dependencies = { benchmark = [
+    "ipywidgets",
+    "jupyter",
+    "pandas",
+    "tqdm",
+], testing = [
+    "more_itertools",
+    "pytest",
+    "pytest-cov",
+    "pytest-env",
+    "pytest-xdist",
+    "python_minifier",
+] }
+readme = { file = "README.md", content-type = "text/markdown" }
+requires-python = ">=3.10,<3.14"
+scripts = { getOEISids = "mapFolding.oeis:getOEISids", clearOEIScache = "mapFolding.oeis:clearOEIScache", OEIS_for_n = "mapFolding.oeis:OEIS_for_n" }
+urls = { Homepage = "https://github.com/hunterhogan/mapFolding", Donate = "https://www.patreon.com/integrated" }
+version = "0.3.0"
+
+[tool.coverage]
+report = { exclude_lines = [
+    "if TYPE_CHECKING:",
+    "if __name__ == \"__main__\":",
+    "numba.jit_module",
+], ignore_errors = false }
+run = { branch = true, concurrency = [
+    "multiprocessing",
+    "thread",
+], data_file = "tests/coverage/.coverage", omit = [
+    "tests/*",
+    "Z0Z_*",
+], parallel = true, source = [
+    "mapFolding",
+] }
+xml = { output = "tests/coverage/coverage.xml" }
+
+[tool.pytest.ini_options]
+addopts = ["--color=yes", "-n 4"]
+# env = ["NUMBA_JIT_COVERAGE=1"]
+env = ["NUMBA_DISABLE_JIT=1"]
+testpaths = ["tests"]
+
+[tool.setuptools.packages.find]
+where = ["mapFolding"]

{mapfolding-0.2.6 → mapfolding-0.3.0}/tests/test_other.py

@@ -1,4 +1,5 @@
 import pathlib
+from Z0Z_tools import intInnit
 from tests.conftest import *
 from tests.pythons_idiotic_namespace import *
 from typing import List, Optional, Any
@@ -92,15 +93,13 @@ def test_countFolds_writeFoldsTotal(
     # standardComparison(foldsValue, lambda: returned)  # Check return value
     standardComparison(str(foldsTotalExpected), lambda: (pathTempTesting / filenameFoldsTotalExpected).read_text())  # Check file content
 
-def test_intInnit() -> None:
-    """Test integer parsing using the test suite generator."""
-    for testName, testFunction in makeTestSuiteIntInnit(intInnit).items():
-        testFunction()
+@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_intInnit())
+def testIntInnit(nameOfTest, callablePytest):
+    callablePytest()
 
-def test_oopsieKwargsie() -> None:
-    """Test handling of unexpected keyword arguments."""
-    for testName, testFunction in makeTestSuiteOopsieKwargsie(oopsieKwargsie).items():
-        testFunction()
+@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_oopsieKwargsie())
+def testOopsieKwargsie(nameOfTest, callablePytest):
+    callablePytest()
 
 @pytest.mark.parametrize("CPUlimit, expectedLimit", [
     (None, numba.config.NUMBA_DEFAULT_NUM_THREADS), # type: ignore

{mapfolding-0.2.6 → mapfolding-0.3.0}/tests/test_tasks.py

@@ -1,4 +1,4 @@
-from .conftest import *
+from tests.conftest import *
 import pytest
 from typing import List, Dict, Tuple
 
@@ -8,14 +8,13 @@ from typing import List, Dict, Tuple
 def test_countFolds_computationDivisions(listDimensionsTest_countFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]) -> None:
     standardComparison(foldsTotalKnown[tuple(listDimensionsTest_countFolds)], countFolds, listDimensionsTest_countFolds, None, 'maximum')
 
-def test_defineConcurrencyLimit() -> None:
-    testSuite = makeTestSuiteConcurrencyLimit(defineConcurrencyLimit)
-    for testName, testFunction in testSuite.items():
-        testFunction()
+@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_defineConcurrencyLimit())
+def testConcurrencyLimit(nameOfTest, callablePytest):
+    callablePytest()
 
-@pytest.mark.parametrize("CPUlimitParameter", [{"invalid": True}, ["weird"]])
-def test_countFolds_cpuLimitOopsie(listDimensionsTestFunctionality: List[int], CPUlimitParameter: Dict[str, bool] | List[str]) -> None:
-    standardComparison(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:
+#     standardComparison((AttributeError or ValueError), countFolds, listDimensionsTestFunctionality, None, 'cpu', CPUlimitParameter)
 
 def test_countFolds_invalid_computationDivisions(listDimensionsTestFunctionality: List[int]) -> None:
     standardComparison(ValueError, countFolds, listDimensionsTestFunctionality, None, {"wrong": "value"})