mapFolding 0.7.1__py3-none-any.whl → 0.8.0__py3-none-any.whl

mapFolding/syntheticModules/numbaCount_doTheNeedful.py

@@ -1,13 +1,198 @@
-from mapFolding import indexMy
-from mapFolding.syntheticModules.numbaCount import countInitialize, countSequential, countParallel
-from numba import uint16, int64, jit
-from numpy import ndarray, dtype, integer
-from typing import Any
-
-@jit((uint16[:, :, ::1], int64[::1], uint16[::1], uint16[::1], uint16[::1], uint16[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
-def doTheNeedful(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[tuple[int], dtype[integer[Any]]], mapShape: ndarray[tuple[int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
-    countInitialize(connectionGraph, gapsWhere, my, track)
-    if my[indexMy.taskDivisions] > 0:
-        countParallel(connectionGraph, foldGroups, gapsWhere, my, track)
+from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
+from copy import deepcopy
+from mapFolding.theSSOT import Array1DElephino, Array1DFoldsTotal, Array1DLeavesTotal, Array3D, ComputationState, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
+from numba import jit
+
+def countInitialize(state: ComputationState) -> ComputationState:
+    while state.leaf1ndex > 0:
+        if state.leaf1ndex <= 1 or state.leafBelow[0] == 1:
+            state.dimensionsUnconstrained = state.dimensionsTotal
+            state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
+            state.indexDimension = 0
+            while state.indexDimension < state.dimensionsTotal:
+                state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
+                if state.leafConnectee == state.leaf1ndex:
+                    state.dimensionsUnconstrained -= 1
+                else:
+                    while state.leafConnectee != state.leaf1ndex:
+                        state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
+                        if state.countDimensionsGapped[state.leafConnectee] == 0:
+                            state.gap1ndexCeiling += 1
+                        state.countDimensionsGapped[state.leafConnectee] += 1
+                        state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
+                state.indexDimension += 1
+            if not state.dimensionsUnconstrained:
+                indexLeaf = 0
+                while indexLeaf < state.leaf1ndex:
+                    state.gapsWhere[state.gap1ndexCeiling] = indexLeaf
+                    state.gap1ndexCeiling += 1
+                    indexLeaf += 1
+            state.indexMiniGap = state.gap1ndex
+            while state.indexMiniGap < state.gap1ndexCeiling:
+                state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
+                if state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] == state.dimensionsUnconstrained:
+                    state.gap1ndex += 1
+                state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] = 0
+                state.indexMiniGap += 1
+        if state.leaf1ndex > 0:
+            state.gap1ndex -= 1
+            state.leafAbove[state.leaf1ndex] = state.gapsWhere[state.gap1ndex]
+            state.leafBelow[state.leaf1ndex] = state.leafBelow[state.leafAbove[state.leaf1ndex]]
+            state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leaf1ndex
+            state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
+            state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
+            state.leaf1ndex += 1
+        if state.gap1ndex > 0:
+            break
+    return state
+
+@jit(_nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
+def countParallel(mapShape: tuple[DatatypeLeavesTotal, ...], leavesTotal: DatatypeLeavesTotal, taskDivisions: DatatypeLeavesTotal, concurrencyLimit: DatatypeElephino, connectionGraph: Array3D, dimensionsTotal: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, foldGroups: Array1DFoldsTotal, foldsTotal: DatatypeFoldsTotal, gap1ndex: DatatypeLeavesTotal, gap1ndexCeiling: DatatypeElephino, groupsOfFolds: DatatypeFoldsTotal, indexDimension: DatatypeLeavesTotal, indexLeaf: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeElephino, leafConnectee: DatatypeElephino, taskIndex: DatatypeLeavesTotal) -> DatatypeFoldsTotal:
+    while leaf1ndex > 0:
+        if leaf1ndex <= 1 or leafBelow[0] == 1:
+            if leaf1ndex > leavesTotal:
+                groupsOfFolds += 1
+            else:
+                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:
+                            if leaf1ndex != taskDivisions or leafConnectee % taskDivisions == taskIndex:
+                                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
+    return groupsOfFolds
+
+@jit(_nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
+def countSequential(mapShape: tuple[DatatypeLeavesTotal, ...], leavesTotal: DatatypeLeavesTotal, taskDivisions: DatatypeLeavesTotal, concurrencyLimit: DatatypeElephino, connectionGraph: Array3D, dimensionsTotal: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, foldGroups: Array1DFoldsTotal, foldsTotal: DatatypeFoldsTotal, gap1ndex: DatatypeLeavesTotal, gap1ndexCeiling: DatatypeElephino, groupsOfFolds: DatatypeFoldsTotal, indexDimension: DatatypeLeavesTotal, indexLeaf: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeElephino, leafConnectee: DatatypeElephino, taskIndex: DatatypeLeavesTotal) -> tuple[tuple[DatatypeLeavesTotal, ...], DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, Array3D, DatatypeLeavesTotal, Array1DLeavesTotal, DatatypeLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array1DFoldsTotal, DatatypeFoldsTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal]:
+    while leaf1ndex > 0:
+        if leaf1ndex <= 1 or leafBelow[0] == 1:
+            if leaf1ndex > leavesTotal:
+                groupsOfFolds += 1
+            else:
+                dimensionsUnconstrained = dimensionsTotal
+                gap1ndexCeiling = gapRangeStart[leaf1ndex - 1]
+                indexDimension = 0
+                while indexDimension < dimensionsTotal:
+                    leafConnectee = connectionGraph[indexDimension, leaf1ndex, leaf1ndex]
+                    if leafConnectee == leaf1ndex:
+                        dimensionsUnconstrained -= 1
+                    else:
+                        while leafConnectee != leaf1ndex:
+                            gapsWhere[gap1ndexCeiling] = leafConnectee
+                            if countDimensionsGapped[leafConnectee] == 0:
+                                gap1ndexCeiling += 1
+                            countDimensionsGapped[leafConnectee] += 1
+                            leafConnectee = connectionGraph[indexDimension, leaf1ndex, leafBelow[leafConnectee]]
+                    indexDimension += 1
+                indexMiniGap = gap1ndex
+                while indexMiniGap < gap1ndexCeiling:
+                    gapsWhere[gap1ndex] = gapsWhere[indexMiniGap]
+                    if countDimensionsGapped[gapsWhere[indexMiniGap]] == dimensionsUnconstrained:
+                        gap1ndex += 1
+                    countDimensionsGapped[gapsWhere[indexMiniGap]] = 0
+                    indexMiniGap += 1
+        while leaf1ndex > 0 and gap1ndex == gapRangeStart[leaf1ndex - 1]:
+            leaf1ndex -= 1
+            leafBelow[leafAbove[leaf1ndex]] = leafBelow[leaf1ndex]
+            leafAbove[leafBelow[leaf1ndex]] = leafAbove[leaf1ndex]
+        if leaf1ndex > 0:
+            gap1ndex -= 1
+            leafAbove[leaf1ndex] = gapsWhere[gap1ndex]
+            leafBelow[leaf1ndex] = leafBelow[leafAbove[leaf1ndex]]
+            leafBelow[leafAbove[leaf1ndex]] = leaf1ndex
+            leafAbove[leafBelow[leaf1ndex]] = leaf1ndex
+            gapRangeStart[leaf1ndex] = gap1ndex
+            leaf1ndex += 1
+    foldGroups[taskIndex] = groupsOfFolds
+    return (mapShape, leavesTotal, taskDivisions, concurrencyLimit, connectionGraph, dimensionsTotal, countDimensionsGapped, dimensionsUnconstrained, gapRangeStart, gapsWhere, leafAbove, leafBelow, foldGroups, foldsTotal, gap1ndex, gap1ndexCeiling, groupsOfFolds, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, taskIndex)
+
+def doTheNeedful(state: ComputationState) -> ComputationState:
+    state = countInitialize(state)
+    if state.taskDivisions > 0:
+        dictionaryConcurrency: dict[int, ConcurrentFuture[ComputationState]] = {}
+        with ProcessPoolExecutor(state.concurrencyLimit) as concurrencyManager:
+            for indexSherpa in range(state.taskDivisions):
+                stateParallel = deepcopy(state)
+                stateParallel.taskIndex = indexSherpa
+                mapShape: tuple[DatatypeLeavesTotal, ...] = stateParallel.mapShape
+                leavesTotal: DatatypeLeavesTotal = stateParallel.leavesTotal
+                taskDivisions: DatatypeLeavesTotal = stateParallel.taskDivisions
+                concurrencyLimit: DatatypeElephino = stateParallel.concurrencyLimit
+                connectionGraph: Array3D = stateParallel.connectionGraph
+                dimensionsTotal: DatatypeLeavesTotal = stateParallel.dimensionsTotal
+                countDimensionsGapped: Array1DLeavesTotal = stateParallel.countDimensionsGapped
+                dimensionsUnconstrained: DatatypeLeavesTotal = stateParallel.dimensionsUnconstrained
+                gapRangeStart: Array1DElephino = stateParallel.gapRangeStart
+                gapsWhere: Array1DLeavesTotal = stateParallel.gapsWhere
+                leafAbove: Array1DLeavesTotal = stateParallel.leafAbove
+                leafBelow: Array1DLeavesTotal = stateParallel.leafBelow
+                foldGroups: Array1DFoldsTotal = stateParallel.foldGroups
+                foldsTotal: DatatypeFoldsTotal = stateParallel.foldsTotal
+                gap1ndex: DatatypeLeavesTotal = stateParallel.gap1ndex
+                gap1ndexCeiling: DatatypeElephino = stateParallel.gap1ndexCeiling
+                groupsOfFolds: DatatypeFoldsTotal = stateParallel.groupsOfFolds
+                indexDimension: DatatypeLeavesTotal = stateParallel.indexDimension
+                indexLeaf: DatatypeLeavesTotal = stateParallel.indexLeaf
+                indexMiniGap: DatatypeElephino = stateParallel.indexMiniGap
+                leaf1ndex: DatatypeElephino = stateParallel.leaf1ndex
+                leafConnectee: DatatypeElephino = stateParallel.leafConnectee
+                taskIndex: DatatypeLeavesTotal = stateParallel.taskIndex
+                dictionaryConcurrency[indexSherpa] = concurrencyManager.submit(countParallel, mapShape, leavesTotal, taskDivisions, concurrencyLimit, connectionGraph, dimensionsTotal, countDimensionsGapped, dimensionsUnconstrained, gapRangeStart, gapsWhere, leafAbove, leafBelow, foldGroups, foldsTotal, gap1ndex, gap1ndexCeiling, groupsOfFolds, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, taskIndex)
+            for indexSherpa in range(state.taskDivisions):
+                state.foldGroups[indexSherpa] = dictionaryConcurrency[indexSherpa].result()
     else:
-        countSequential(connectionGraph, foldGroups, gapsWhere, my, track)
+        mapShape: tuple[DatatypeLeavesTotal, ...] = state.mapShape
+        leavesTotal: DatatypeLeavesTotal = state.leavesTotal
+        taskDivisions: DatatypeLeavesTotal = state.taskDivisions
+        concurrencyLimit: DatatypeElephino = state.concurrencyLimit
+        connectionGraph: Array3D = state.connectionGraph
+        dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
+        countDimensionsGapped: Array1DLeavesTotal = state.countDimensionsGapped
+        dimensionsUnconstrained: DatatypeLeavesTotal = state.dimensionsUnconstrained
+        gapRangeStart: Array1DElephino = state.gapRangeStart
+        gapsWhere: Array1DLeavesTotal = state.gapsWhere
+        leafAbove: Array1DLeavesTotal = state.leafAbove
+        leafBelow: Array1DLeavesTotal = state.leafBelow
+        foldGroups: Array1DFoldsTotal = state.foldGroups
+        foldsTotal: DatatypeFoldsTotal = state.foldsTotal
+        gap1ndex: DatatypeLeavesTotal = state.gap1ndex
+        gap1ndexCeiling: DatatypeElephino = state.gap1ndexCeiling
+        groupsOfFolds: DatatypeFoldsTotal = state.groupsOfFolds
+        indexDimension: DatatypeLeavesTotal = state.indexDimension
+        indexLeaf: DatatypeLeavesTotal = state.indexLeaf
+        indexMiniGap: DatatypeElephino = state.indexMiniGap
+        leaf1ndex: DatatypeElephino = state.leaf1ndex
+        leafConnectee: DatatypeElephino = state.leafConnectee
+        taskIndex: DatatypeLeavesTotal = state.taskIndex
+        mapShape, leavesTotal, taskDivisions, concurrencyLimit, connectionGraph, dimensionsTotal, countDimensionsGapped, dimensionsUnconstrained, gapRangeStart, gapsWhere, leafAbove, leafBelow, foldGroups, foldsTotal, gap1ndex, gap1ndexCeiling, groupsOfFolds, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, taskIndex = countSequential(mapShape, leavesTotal, taskDivisions, concurrencyLimit, connectionGraph, dimensionsTotal, countDimensionsGapped, dimensionsUnconstrained, gapRangeStart, gapsWhere, leafAbove, leafBelow, foldGroups, foldsTotal, gap1ndex, gap1ndexCeiling, groupsOfFolds, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, taskIndex)
+        state = ComputationState(mapShape=mapShape, leavesTotal=leavesTotal, taskDivisions=taskDivisions, concurrencyLimit=concurrencyLimit, countDimensionsGapped=countDimensionsGapped, dimensionsUnconstrained=dimensionsUnconstrained, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, foldGroups=foldGroups, foldsTotal=foldsTotal, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, groupsOfFolds=groupsOfFolds, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, taskIndex=taskIndex)
+    return state

mapFolding/theDao.py

@@ -1,12 +1,18 @@
-from concurrent.futures import ProcessPoolExecutor
+from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
+from copy import deepcopy
 from mapFolding.theSSOT import ComputationState
-import concurrent.futures
-import copy
-import multiprocessing
+from multiprocessing import set_start_method as multiprocessing_set_start_method
+
+"""
+- A "leaf" is a unit square in the map
+- A "gap" is a potential position where a new leaf can be folded
+- Connections track how leaves can connect above/below each other
+- Leaves are enumerated starting from 1, not 0; hence, leaf1ndex not leafIndex
+"""
 
 # When to use multiprocessing.set_start_method https://github.com/hunterhogan/mapFolding/issues/6
 if __name__ == '__main__':
-	multiprocessing.set_start_method('spawn')
+	multiprocessing_set_start_method('spawn')
 
 def activeLeafConnectedToItself(state: ComputationState) -> bool:
 	return state.leafConnectee == state.leaf1ndex
@@ -23,7 +29,7 @@ def activeLeafIsTheFirstLeaf(state: ComputationState) -> bool:
 def allDimensionsAreUnconstrained(state: ComputationState) -> bool:
 	return not state.dimensionsUnconstrained
 
-def backtrack(state: ComputationState) -> ComputationState:
+def undoLastLeafPlacement(state: ComputationState) -> ComputationState:
 	state.leaf1ndex -= 1
 	state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leafBelow[state.leaf1ndex]
 	state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leafAbove[state.leaf1ndex]
@@ -103,7 +109,7 @@ def loopUpToDimensionsTotal(state: ComputationState) -> bool:
 def noGapsHere(state: ComputationState) -> bool:
 	return (state.leaf1ndex > 0) and (state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1])
 
-def placeLeaf(state: ComputationState) -> ComputationState:
+def insertLeafAtGap(state: ComputationState) -> ComputationState:
 	state.gap1ndex -= 1
 	state.leafAbove[state.leaf1ndex] = state.gapsWhere[state.gap1ndex]
 	state.leafBelow[state.leaf1ndex] = state.leafBelow[state.leafAbove[state.leaf1ndex]]
@@ -143,7 +149,7 @@ def countInitialize(state: ComputationState) -> ComputationState:
 					state = filterCommonGaps(state)
 					state = incrementIndexMiniGap(state)
 		if thereIsAnActiveLeaf(state):
-			state = placeLeaf(state)
+			state = insertLeafAtGap(state)
 		if state.gap1ndex > 0:
 			break
 	return state
@@ -170,9 +176,9 @@ def countParallel(state: ComputationState) -> ComputationState:
 					state = filterCommonGaps(state)
 					state = incrementIndexMiniGap(state)
 		while noGapsHere(state):
-			state = backtrack(state)
+			state = undoLastLeafPlacement(state)
 		if thereIsAnActiveLeaf(state):
-			state = placeLeaf(state)
+			state = insertLeafAtGap(state)
 	state.foldGroups[state.taskIndex] = state.groupsOfFolds
 	return state
 
@@ -197,23 +203,24 @@ def countSequential(state: ComputationState) -> ComputationState:
 					state = filterCommonGaps(state)
 					state = incrementIndexMiniGap(state)
 		while noGapsHere(state):
-			state = backtrack(state)
+			state = undoLastLeafPlacement(state)
 		if thereIsAnActiveLeaf(state):
-			state = placeLeaf(state)
+			state = insertLeafAtGap(state)
 	state.foldGroups[state.taskIndex] = state.groupsOfFolds
 	return state
 
 def doTheNeedful(state: ComputationState) -> ComputationState:
 	state = countInitialize(state)
 	if state.taskDivisions > 0:
-		dictionaryConcurrency: dict[int, concurrent.futures.Future[ComputationState]] = {}
+		dictionaryConcurrency: dict[int, ConcurrentFuture[ComputationState]] = {}
 		with ProcessPoolExecutor(state.concurrencyLimit) as concurrencyManager:
 			for indexSherpa in range(state.taskDivisions):
-				stateParallel = copy.deepcopy(state)
+				stateParallel = deepcopy(state)
 				stateParallel.taskIndex = indexSherpa
 				dictionaryConcurrency[indexSherpa] = concurrencyManager.submit(countParallel, stateParallel)
 			for indexSherpa in range(state.taskDivisions):
 				state.foldGroups[indexSherpa] = dictionaryConcurrency[indexSherpa].result().foldGroups[indexSherpa]
-		return state
 	else:
-		return countSequential(state)
+		state = countSequential(state)
+
+	return state

mapFolding/theSSOT.py

@@ -20,12 +20,11 @@ Identifiers: scope and resolution, LEGB (Local, Enclosing, Global, Builtin)
 """
 
 # I _think_, in theSSOT, I have abstracted the flow settings to only these couple of lines:
+# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
 packageFlowSynthetic = 'numba'
-# packageFlowSynthetic = 'multiprocessing'
-Z0Z_packageFlow = 'algorithm'
-# https://github.com/hunterhogan/mapFolding/issues/4
-# Z0Z_packageFlow = packageFlowSynthetic
-
+# Z0Z_packageFlow = 'algorithm'
+Z0Z_packageFlow = packageFlowSynthetic
+Z0Z_concurrencyPackage = 'multiprocessing'
 # =============================================================================
 # The Wrong Way The Wrong Way The Wrong Way The Wrong Way The Wrong Way
 # Evaluate When Packaging Evaluate When Packaging Evaluate When Packaging
@@ -38,8 +37,7 @@ moduleOfSyntheticModulesPACKAGING: Final[str] = 'syntheticModules'
 dataclassModulePACKAGING: str = 'theSSOT'
 dataclassIdentifierPACKAGING: str = 'ComputationState'
 dataclassInstancePACKAGING: str = 'state'
-dataclassInstance_Pre_ParallelPACKAGING = dataclassInstancePACKAGING + 'PARALLEL'
-dataclassInstance_Post_ParallelPACKAGING = dataclassInstancePACKAGING + 'COMPLETE'
+dataclassInstanceTaskDistributionPACKAGING = dataclassInstancePACKAGING + 'Parallel'
 
 sourceInitializeCallablePACKAGING = 'countInitialize'
 sourceSequentialCallablePACKAGING = 'countSequential'
@@ -48,7 +46,7 @@ sourceParallelCallablePACKAGING = 'countParallel'
 try:
 	thePackageNamePACKAGING: str = tomli_load(Path("../pyproject.toml").open('rb'))["project"]["name"]
 except Exception:
-	thePackageNamePACKAGING: str = "mapFolding"
+	thePackageNamePACKAGING = "mapFolding"
 
 # =============================================================================
 # The Wrong Way The Wrong Way The Wrong Way The Wrong Way The Wrong Way
@@ -62,14 +60,9 @@ def getPathPackageINSTALLING() -> Path:
 		pathPackage = pathPackage.parent
 	return pathPackage
 
-# =============================================================================
-# The Wrong Way The Wrong Way The Wrong Way The Wrong Way The Wrong Way
-# Hardcoding Hardcoding Hardcoding Hardcoding Hardcoding Hardcoding Hardcoding
-
 # =============================================================================
 # The right way, perhaps.
 
-# =====================
 # Create enduring identifiers from the hopefully transient identifiers above.
 thePackageName: Final[str] = thePackageNamePACKAGING
 thePathPackage: Path = getPathPackageINSTALLING()
@@ -94,16 +87,17 @@ theDispatcherCallable: str = dispatcherCallablePACKAGING
 theDataclassModule: str = dataclassModulePACKAGING
 theDataclassIdentifier: str = dataclassIdentifierPACKAGING
 theDataclassInstance: str = dataclassInstancePACKAGING
-theDataclassInstance_Pre_Parallel: str = dataclassInstance_Pre_ParallelPACKAGING
-theDataclassInstance_Post_Parallel: str = dataclassInstance_Post_ParallelPACKAGING
+theDataclassInstanceTaskDistribution: str = dataclassInstanceTaskDistributionPACKAGING
 
 theFileExtension: str = fileExtensionINSTALLING
 
 theModuleOfSyntheticModules: Final[str] = moduleOfSyntheticModulesPACKAGING
 
 # =============================================================================
-# The right way.
+
+# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
 concurrencyPackage: str = Z0Z_packageFlow
+concurrencyPackage = Z0Z_concurrencyPackage
 
 # =============================================================================
 # The relatively flexible type system needs a different paradigm, but I don't
@@ -141,16 +135,16 @@ class ComputationState:
 	taskDivisions: DatatypeLeavesTotal
 	concurrencyLimit: DatatypeElephino
 
-	connectionGraph: Array3D = dataclasses.field(init=False, metadata={'description': 'A 3D array representing the connection graph of the map.'})
+	connectionGraph: Array3D = dataclasses.field(init=False)
 	dimensionsTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
 
-	countDimensionsGapped: Array1DLeavesTotal = dataclasses.field(default=None) # pyright: ignore[reportAssignmentType]
-	dimensionsUnconstrained: DatatypeLeavesTotal = dataclasses.field(default=None) # pyright: ignore[reportAssignmentType]
-	gapRangeStart: Array1DElephino = dataclasses.field(default=None) # pyright: ignore[reportAssignmentType]
-	gapsWhere: Array1DLeavesTotal = dataclasses.field(default=None) # pyright: ignore[reportAssignmentType]
-	leafAbove: Array1DLeavesTotal = dataclasses.field(default=None) # pyright: ignore[reportAssignmentType]
-	leafBelow: Array1DLeavesTotal = dataclasses.field(default=None) # pyright: ignore[reportAssignmentType]
-	foldGroups: Array1DFoldsTotal = dataclasses.field(default=None) # pyright: ignore[reportAssignmentType]
+	countDimensionsGapped: Array1DLeavesTotal = dataclasses.field(default=None, init=True) # type: ignore[arg-type, reportAssignmentType]
+	dimensionsUnconstrained: DatatypeLeavesTotal = dataclasses.field(default=None, init=True) # type: ignore[assignment, reportAssignmentType]
+	gapRangeStart: Array1DElephino = dataclasses.field(default=None, init=True) # type: ignore[arg-type, reportAssignmentType]
+	gapsWhere: Array1DLeavesTotal = dataclasses.field(default=None, init=True) # type: ignore[arg-type, reportAssignmentType]
+	leafAbove: Array1DLeavesTotal = dataclasses.field(default=None, init=True) # type: ignore[arg-type, reportAssignmentType]
+	leafBelow: Array1DLeavesTotal = dataclasses.field(default=None, init=True) # type: ignore[arg-type, reportAssignmentType]
+	foldGroups: Array1DFoldsTotal = dataclasses.field(default=None, init=True) # type: ignore[arg-type, reportAssignmentType]
 
 	foldsTotal: DatatypeFoldsTotal = DatatypeFoldsTotal(0)
 	gap1ndex: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
@@ -161,10 +155,10 @@ class ComputationState:
 	indexMiniGap: DatatypeElephino = DatatypeElephino(0)
 	leaf1ndex: DatatypeElephino = DatatypeElephino(1)
 	leafConnectee: DatatypeElephino = DatatypeElephino(0)
-	taskIndex: DatatypeLeavesTotal = dataclasses.field(default=DatatypeLeavesTotal(0), metadata={'myType': DatatypeLeavesTotal})
-	# taskIndex: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+	taskIndex: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+	# Efficient translation of Python scalar types to Numba types https://github.com/hunterhogan/mapFolding/issues/8
 
-	def __post_init__(self):
+	def __post_init__(self) -> None:
 		from mapFolding.beDRY import makeConnectionGraph, makeDataContainer
 		self.dimensionsTotal = DatatypeLeavesTotal(len(self.mapShape))
 		self.connectionGraph = makeConnectionGraph(self.mapShape, self.leavesTotal, numpyLeavesTotal)
@@ -189,14 +183,9 @@ class ComputationState:
 		if self.leafBelow is None:
 			self.leafBelow = makeDataContainer(leavesTotalAsInt + 1, numpyLeavesTotal)
 
-	def getFoldsTotal(self):
+	def getFoldsTotal(self) -> None:
 		self.foldsTotal = DatatypeFoldsTotal(self.foldGroups[0:-1].sum() * self.leavesTotal)
 
-	# factory? constructor?
-	# state.taskIndex = state.taskIndex.type(indexSherpa)
-	# self.fieldName = self.fieldName.fieldType(indexSherpa)
-	# state.taskIndex.toMyType(indexSherpa)
-
 # =============================================================================
 # The most right way I know how to implement.
 
@@ -208,8 +197,7 @@ def getSourceAlgorithm() -> ModuleType:
 	moduleImported: ModuleType = importlib_import_module(theLogicalPathModuleSourceAlgorithm)
 	return moduleImported
 
-# dynamically set the return type https://github.com/hunterhogan/mapFolding/issues/5
-def getAlgorithmDispatcher():
+def getAlgorithmDispatcher() -> Callable[[ComputationState], ComputationState]:
 	moduleImported: ModuleType = getSourceAlgorithm()
 	dispatcherCallable = getattr(moduleImported, theDispatcherCallable)
 	return dispatcherCallable
@@ -238,7 +226,7 @@ def getNumpyDtypeDefault() -> type[signedinteger[Any]]:
 # =============================================================================
 # The coping way.
 
-class FREAKOUT(Exception): pass
+class raiseIfNoneGitHubIssueNumber3(Exception): pass
 
 # =============================================================================
 # Temporary or transient or something; probably still the wrong way
@@ -266,13 +254,8 @@ def getPackageDispatcher() -> Callable[[ComputationState], ComputationState]:
 	# NOTE but this part, if the package flow is synthetic, probably needs to be delegated
 	# to the authority for creating _that_ synthetic flow.
 
-	# Automated system
-	# moduleImported: ModuleType = importlib_import_module(theLogicalPathModuleDispatcher)
-	# dispatcherCallable = getattr(moduleImported, theDispatcherCallable)
-
-	# Hardcoded while I am refactoring "someAssemblyRequired"
-	from mapFolding.syntheticModules.numbaCountSequential import flattenData
-	dispatcherCallable = flattenData
+	moduleImported: ModuleType = importlib_import_module(theLogicalPathModuleDispatcher)
+	dispatcherCallable = getattr(moduleImported, theDispatcherCallable)
 	return dispatcherCallable
 
 """Technical concepts I am likely using and likely want to use more effectively:
@@ -281,8 +264,10 @@ def getPackageDispatcher() -> Callable[[ComputationState], ComputationState]:
 - Lazy Initialization
 - Separate configuration from business logic
 
+----
 theSSOT and yourSSOT
 
+----
 delay realization/instantiation until a concrete value is desired
 moment of truth: when the value is needed, not when the value is defined
 """

{mapfolding-0.7.1.dist-info → mapfolding-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.7.1
+Version: 0.8.0
 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
@@ -38,12 +38,11 @@ Requires-Dist: tomli
 Requires-Dist: Z0Z_tools
 Provides-Extra: testing
 Requires-Dist: mypy; 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: pytest; extra == "testing"
 Requires-Dist: pyupgrade; extra == "testing"
-Requires-Dist: updateCitation; extra == "testing"
 
 # mapFolding: Algorithms for enumerating distinct map/stamp folding patterns 🗺️
 
@@ -113,14 +112,14 @@ Available OEIS sequences:
 
 ### 4. **Customizing your algorithm**
 
-- mapFolding\someAssemblyRequired\synthesizeNumbaJob.py (and/or synthesizeNumba____.py, as applicable)
+- Renovations in progress: ~~mapFolding\someAssemblyRequired\synthesizeNumbaJob.py (and/or synthesizeNumba____.py, as applicable)~~
   - Synthesize a Numba-optimized module for a specific mapShape
   - Synthesize _from_ a module in mapFolding\syntheticModules or from any source you select
   - Use the existing transformation options
   - Or create new ways of transforming the algorithm from its source to a specific job
-- mapFolding\someAssemblyRequired\makeJob.py
+- Renovations in progress: ~~mapFolding\someAssemblyRequired\makeJob.py~~
   - Initialize data for a specific mapShape
-- mapFolding\someAssemblyRequired\synthesizeNumbaModules.py (and/or synthesizeNumba____.py, as applicable)
+- Renovations in progress: ~~mapFolding\someAssemblyRequired\synthesizeNumbaModules.py (and/or synthesizeNumba____.py, as applicable)~~
   - Synthesize one or more Numba-optimized modules for parallel or sequential computation
   - Overwrite the modules in mapFolding\syntheticModules or save the module(s) to a custom path
   - Synthesize _from_ the algorithm(s) in mapFolding\theDao.py or from any source you select
@@ -131,7 +130,7 @@ Available OEIS sequences:
   - Modify the algorithms for initializing values, parallel computation, and/or sequential computation
   - Use the modified algorithm(s) in synthesizeNumbaModules.py, above, to create Numba-optimized version(s)
   - Then use a Numba-optimized version in synthesizeNumbaJob.py, above, to create a hyper-optimized version for a specific mapShape
-- mapFolding\theSSOT.py (and/or theSSOTnumba.py and/ or theSSOT____.py, if they exist)
+- mapFolding\theSSOT.py
   - Modify broad settings or find functions to modify broad settings, such as data structures and their data types
   - Create new settings or groups of settings
 - mapFolding\beDRY.py

mapfolding-0.8.0.dist-info/RECORD

@@ -0,0 +1,41 @@
+mapFolding/__init__.py,sha256=hONqdWnBN1ebgrKZuMIZfI8m-1krSR66L4GTVRwBmw4,203
+mapFolding/basecamp.py,sha256=Ik_oH-MpH8f6k-yBzwm99lfkv3pMDgFFEnSSDyiJjsQ,3861
+mapFolding/beDRY.py,sha256=nn0AEGzrroM3wp91Fts7mmx1VQgG14s0EZsXR-Uy5x8,9049
+mapFolding/filesystem.py,sha256=KqgsO-jaSWAlYib_9ovoXQY76PcQri09_73u0OqMWC8,4094
+mapFolding/noHomeYet.py,sha256=DAppmTJG95Ip1qF1uVLU_vXGz4Lmonp8OYfGXtmOnTE,785
+mapFolding/oeis.py,sha256=ZNt3UBklmpfjdmgbA7pO-ezz2prafr2JvdkpIDapi1w,11853
+mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/theDao.py,sha256=E-hisOy_1_iQqS6w4c7S-C-sIgIcwnAPFqooeWuinVY,9008
+mapFolding/theSSOT.py,sha256=r7_9t0dOo_IfBMqmkm1WXOzMfZjyPNco0hl1g9uU_2Y,12710
+mapFolding/reference/flattened.py,sha256=S6D9wiFTlbeoetEqaMLOcA-R22BHOzjqPRujffNxxUM,14875
+mapFolding/reference/hunterNumba.py,sha256=jDS0ORHkIhcJ1rzA5hT49sZHKf3rgJOoGesUCcbKFFY,6054
+mapFolding/reference/irvineJavaPort.py,sha256=7GvBU0tnS6wpFgkYad3465do9jBQW-2bYvbCYyABPHM,3341
+mapFolding/reference/jax.py,sha256=7ji9YWia6Kof0cjcNdiS1GG1rMbC5SBjcyVr_07AeUk,13845
+mapFolding/reference/lunnan.py,sha256=iAbJELfW6RKNMdPcBY9b6rGQ-z1zoRf-1XCurCRMOo8,3951
+mapFolding/reference/lunnanNumpy.py,sha256=rwVP3WIDXimpAuaxhRIuBYU56nVDTKlfGiclw_FkgUU,3765
+mapFolding/reference/lunnanWhile.py,sha256=uRrMT23jTJvoQDlD_FzeIQe_pfMXJG6_bRvs7uhC8z0,3271
+mapFolding/reference/rotatedEntryPoint.py,sha256=USZY3n3zwhSE68ATscUuN66t1qShuEbMI790Gz9JFTw,9352
+mapFolding/reference/total_countPlus1vsPlusN.py,sha256=wpgay-uqPOBd64Z4Pg6tg40j7-4pzWHGMM6v0bnmjhE,6288
+mapFolding/someAssemblyRequired/Z0Z_workbench.py,sha256=g4VkNKp2ts0koqcMSPNbE_ySR2-23Y-5CJBDpvbT6XU,16853
+mapFolding/someAssemblyRequired/__init__.py,sha256=G1uIo1RWcdBjeFPXFwa69kizsZFzkDR55B2uyyY5z7E,680
+mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=2kGRji3FGaALZwUZ6qlEjS7QxOkJK1Si-mAnsWePs_Q,983
+mapFolding/someAssemblyRequired/ingredientsNumba.py,sha256=u5621TzZW7Sp8BXedq0yooyYoFwDDsd9smoqObzRf8g,7359
+mapFolding/someAssemblyRequired/synthesizeDataConverters.py,sha256=J1qLKxqCMQd5JhcrTg9fvpPCfhb5TLz2wXY-J9z-TH8,5792
+mapFolding/someAssemblyRequired/synthesizeNumbaJobVESTIGIAL.py,sha256=3yRCEMIf9UCswu6wQvdUK9H3MW6Ossn-wg5eOq8LWz8,22362
+mapFolding/someAssemblyRequired/transformationTools.py,sha256=u2ah47kOqvVGKifuk7rZe4bSm3Z681nJzp73IXavYw4,36297
+mapFolding/syntheticModules/numbaCountHistoricalExample.py,sha256=Oo0Xeex89sLD15iRt3N76OKRFScKl9qwO84-d5sv6lM,11871
+mapFolding/syntheticModules/numbaCount_doTheNeedful.py,sha256=52RuwJVH2fROvWU2dT8wYcQvLgRuvkNZPq01kujCC_U,15725
+mapFolding/syntheticModules/numba_doTheNeedfulHistoricalExample.py,sha256=J9wZ9PW5EVduOQWVze7CgpTHkUjRIvBPG8fNuT3IVpA,1145
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/conftest.py,sha256=rRlXOhihwheHyQ8ggjRBbmgPVERxWjupajguVBzBkVE,10783
+tests/test_computations.py,sha256=YhadlskBh_r5RiefHRy0FlrYQ0FelYbqcSNNSkSJMIY,3368
+tests/test_filesystem.py,sha256=Kou0gj5T72oISao6umYfU6L_W5Hi7QS9_IxTv2hU0Pw,3147
+tests/test_oeis.py,sha256=uxvwmgbnylSDdsVJfuAT0LuYLbIVFwSgdLxHm-xUGBM,5043
+tests/test_other.py,sha256=1uuApByNWPiTf0zaro2dETkvyWQFfMweU_ge4aJuVgM,4244
+tests/test_tasks.py,sha256=hkZygihT8bCEO2zc-2VcxReQrZJBwgLNbYx0YP4lTDg,2853
+mapfolding-0.8.0.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+mapfolding-0.8.0.dist-info/METADATA,sha256=AA0b9jY45EztgHbZQq8SbpBExcDpnmhotXZB4DDO_2A,7670
+mapfolding-0.8.0.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+mapfolding-0.8.0.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapfolding-0.8.0.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapfolding-0.8.0.dist-info/RECORD,,

{mapfolding-0.7.1.dist-info → mapfolding-0.8.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.0.0)
+Generator: setuptools (76.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tests/conftest.py

@@ -1,5 +1,5 @@
 from collections.abc import Callable, Generator, Sequence
-from mapFolding.theSSOT import getAlgorithmDispatcher, getSourceAlgorithm, getPackageDispatcher, theModuleOfSyntheticModules, FREAKOUT
+from mapFolding.theSSOT import getAlgorithmDispatcher, getSourceAlgorithm, getPackageDispatcher, theModuleOfSyntheticModules, raiseIfNoneGitHubIssueNumber3
 from mapFolding.beDRY import getLeavesTotal, validateListDimensions, makeDataContainer
 from mapFolding.oeis import oeisIDsImplemented, settingsOEIS
 from pathlib import Path
@@ -10,7 +10,6 @@ import random
 import shutil
 import unittest.mock
 import uuid
-# TODO learn how to run tests and coverage analysis without `env = ["NUMBA_DISABLE_JIT=1"]`
 
 # SSOT for test data paths and filenames
 pathDataSamples = Path("tests/dataSamples")
@@ -215,7 +214,7 @@ def syntheticDispatcherFixture(useThisDispatcher: Callable[..., Any]) -> Callabl
 			dispatcherSynthetic = stuff
 
 	if dispatcherSynthetic is None:
-		raise FREAKOUT
+		raise raiseIfNoneGitHubIssueNumber3
 
 	dispatcherSpec = importlib.util.spec_from_file_location(dispatcherSynthetic.callableSynthesized, dispatcherSynthetic.pathFilenameForMe)
 	if dispatcherSpec is None:

tests/test_filesystem.py

@@ -3,9 +3,7 @@ from mapFolding.filesystem import getFilenameFoldsTotal, getPathFilenameFoldsTot
 from mapFolding.beDRY import validateListDimensions
 from mapFolding.theSSOT import getPathJobRootDEFAULT
 from pathlib import Path
-from typing import Any
 import io
-import numpy
 import pytest
 import unittest.mock
 

tests/test_other.py

@@ -42,8 +42,8 @@ import sys
 	(tuple([3, 5, 7]), [3, 5, 7], (3, 5, 7)),  # tuple sequence type
 ])
 def test_listDimensionsAsParameter(listDimensions: None | list[str] | list[int] | list[float] | list[None] | list[bool] | list[list[int]] | list[complex] | range | tuple[int, ...],
-							   expected_intInnit: type[ValueError] | list[int] | type[TypeError],
-							   expected_validateListDimensions: type[ValueError] | type[NotImplementedError] | tuple[int, ...] | type[TypeError]) -> None:
+							expected_intInnit: type[ValueError] | list[int] | type[TypeError],
+							expected_validateListDimensions: type[ValueError] | type[NotImplementedError] | tuple[int, ...] | type[TypeError]) -> None:
 	"""Test both validateListDimensions and getLeavesTotal with the same inputs."""
 	standardizedEqualToCallableReturn(expected_intInnit, intInnit, listDimensions)
 	standardizedEqualToCallableReturn(expected_validateListDimensions, validateListDimensions, listDimensions)
@@ -56,7 +56,6 @@ def test_getLeavesTotal_edge_cases() -> None:
 	# Input preservation
 	mapShape = (2, 3)
 	standardizedEqualToCallableReturn(6, getLeavesTotal, mapShape)
-	# Remove the lambda entirely for a simpler approach
 	assert mapShape == (2, 3), "Input tuple was modified"
 
 @pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_intInnit())

tests/test_tasks.py

@@ -12,10 +12,6 @@ import pytest
 if __name__ == '__main__':
 	multiprocessing.set_start_method('spawn')
 
-
-# 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_countFoldsComputationDivisionsInvalid(mapShapeTestFunctionality: tuple[int, ...]) -> None:
 	standardizedEqualToCallableReturn(ValueError, countFolds, mapShapeTestFunctionality, None, {"wrong": "value"})