mapFolding 0.2.7__py3-none-any.whl → 0.3.1__py3-none-any.whl

{mapFolding-0.2.7.dist-info → mapFolding-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.2.7
+Version: 0.3.1
 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
@@ -29,10 +29,12 @@ 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)
 

mapFolding-0.3.1.dist-info/RECORD

@@ -0,0 +1,22 @@
+benchmarks/benchmarking.py,sha256=HD_0NSvuabblg94ftDre6LFnXShTe8MYj3hIodW-zV0,3076
+reference/flattened.py,sha256=6blZ2Y9G8mu1F3gV8SKndPE398t2VVFlsgKlyeJ765A,16538
+reference/hunterNumba.py,sha256=HWndRgsajOf76rbb2LDNEZ6itsdYbyV-k3wgOFjeR6c,7104
+reference/irvineJavaPort.py,sha256=Sj-63Z-OsGuDoEBXuxyjRrNmmyl0d7Yz_XuY7I47Oyg,4250
+reference/jax.py,sha256=rojyK80lOATtbzxjGOHWHZngQa47CXCLJHZwIdN2MwI,14955
+reference/lunnan.py,sha256=XEcql_gxvCCghb6Or3qwmPbn4IZUbZTaSmw_fUjRxZE,5037
+reference/lunnanNumpy.py,sha256=HqDgSwTOZA-G0oophOEfc4zs25Mv4yw2aoF1v8miOLk,4653
+reference/lunnanWhile.py,sha256=7NY2IKO5XBgol0aWWF_Fi-7oTL9pvu_z6lB0TF1uVHk,4063
+reference/rotatedEntryPoint.py,sha256=z0QyDQtnMvXNj5ntWzzJUQUMFm1-xHGLVhtYzwmczUI,11530
+reference/total_countPlus1vsPlusN.py,sha256=usenM8Yn_G1dqlPl7NKKkcnbohBZVZBXTQRm2S3_EDA,8106
+someAssemblyRequired/__init__.py,sha256=nDtS5UFMKN-F5pTp0qKA0J0I-XR3n3OFxV2bosieBu8,131
+someAssemblyRequired/countInitialize.py,sha256=hwo9SW_IvB-bgKNfaGvjl40yayFEmZZmeywiEMDSQDw,1840
+someAssemblyRequired/countParallel.py,sha256=4MfRYLBA2IBxRiXb04voNcxSDAtmZOe7lrji1c3kFls,2560
+someAssemblyRequired/countSequential.py,sha256=8YILeL3rflOhW1ts78ZSgYkPYXMPfusYOPkPtf8Xa3M,3217
+someAssemblyRequired/getLLVMforNoReason.py,sha256=FtJzw2pZS3A4NimWdZsegXaU-vKeCw8m67kcfb5wvGM,894
+someAssemblyRequired/synthesizeJob.py,sha256=xrcEW-QQPKogYh3O0TaRBSZEd8HgMLtXBTeS0Ps_pns,7500
+someAssemblyRequired/synthesizeModules.py,sha256=4mDgzfhm36zIDT8LlcPZzfGfoxRi1Z5rb4rgkAWVtkQ,8625
+mapFolding-0.3.1.dist-info/METADATA,sha256=sDKpDeoFSg3rgNkz20rj9Ec3FL-_wVEv2svn8RuwFfI,7526
+mapFolding-0.3.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapFolding-0.3.1.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapFolding-0.3.1.dist-info/top_level.txt,sha256=yHhQq-bIJhB4pZcof5hXDTIjan0nxcFuOEWb7gy1DuU,42
+mapFolding-0.3.1.dist-info/RECORD,,

reference/flattened.py

@@ -236,7 +236,7 @@ class computationState(TypedDict):
     track: NDArray[integer[Any]]
 
 dtypeLarge = numpy.int64
-dtypeDefault = dtypeLarge
+dtypeMedium = dtypeLarge
 
 def getLeavesTotal(listDimensions: Sequence[int]) -> int:
     """
@@ -284,7 +284,7 @@ def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrenc
     return taskDivisions
 
 def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optional[Type]) -> NDArray[integer[Any]]:
-    datatype = keywordArguments.get('datatype', dtypeDefault)
+    datatype = keywordArguments.get('datatype', dtypeMedium)
     mapShape = validateListDimensions(listDimensions)
     leavesTotal = getLeavesTotal(mapShape)
     arrayDimensions = numpy.array(mapShape, dtype=datatype)
@@ -317,14 +317,14 @@ def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optio
 
 def makeDataContainer(shape, datatype: Optional[Type] = None):
     if datatype is None:
-        datatype = dtypeDefault
+        datatype = dtypeMedium
     return numpy.zeros(shape, dtype=datatype)
 
 def outfitFoldings(listDimensions: Sequence[int], computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[bool, float, int]] = None, **keywordArguments: Optional[Type]) -> computationState:
-    datatypeDefault = keywordArguments.get('datatypeDefault', dtypeDefault)
+    datatypeMedium = keywordArguments.get('datatypeMedium', dtypeMedium)
     datatypeLarge = keywordArguments.get('datatypeLarge', dtypeLarge)
 
-    the = makeDataContainer(len(indexThe), datatypeDefault)
+    the = makeDataContainer(len(indexThe), datatypeMedium)
 
     mapShape = tuple(sorted(validateListDimensions(listDimensions)))
     the[indexThe.leavesTotal] = getLeavesTotal(mapShape)
@@ -333,11 +333,11 @@ def outfitFoldings(listDimensions: Sequence[int], computationDivisions: Optional
     the[indexThe.taskDivisions] = getTaskDivisions(computationDivisions, concurrencyLimit, CPUlimit, listDimensions)
 
     stateInitialized = computationState(
-        connectionGraph = makeConnectionGraph(mapShape, datatype=datatypeDefault),
+        connectionGraph = makeConnectionGraph(mapShape, datatype=datatypeMedium),
         foldsSubTotals = makeDataContainer(the[indexThe.leavesTotal], datatypeLarge),
         mapShape = mapShape,
         my = makeDataContainer(len(indexMy), datatypeLarge),
-        gapsWhere = makeDataContainer(int(the[indexThe.leavesTotal]) * int(the[indexThe.leavesTotal]) + 1, datatypeDefault),
+        gapsWhere = makeDataContainer(int(the[indexThe.leavesTotal]) * int(the[indexThe.leavesTotal]) + 1, datatypeMedium),
         the = the,
         track = makeDataContainer((len(indexTrack), the[indexThe.leavesTotal] + 1), datatypeLarge)
         )

reference/hunterNumba.py

@@ -19,7 +19,7 @@ def countFolds(listDimensions: List[int]) -> int:
     def integerLarge(value) -> numpy.uint64:
         return numpy.uint64(value)
 
-    dtypeDefault = numpy.uint8
+    dtypeMedium = numpy.uint8
     dtypeMaximum = numpy.uint16
 
     leavesTotal = integerSmall(1)
@@ -30,19 +30,19 @@ def countFolds(listDimensions: List[int]) -> int:
     """How to build a leaf connection graph, also called a "Cartesian Product Decomposition"
     or a "Dimensional Product Mapping", with sentinels:
     Step 1: find the cumulative product of the map's dimensions"""
-    cumulativeProduct = numpy.ones(dimensionsTotal + 1, dtype=dtypeDefault)
+    cumulativeProduct = numpy.ones(dimensionsTotal + 1, dtype=dtypeMedium)
     for dimension1ndex in range(1, dimensionsTotal + 1):
         cumulativeProduct[dimension1ndex] = cumulativeProduct[dimension1ndex - 1] * listDimensions[dimension1ndex - 1]
 
     """Step 2: for each dimension, create a coordinate system """
     """coordinateSystem[dimension1ndex, leaf1ndex] holds the dimension1ndex-th coordinate of leaf leaf1ndex"""
-    coordinateSystem = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1), dtype=dtypeDefault)
+    coordinateSystem = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1), dtype=dtypeMedium)
     for dimension1ndex in range(1, dimensionsTotal + 1):
         for leaf1ndex in range(1, leavesTotal + 1):
             coordinateSystem[dimension1ndex, leaf1ndex] = ((leaf1ndex - 1) // cumulativeProduct[dimension1ndex - 1]) % listDimensions[dimension1ndex - 1] + 1
 
     """Step 3: create a huge empty connection graph"""
-    connectionGraph = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1, leavesTotal + 1), dtype=dtypeDefault)
+    connectionGraph = numpy.zeros((dimensionsTotal + 1, leavesTotal + 1, leavesTotal + 1), dtype=dtypeMedium)
 
     """Step for... for... for...: fill the connection graph"""
     for dimension1ndex in range(1, dimensionsTotal + 1):
@@ -61,7 +61,7 @@ def countFolds(listDimensions: List[int]) -> int:
     leafBelow = numba.literally(1)
     countDimensionsGapped = numba.literally(2)
     gapRangeStart = numba.literally(3)
-    track = numpy.zeros((4, leavesTotal + 1), dtype=dtypeDefault)
+    track = numpy.zeros((4, leavesTotal + 1), dtype=dtypeMedium)
 
     gapsWhere = numpy.zeros(integerLarge(integerLarge(leavesTotal) * integerLarge(leavesTotal) + 1), dtype=dtypeMaximum)
 

reference/jax.py

@@ -5,7 +5,7 @@ from typing import List, Tuple
 import jax
 import jaxtyping
 
-dtypeDefault = jax.numpy.uint32
+dtypeMedium = jax.numpy.uint32
 dtypeMaximum = jax.numpy.uint32
 
 def countFolds(listDimensions: List[int]) -> int:
@@ -15,7 +15,7 @@ def countFolds(listDimensions: List[int]) -> int:
     d: int = len(listDimensions)
     import numpy
     D: numpy.ndarray = makeConnectionGraph(listDimensionsPositive)
-    connectionGraph = jax.numpy.asarray(D, dtype=dtypeDefault)
+    connectionGraph = jax.numpy.asarray(D, dtype=dtypeMedium)
     del listDimensionsPositive
 
     return foldingsJAX(n, d, connectionGraph)
@@ -191,10 +191,10 @@ def foldingsJAX(leavesTotal: jaxtyping.UInt32, dimensionsTotal: jaxtyping.UInt32
         return (leafAbove, leafBelow, allValues[2], gapRangeStart, gapsWhere, allValues[5], activeLeaf1ndex, activeGap1ndex)
 
     # Dynamic values
-    A = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeDefault)
-    B = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeDefault)
-    count = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeDefault)
-    gapter = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeDefault)
+    A = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeMedium)
+    B = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeMedium)
+    count = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeMedium)
+    gapter = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeMedium)
     gap = jax.numpy.zeros(leavesTotal * leavesTotal + 1, dtype=dtypeMaximum)
 
     foldingsTotal = jax.numpy.uint32(0)

someAssemblyRequired/__init__.py

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

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

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

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

someAssemblyRequired/getLLVMforNoReason.py

@@ -0,0 +1,19 @@
+import importlib
+import importlib.util
+import llvmlite.binding
+import pathlib
+
+def writeModuleLLVM(pathFilename: pathlib.Path, identifierCallable: str) -> pathlib.Path:
+    """Import the generated module directly and get its LLVM IR."""
+    specTarget = importlib.util.spec_from_file_location("generatedModule", pathFilename)
+    if specTarget is None or specTarget.loader is None:
+        raise ImportError(f"Could not create module spec or loader for {pathFilename}")
+    moduleTarget = importlib.util.module_from_spec(specTarget)
+    specTarget.loader.exec_module(moduleTarget)
+
+    # Get LLVM IR and write to file
+    linesLLVM = moduleTarget.__dict__[identifierCallable].inspect_llvm()[()]
+    moduleLLVM = llvmlite.binding.module.parse_assembly(linesLLVM)
+    pathFilenameLLVM = pathFilename.with_suffix(".ll")
+    pathFilenameLLVM.write_text(str(moduleLLVM))
+    return pathFilenameLLVM

someAssemblyRequired/synthesizeJob.py

@@ -0,0 +1,170 @@
+from mapFolding import getPathFilenameFoldsTotal, dtypeNumpyDefaults, thisSeemsVeryComplicated
+from mapFolding import make_dtype, datatypeLarge, dtypeLarge, datatypeMedium, dtypeMedium, datatypeSmall, dtypeSmall
+from mapFolding import outfitCountFolds, computationState, indexMy, indexTrack
+from someAssemblyRequired import countInitialize, countSequential
+from typing import Any, Optional, Sequence, Type
+import more_itertools
+import inspect
+import numpy
+import pathlib
+import pickle
+import python_minifier
+
+identifierCallableLaunch = "goGoGadgetAbsurdity"
+
+def makeStateJob(listDimensions: Sequence[int], **keywordArguments: Optional[Type[Any]]):
+    stateUniversal = outfitCountFolds(listDimensions, computationDivisions=None, CPUlimit=None, **keywordArguments)
+    countInitialize(stateUniversal['connectionGraph'], stateUniversal['gapsWhere'], stateUniversal['my'], stateUniversal['track'])
+
+    pathFilenameChopChop = getPathFilenameFoldsTotal(stateUniversal['mapShape'])
+    suffix = pathFilenameChopChop.suffix
+    pathJob = pathlib.Path(str(pathFilenameChopChop)[0:-len(suffix)])
+    pathJob.mkdir(parents=True, exist_ok=True)
+    pathFilenameJob = pathJob / 'stateJob.pkl'
+
+    pathFilenameJob.write_bytes(pickle.dumps(stateUniversal))
+    return pathFilenameJob
+
+def convertNDArrayToStr(arrayTarget: numpy.ndarray, identifierName: str) -> str:
+    def process_nested_array(arraySlice):
+        if isinstance(arraySlice, numpy.ndarray) and arraySlice.ndim > 1:
+            return [process_nested_array(arraySlice[index]) for index in range(arraySlice.shape[0])]
+        elif isinstance(arraySlice, numpy.ndarray) and arraySlice.ndim == 1:
+            listWithRanges = []
+            for group in more_itertools.consecutive_groups(arraySlice.tolist()):
+                ImaSerious = list(group)
+                if len(ImaSerious) <= 4:
+                    listWithRanges += ImaSerious
+                else:
+                    ImaRange = [range(ImaSerious[0], ImaSerious[-1] + 1)]
+                    listWithRanges += ImaRange
+            return listWithRanges
+        return arraySlice
+
+    arrayAsNestedLists = process_nested_array(arrayTarget)
+
+    stringMinimized = python_minifier.minify(str(arrayAsNestedLists))
+    commaZeroMaximum = arrayTarget.shape[-1] - 1
+    stringMinimized = stringMinimized.replace('[0' + ',0'*commaZeroMaximum + ']', '[0]*'+str(commaZeroMaximum+1))
+    for countZeros in range(commaZeroMaximum, 2, -1):
+        stringMinimized = stringMinimized.replace(',0'*countZeros + ']', ']+[0]*'+str(countZeros))
+
+    stringMinimized = stringMinimized.replace('range', '*range')
+
+    return f"{identifierName} = numpy.array({stringMinimized}, dtype=numpy.{arrayTarget.dtype})"
+
+def writeModuleWithNumba(listDimensions, **keywordArguments: Optional[str]) -> pathlib.Path:
+    datatypeLargeAsStr = keywordArguments.get('datatypeLarge', thisSeemsVeryComplicated.datatypeLarge)
+    datatypeMediumAsStr = keywordArguments.get('datatypeMedium', thisSeemsVeryComplicated.datatypeMedium)
+    datatypeSmallAsStr = keywordArguments.get('datatypeSmall', thisSeemsVeryComplicated.datatypeSmall)
+
+    numpy_dtypeLarge = make_dtype(datatypeLargeAsStr) # type: ignore
+    numpy_dtypeMedium = make_dtype(datatypeMediumAsStr) # type: ignore
+    numpy_dtypeSmall = make_dtype(datatypeSmallAsStr) # type: ignore
+
+    pathFilenameJob = makeStateJob(listDimensions, dtypeLarge = numpy_dtypeLarge, dtypeMedium = numpy_dtypeMedium, dtypeSmall = numpy_dtypeSmall)
+    stateJob: computationState = pickle.loads(pathFilenameJob.read_bytes())
+    pathFilenameFoldsTotal = getPathFilenameFoldsTotal(stateJob['mapShape'], pathFilenameJob.parent)
+
+    codeSource = inspect.getsource(countSequential)
+
+    # forceinline=True might actually be useful
+    parametersNumba = f"numba.types.{datatypeLargeAsStr}(), \
+cache=True, \
+nopython=True, \
+fastmath=True, \
+forceinline=True, \
+inline='always', \
+looplift=False, \
+_nrt=True, \
+error_model='numpy', \
+parallel=False, \
+boundscheck=False, \
+no_cfunc_wrapper=False, \
+no_cpython_wrapper=False, \
+"
+# no_cfunc_wrapper=True, \
+# no_cpython_wrapper=True, \
+
+    lineNumba = f"@numba.jit({parametersNumba})"
+
+    linesImport = "\n".join([
+                        "import numpy"
+                        , "import numba"
+                        ])
+
+    ImaIndent = '    '
+    linesDataDynamic = """"""
+    linesDataDynamic = "\n".join([linesDataDynamic
+            , ImaIndent + f"foldsTotal = numba.types.{datatypeLargeAsStr}(0)"
+            , ImaIndent + convertNDArrayToStr(stateJob['foldGroups'], 'foldGroups')
+            , ImaIndent + convertNDArrayToStr(stateJob['gapsWhere'], 'gapsWhere')
+            ])
+
+    linesDataStatic = """"""
+    linesDataStatic = "\n".join([linesDataStatic
+            , ImaIndent + convertNDArrayToStr(stateJob['connectionGraph'], 'connectionGraph')
+            ])
+
+    my = stateJob['my']
+    track = stateJob['track']
+    linesAlgorithm = """"""
+    for lineSource in codeSource.splitlines():
+        if lineSource.startswith(('#', 'import', 'from', '@numba.jit')):
+            continue
+        elif not lineSource:
+            continue
+        elif lineSource.startswith('def '):
+            lineSource = "\n".join([lineNumba
+                                , f"def {identifierCallableLaunch}():"
+                                , linesDataDynamic
+                                , linesDataStatic
+                                ])
+        elif 'my[indexMy.' in lineSource:
+            # leaf1ndex = my[indexMy.leaf1ndex.value]
+            identifier, statement = lineSource.split('=')
+            lineSource = ImaIndent + identifier.strip() + '=' + str(eval(statement.strip()))
+        elif 'track[indexTrack.' in lineSource:
+            # leafAbove = track[indexTrack.leafAbove.value]
+            identifier, statement = lineSource.split('=')
+            lineSource = ImaIndent + convertNDArrayToStr(eval(statement.strip()), identifier.strip())
+
+        linesAlgorithm = "\n".join([linesAlgorithm
+                            , lineSource
+                            ])
+
+    linesLaunch = """"""
+    linesLaunch = linesLaunch + f"""
+if __name__ == '__main__':
+    import time
+    timeStart = time.perf_counter()
+    {identifierCallableLaunch}()
+    print(time.perf_counter() - timeStart)"""
+
+    linesWriteFoldsTotal = """"""
+    linesWriteFoldsTotal = "\n".join([linesWriteFoldsTotal
+                                    , "    foldsTotal = foldGroups[0:-1].sum() * foldGroups[-1]"
+                                    , "    print(foldsTotal)"
+                                    , "    with numba.objmode():"
+                                    , f"        open('{pathFilenameFoldsTotal.as_posix()}', 'w').write(str(foldsTotal))"
+                                    , "    return foldsTotal"
+                                    ])
+
+    linesAll = "\n".join([
+                        linesImport
+                        , linesAlgorithm
+                        , linesWriteFoldsTotal
+                        , linesLaunch
+                        ])
+
+    pathFilenameDestination = pathFilenameJob.with_stem(pathFilenameJob.parent.name).with_suffix(".py")
+    pathFilenameDestination.write_text(linesAll)
+
+    return pathFilenameDestination
+
+if __name__ == '__main__':
+    listDimensions = [3,15]
+    datatypeLarge = 'int64'
+    datatypeMedium = 'uint8'
+    datatypeSmall = datatypeMedium
+    writeModuleWithNumba(listDimensions, datatypeLarge=datatypeLarge, datatypeMedium=datatypeMedium, datatypeSmall=datatypeSmall)

someAssemblyRequired/{inlineAfunction.py → synthesizeModules.py}

@@ -1,7 +1,18 @@
-from mapFolding import indexMy, indexTrack
+from mapFolding import indexMy, indexTrack, theDao, datatypeMedium, datatypeLarge, datatypeSmall
 import ast
-import copy
 import pathlib
+import inspect
+
+algorithmSource = theDao
+
+dictionaryDecorators={
+    'countInitialize':
+    f'@numba.jit((numba.{datatypeSmall}[:,:,::1], numba.{datatypeMedium}[::1], numba.{datatypeSmall}[::1], numba.{datatypeMedium}[:,::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.{datatypeMedium}[::1], numba.{datatypeSmall}[::1], numba.{datatypeMedium}[:,::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.{datatypeMedium}[::1], numba.{datatypeSmall}[::1], numba.{datatypeMedium}[:,::1]), parallel=False, boundscheck=False, cache=True, error_model="numpy", fastmath=True, looplift=False, nogil=True, nopython=True)\n',
+    }
 
 def getDictionaryEnumValues():
     dictionaryEnumValues = {}
@@ -11,10 +22,13 @@ def getDictionaryEnumValues():
     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.2.7.dist-info/RECORD

@@ -1,19 +0,0 @@
-benchmarks/benchmarking.py,sha256=HD_0NSvuabblg94ftDre6LFnXShTe8MYj3hIodW-zV0,3076
-reference/flattened.py,sha256=X9nvRzg7YDcpCtSDTL4YiidjshlX9rg2e6JVCY6i2u0,16547
-reference/hunterNumba.py,sha256=0giUyqAFzP-XKcq3Kz8wIWCK0BVFhjABVJ1s-w4Jhu0,7109
-reference/irvineJavaPort.py,sha256=Sj-63Z-OsGuDoEBXuxyjRrNmmyl0d7Yz_XuY7I47Oyg,4250
-reference/jax.py,sha256=bB34dGdi3VSz4cRFbmCPn_erAmQ3FyrSED8uJ7CsES0,14961
-reference/lunnan.py,sha256=XEcql_gxvCCghb6Or3qwmPbn4IZUbZTaSmw_fUjRxZE,5037
-reference/lunnanNumpy.py,sha256=HqDgSwTOZA-G0oophOEfc4zs25Mv4yw2aoF1v8miOLk,4653
-reference/lunnanWhile.py,sha256=7NY2IKO5XBgol0aWWF_Fi-7oTL9pvu_z6lB0TF1uVHk,4063
-reference/rotatedEntryPoint.py,sha256=z0QyDQtnMvXNj5ntWzzJUQUMFm1-xHGLVhtYzwmczUI,11530
-reference/total_countPlus1vsPlusN.py,sha256=usenM8Yn_G1dqlPl7NKKkcnbohBZVZBXTQRm2S3_EDA,8106
-someAssemblyRequired/inlineAfunction.py,sha256=_hGAxVSVUAKCsNT92p0--Y636HkudpxHDEClXKrmmNE,6181
-someAssemblyRequired/jobsAndTasks.py,sha256=zHgqvY4GHiCmH1fQrOHxsyDFUWoOcNtLAKPLwL6NVvU,2155
-someAssemblyRequired/makeNuitkaSource.py,sha256=jTK34OWzm6OsgFPd2mHwETxFo2X83io0M4YiEHRgk3U,3262
-someAssemblyRequired/makeNumbaJob.py,sha256=L1JORHfVKjBve7GjlE4-JMnzT7wJGJISGzLbWyRCyxU,5899
-mapFolding-0.2.7.dist-info/METADATA,sha256=i3nAtGhadvid_ODpCN9uXk9e4L3zQhXJfuElSQUmY50,7425
-mapFolding-0.2.7.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapFolding-0.2.7.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapFolding-0.2.7.dist-info/top_level.txt,sha256=yHhQq-bIJhB4pZcof5hXDTIjan0nxcFuOEWb7gy1DuU,42
-mapFolding-0.2.7.dist-info/RECORD,,

someAssemblyRequired/jobsAndTasks.py

@@ -1,46 +0,0 @@
-from typing import Any, Optional, Sequence, Type
-
-def Z0Z_makeJob(listDimensions: Sequence[int], **keywordArguments: Optional[Type[Any]]):
-    from mapFolding import outfitCountFolds
-    stateUniversal = outfitCountFolds(listDimensions, computationDivisions=None, CPUlimit=None, **keywordArguments)
-    from mapFolding.someAssemblyRequired.countInitializeNoNumba import countInitialize
-    countInitialize(stateUniversal['connectionGraph'], stateUniversal['gapsWhere'], stateUniversal['my'], stateUniversal['track'])
-    from mapFolding import getPathFilenameFoldsTotal
-    pathFilenameChopChop = getPathFilenameFoldsTotal(stateUniversal['mapShape'])
-    import pathlib
-    suffix = pathFilenameChopChop.suffix
-    pathJob = pathlib.Path(str(pathFilenameChopChop)[0:-len(suffix)])
-    pathJob.mkdir(parents=True, exist_ok=True)
-    pathFilenameJob = pathJob / 'stateJob.pkl'
-
-    pathFilenameFoldsTotal = getPathFilenameFoldsTotal(stateUniversal['mapShape'], pathFilenameJob.parent)
-    stateJob = {**stateUniversal, 'pathFilenameFoldsTotal': pathFilenameFoldsTotal}
-
-    del stateJob['mapShape']
-
-    import pickle
-    pathFilenameJob.write_bytes(pickle.dumps(stateJob))
-    return pathFilenameJob
-
-def runJob(pathFilename):
-    from typing import Final
-    import numpy
-    from pathlib import Path
-    pathFilenameJob = Path(pathFilename)
-    from pickle import loads
-    stateJob = loads(pathFilenameJob.read_bytes())
-
-    connectionGraph: numpy.ndarray = stateJob['connectionGraph']
-    foldsSubTotals: numpy.ndarray = stateJob['foldsSubTotals']
-    gapsWhere: numpy.ndarray = stateJob['gapsWhere']
-    my: numpy.ndarray = stateJob['my']
-    pathFilenameFoldsTotal: Final[Path] = stateJob['pathFilenameFoldsTotal']
-    track: numpy.ndarray = stateJob['track']
-
-    from mapFolding.someAssemblyRequired.countSequentialNoNumba import countSequential
-    countSequential(connectionGraph, foldsSubTotals, gapsWhere, my, track)
-
-    print(foldsSubTotals.sum().item())
-    Path(pathFilenameFoldsTotal).parent.mkdir(parents=True, exist_ok=True)
-    Path(pathFilenameFoldsTotal).write_text(str(foldsSubTotals.sum().item()))
-    print(pathFilenameFoldsTotal)

someAssemblyRequired/makeNuitkaSource.py

@@ -1,99 +0,0 @@
-"""NOTE make a special venv for nuitka, then run nuitka from that venv"""
-from pathlib import Path
-from pickle import loads
-from typing import Final
-import numpy
-from mapFolding.someAssemblyRequired.jobsAndTasks import Z0Z_makeJob
-
-"""
-Section: configure every time"""
-
-# TODO configure this
-mapShape = [3]*3
-# NOTE ^^^^^^ pay attention
-
-"""
-Section: settings"""
-
-pathFilenameData = Z0Z_makeJob(mapShape)
-
-pathJob = pathFilenameData.parent
-
-pathFilenameAlgorithm = Path('/apps/mapFolding/mapFolding/countSequentialNoNumba.py')
-pathFilenameDestination = Path(f"/apps/mapFolding/nn/{pathJob.name}.py")
-
-"""
-Section: did you handle and include this stuff?"""
-
-lineImportNumPy = "import numpy"
-linePrintFoldsTotal = "print(foldsSubTotals.sum().item())"
-linesAlgorithm = """"""
-linesData = """"""
-settingsNuitkaProject=f"""
-# nuitka-project: --mode=onefile
-# nuitka-project: --onefile-no-compression
-# nuitka-project: --lto=yes
-# nuitka-project: --clang
-# nuitka-project: --output-dir={pathJob}
-# nuitka-project: --output-filename={pathJob.name}.exe
-"""
-# nuitka-project:
-"""
-Section: do the work"""
-
-WTFamIdoing = pathFilenameAlgorithm.read_text()
-for lineSource in WTFamIdoing.splitlines():
-    ImaIndent = '    '
-    if lineSource.startswith(ImaIndent):
-        lineSource = lineSource[len(ImaIndent):None]
-    elif lineSource.startswith('#'):
-        continue
-    elif not lineSource:
-        continue
-    elif lineSource.startswith('def '):
-        continue
-    else:
-        raise NotImplementedError("You didn't anticipate this.")
-    linesAlgorithm = "\n".join([linesAlgorithm
-                            , lineSource
-                            ])
-
-stateJob = loads(pathFilenameData.read_bytes())
-connectionGraph: Final[numpy.ndarray] = stateJob['connectionGraph']
-foldsSubTotals: numpy.ndarray = stateJob['foldsSubTotals']
-gapsWhere: numpy.ndarray = stateJob['gapsWhere']
-my: numpy.ndarray = stateJob['my']
-the: numpy.ndarray = stateJob['the']
-track: numpy.ndarray = stateJob['track']
-
-pathFilenameFoldsTotal = stateJob['pathFilenameFoldsTotal']
-lineDataPathFilenameFoldsTotal = "pathFilenameFoldsTotal = r'" + str(pathFilenameFoldsTotal) + "'\n"
-
-def archivistFormatsArrayToCode(arrayTarget: numpy.ndarray, identifierName: str) -> str:
-    """Format numpy array into a code string that recreates the array."""
-    arrayAsTypeStr = numpy.array2string(
-        arrayTarget,
-        threshold=10000,
-        max_line_width=100,
-        separator=','
-        )
-    return f"{identifierName} = numpy.array({arrayAsTypeStr}, dtype=numpy.{arrayTarget.dtype})\n"
-
-linesData = "\n".join([linesData
-            , lineDataPathFilenameFoldsTotal
-            , archivistFormatsArrayToCode(the, 'the')
-            , archivistFormatsArrayToCode(my, 'my')
-            , archivistFormatsArrayToCode(foldsSubTotals, 'foldsSubTotals')
-            , archivistFormatsArrayToCode(gapsWhere, 'gapsWhere')
-            , archivistFormatsArrayToCode(connectionGraph, 'connectionGraph')
-            , archivistFormatsArrayToCode(track, 'track')
-            ])
-
-linesAll = "\n".join([settingsNuitkaProject
-            , lineImportNumPy
-            , linesData
-            , linesAlgorithm
-            , linePrintFoldsTotal
-            ])
-
-pathFilenameDestination.write_text(linesAll)

someAssemblyRequired/makeNumbaJob.py

@@ -1,147 +0,0 @@
-"""Create a python module hardcoded to compute a map's foldsTotal.
-- NumPy ndarray.
-- Numba optimized.
-- Absolutely no other imports.
-
-Can create LLVM IR from the module: of unknown utility.
-"""
-# from mapFolding import dtypeDefault, dtypeSmall
-from mapFolding import make_dtype, datatypeLarge, dtypeLarge
-from mapFolding.someAssemblyRequired.inlineAfunction import Z0Z_inlineMapFolding
-from mapFolding.someAssemblyRequired.jobsAndTasks import Z0Z_makeJob
-import importlib
-import llvmlite.binding
-import numpy
-import pathlib
-import pickle
-import python_minifier
-
-listDimensions = [5,5]
-
-# NOTE this overwrites files
-Z0Z_inlineMapFolding()
-
-identifierCallableLaunch = "goGoGadgetAbsurdity"
-
-def convertNDArrayToStr(arrayTarget: numpy.ndarray, identifierName: str) -> str:
-    arrayAsTypeStr = numpy.array2string(arrayTarget, threshold=100000, max_line_width=200, separator=',')
-    stringMinimized = python_minifier.minify(arrayAsTypeStr)
-    commaZeroMaximum = arrayTarget.shape[-1] - 1
-    stringMinimized = stringMinimized.replace('[0' + ',0'*commaZeroMaximum + ']', '[0]*'+str(commaZeroMaximum+1))
-    for countZeros in range(commaZeroMaximum, 2, -1):
-        stringMinimized = stringMinimized.replace(',0'*countZeros + ']', ']+[0]*'+str(countZeros))
-    return f"{identifierName} = numpy.array({stringMinimized}, dtype=numpy.{arrayTarget.dtype})"
-
-def writeModuleWithNumba(listDimensions):
-    numpy_dtypeLarge = dtypeLarge
-    # numpy_dtypeDefault = dtypeDefault
-    datatypeDefault = 'uint8'
-    numpy_dtypeDefault = make_dtype(datatypeDefault)
-    numpy_dtypeSmall = numpy_dtypeDefault
-    # forceinline=True might actually be useful
-    parametersNumba = f"numba.types.{datatypeLarge}(), \
-cache=True, \
-nopython=True, \
-fastmath=True, \
-forceinline=True, \
-inline='always', \
-looplift=False, \
-_nrt=True, \
-error_model='numpy', \
-parallel=False, \
-boundscheck=False, \
-no_cfunc_wrapper=False, \
-no_cpython_wrapper=False, \
-"
-# no_cfunc_wrapper=True, \
-# no_cpython_wrapper=True, \
-
-    pathFilenameData = Z0Z_makeJob(listDimensions, datatypeDefault=numpy_dtypeDefault, datatypeLarge=numpy_dtypeLarge, datatypeSmall=numpy_dtypeSmall)
-
-    pathFilenameAlgorithm = pathlib.Path('/apps/mapFolding/mapFolding/someAssemblyRequired/countSequentialNoNumba.py')
-    pathFilenameDestination = pathFilenameData.with_stem(pathFilenameData.parent.name).with_suffix(".py")
-
-    lineNumba = f"@numba.jit({parametersNumba})"
-
-    linesImport = "\n".join([
-                        "import numpy"
-                        , "import numba"
-                        ])
-
-    stateJob = pickle.loads(pathFilenameData.read_bytes())
-
-    ImaIndent = '    '
-    linesDataDynamic = """"""
-    linesDataDynamic = "\n".join([linesDataDynamic
-            , ImaIndent + f"foldsTotal = numba.types.{datatypeLarge}(0)"
-            , ImaIndent + convertNDArrayToStr(stateJob['my'], 'my')
-            , ImaIndent + convertNDArrayToStr(stateJob['foldGroups'], 'foldGroups')
-            , ImaIndent + convertNDArrayToStr(stateJob['gapsWhere'], 'gapsWhere')
-            , ImaIndent + convertNDArrayToStr(stateJob['track'], 'track')
-            ])
-
-    linesDataStatic = """"""
-    linesDataStatic = "\n".join([linesDataStatic
-            , ImaIndent + convertNDArrayToStr(stateJob['connectionGraph'], 'connectionGraph')
-            ])
-
-    pathFilenameFoldsTotal: pathlib.Path = stateJob['pathFilenameFoldsTotal']
-
-    linesAlgorithm = """"""
-    for lineSource in pathFilenameAlgorithm.read_text().splitlines():
-        if lineSource.startswith('#'):
-            continue
-        elif not lineSource:
-            continue
-        elif lineSource.startswith('def '):
-            lineSource = "\n".join([lineNumba
-                                , f"def {identifierCallableLaunch}():"
-                                , linesDataDynamic
-                                , linesDataStatic
-                                ])
-        linesAlgorithm = "\n".join([linesAlgorithm
-                            , lineSource
-                            ])
-
-    linesLaunch = """"""
-    linesLaunch = linesLaunch + f"""
-if __name__ == '__main__':
-    import time
-    timeStart = time.perf_counter()
-    {identifierCallableLaunch}()
-    print(time.perf_counter() - timeStart)"""
-
-    linesWriteFoldsTotal = """"""
-    linesWriteFoldsTotal = "\n".join([linesWriteFoldsTotal
-                                    , "    foldsTotal = foldGroups[0:-1].sum() * foldGroups[-1]"
-                                    , "    print(foldsTotal)"
-                                    , "    with numba.objmode():"
-                                    , f"        open('{pathFilenameFoldsTotal.as_posix()}', 'w').write(str(foldsTotal))"
-                                    , "    return foldsTotal"
-                                    ])
-
-    linesAll = "\n".join([
-                        linesImport
-                        , linesAlgorithm
-                        , linesWriteFoldsTotal
-                        , linesLaunch
-                        ])
-
-    pathFilenameDestination.write_text(linesAll)
-
-    return pathFilenameDestination
-
-def writeModuleLLVM(pathFilenamePythonFile: pathlib.Path) -> pathlib.Path:
-    pathRootPackage = pathlib.Path('c:/apps/mapFolding')
-    relativePathModule = pathFilenamePythonFile.relative_to(pathRootPackage)
-    moduleTarget = '.'.join(relativePathModule.parts)[0:-len(relativePathModule.suffix)]
-    moduleTargetImported = importlib.import_module(moduleTarget)
-    linesLLVM = moduleTargetImported.__dict__[identifierCallableLaunch].inspect_llvm()[()]
-    moduleLLVM = llvmlite.binding.module.parse_assembly(linesLLVM)
-    pathFilenameLLVM = pathFilenamePythonFile.with_suffix(".ll")
-    pathFilenameLLVM.write_text(str(moduleLLVM))
-    return pathFilenameLLVM
-
-if __name__ == '__main__':
-    pathFilenamePythonFile = writeModuleWithNumba(listDimensions)
-    pathFilenameLLVM = writeModuleLLVM(pathFilenamePythonFile)