mapFolding 0.3.2__py3-none-any.whl → 0.3.3__py3-none-any.whl

{mapFolding-0.3.2.dist-info → mapFolding-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.3.2
+Version: 0.3.3
 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
@@ -52,7 +52,7 @@ The directory [mapFolding/reference](https://github.com/hunterhogan/mapFolding/b
 - [hunterNumba.py](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/reference), a one-size-fits-all, self-contained, reasonably fast, contemporary algorithm that is nevertheless infected by _noobaceae ignorancium_, and
 - miscellaneous notes.
 
-[![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/) [![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml) [![Static Badge](https://img.shields.io/badge/stinkin'%20badges-don't%20need-b98e5e)](https://youtu.be/g6f_miE91mk&t=4) ![PyPI - Downloads](https://img.shields.io/pypi/dd/mapFolding) ![Static Badge](https://img.shields.io/badge/issues-I%20have%20them-brightgreen) ![GitHub repo size](https://img.shields.io/github/repo-size/hunterhogan/mapFolding)
+[![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/) [![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/pythonTests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/pythonTests.yml) [![Static Badge](https://img.shields.io/badge/stinkin'%20badges-don't%20need-b98e5e)](https://youtu.be/g6f_miE91mk&t=4) ![PyPI - Downloads](https://img.shields.io/pypi/dd/mapFolding) ![Static Badge](https://img.shields.io/badge/issues-I%20have%20them-brightgreen) ![GitHub repo size](https://img.shields.io/github/repo-size/hunterhogan/mapFolding)
 
 ## Simple, easy usage based on OEIS IDs
 

mapFolding-0.3.3.dist-info/RECORD

@@ -0,0 +1,25 @@
+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=iZpBslk8OnCmaUoqAivva7Hl7GJYrjwRV_owcBbgfcM,87
+someAssemblyRequired/generalizeSourceCode.py,sha256=6LsUe-5uqGXcrtXWrP70BrUgnjkJKrQo8y1KyFZdb-k,6024
+someAssemblyRequired/getLLVMforNoReason.py,sha256=FtJzw2pZS3A4NimWdZsegXaU-vKeCw8m67kcfb5wvGM,894
+someAssemblyRequired/makeJob.py,sha256=W85W7vWsNsu9mBsgU3Cx-FPYIdLLnyzR4GwdcYsWZv4,947
+someAssemblyRequired/synthesizeJob.py,sha256=xLak-ZZ1zQ92jBobhJqbnA1Fua9ofiRvLdK1fmD8s_s,7271
+someAssemblyRequired/synthesizeModules.py,sha256=yR9oFsZe3sbgDe2XoS9MbaIqNz-hOq6qOFzHMhPn4rc,3737
+syntheticModules/__init__.py,sha256=nDtS5UFMKN-F5pTp0qKA0J0I-XR3n3OFxV2bosieBu8,131
+syntheticModules/countInitialize.py,sha256=rRn1gtR1PWxpQ8Mw-_QRZT7ujRP_1H04QizJE9RlZ7o,1839
+syntheticModules/countParallel.py,sha256=aZQvSEeWeJ-47eyMyIisq1baAAl-H6W0RYIlVPv_D_U,2559
+syntheticModules/countSequential.py,sha256=Uf1Zd-r3wsmVoHOWyNOQQiFO6k6xmFG6Oo3dqwAqBQo,3216
+mapFolding-0.3.3.dist-info/METADATA,sha256=SfukFXyZtDIdmQ4Gzgl8ePyov_factyZ4Te7LSh0UYc,7530
+mapFolding-0.3.3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapFolding-0.3.3.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapFolding-0.3.3.dist-info/top_level.txt,sha256=tZHrMCdFq5ghJY_MAv_GhcpmQecelcIcoxgzLnF1-V4,59
+mapFolding-0.3.3.dist-info/RECORD,,

{mapFolding-0.3.2.dist-info → mapFolding-0.3.3.dist-info}/top_level.txt

@@ -1,3 +1,4 @@
 benchmarks
 reference
 someAssemblyRequired
+syntheticModules

someAssemblyRequired/__init__.py

@@ -1,3 +1,2 @@
-from .countSequential import countSequential
-from .countParallel import countParallel
-from .countInitialize import countInitialize
+from .makeJob import makeStateJob
+from .generalizeSourceCode import makeInlineFunction

someAssemblyRequired/generalizeSourceCode.py

@@ -0,0 +1,121 @@
+from mapFolding import datatypeLargeDEFAULT, datatypeMediumDEFAULT, datatypeSmallDEFAULT
+import ast
+
+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()
+
+    def inlineFunctionBody(self, functionName):
+        if functionName in self.processed:
+            return None
+
+        self.processed.add(functionName)
+        inlineDefinition = self.dictionaryFunctions[functionName]
+        # Recursively process the function body
+        for node in ast.walk(inlineDefinition):
+            self.visit(node)
+        return inlineDefinition
+
+    def visit_Attribute(self, node):
+        # Substitute enum identifiers (e.g., indexMy.leaf1ndex.value)
+        if isinstance(node.value, ast.Attribute) and isinstance(node.value.value, ast.Name):
+            enumPath = f"{node.value.value.id}.{node.value.attr}.{node.attr}"
+            if enumPath in self.dictionaryEnumValues:
+                return ast.Constant(value=self.dictionaryEnumValues[enumPath])
+        return self.generic_visit(node)
+
+    def visit_Call(self, node):
+        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):
+                lastStmt = inlineDefinition.body[-1]
+                if isinstance(lastStmt, ast.Return) and lastStmt.value is not None:
+                    return self.visit(lastStmt.value)
+                elif isinstance(lastStmt, ast.Expr) and lastStmt.value is not None:
+                    return self.visit(lastStmt.value)
+                return None
+        return callNode
+
+    def visit_Expr(self, node):
+        if isinstance(node.value, ast.Call):
+            if isinstance(node.value.func, ast.Name) and node.value.func.id in self.dictionaryFunctions:
+                inlineDefinition = self.inlineFunctionBody(node.value.func.id)
+                if inlineDefinition:
+                    return [self.visit(stmt) for stmt in inlineDefinition.body]
+        return self.generic_visit(node)
+
+def findRequiredImports(node):
+    """Find all modules that need to be imported based on AST analysis.
+    NOTE: due to hardcoding, this is a glorified regex. No, wait, this is less versatile than regex."""
+    requiredImports = set()
+
+    class ImportFinder(ast.NodeVisitor):
+        def visit_Name(self, node):
+            if node.id in {'numba'}:
+                requiredImports.add(node.id)
+            self.generic_visit(node)
+
+        def visitDecorator(self, node):
+            if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
+                if node.func.id == 'jit':
+                    requiredImports.add('numba')
+            self.generic_visit(node)
+
+    ImportFinder().visit(node)
+    return requiredImports
+
+def generateImports(requiredImports):
+    """Generate import statements based on required modules."""
+    importStatements = {'import numba', 'from mapFolding import indexMy, indexTrack'}
+
+    importMapping = {
+        'numba': 'import numba',
+    }
+
+    for moduleName in sorted(requiredImports):
+        if moduleName in importMapping:
+            importStatements.add(importMapping[moduleName])
+
+    return '\n'.join(importStatements)
+
+def makeInlineFunction(sourceCode, targetFunctionName, dictionaryEnumValues, skipEnum=False, **keywordArguments):
+    datatypeLarge = keywordArguments.get('datatypeLarge', datatypeLargeDEFAULT)
+    datatypeMedium = keywordArguments.get('datatypeMedium', datatypeMediumDEFAULT)
+    datatypeSmall = keywordArguments.get('datatypeSmall', datatypeSmallDEFAULT)
+    if skipEnum:
+        dictionaryEnumValues = {}
+    dictionaryParsed = ast.parse(sourceCode)
+    dictionaryFunctions = {
+        element.name: element
+        for element in dictionaryParsed.body
+        if isinstance(element, ast.FunctionDef)
+    }
+    nodeTarget = dictionaryFunctions[targetFunctionName]
+    nodeInliner = RecursiveInlinerWithEnum(dictionaryFunctions, dictionaryEnumValues)
+    nodeInlined = nodeInliner.visit(nodeTarget)
+    ast.fix_missing_locations(nodeInlined)
+    callableInlinedDecorators = [decorator for decorator in nodeInlined.decorator_list]
+
+    requiredImports = findRequiredImports(nodeInlined)
+    importStatements = generateImports(requiredImports)
+    importsRequired = importStatements
+    dictionaryDecoratorsNumba={
+        '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',
+        }
+
+    lineNumbaDecorator = dictionaryDecoratorsNumba[targetFunctionName]
+
+    # inlinedCode = ast.unparse(ast.Module(body=[nodeInlined], type_ignores=[]))
+    callableInlined = lineNumbaDecorator + ast.unparse(nodeInlined)
+    return (callableInlined, callableInlinedDecorators, importsRequired)

someAssemblyRequired/makeJob.py

@@ -0,0 +1,19 @@
+from mapFolding import getPathFilenameFoldsTotal
+from mapFolding import outfitCountFolds
+from typing import Any, Optional, Sequence, Type
+import pathlib
+import pickle
+
+def makeStateJob(listDimensions: Sequence[int], **keywordArguments: Optional[Type[Any]]) -> pathlib.Path:
+    from syntheticModules import countInitialize
+    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

someAssemblyRequired/synthesizeJob.py

@@ -1,10 +1,12 @@
-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
+from mapFolding import getPathFilenameFoldsTotal
+from mapFolding import make_dtype, datatypeLargeDEFAULT, datatypeMediumDEFAULT, datatypeSmallDEFAULT, datatypeModuleDEFAULT
+from mapFolding import computationState
+from someAssemblyRequired import makeStateJob
+from typing import Optional
 import more_itertools
 import inspect
+import importlib
+import importlib.util
 import numpy
 import pathlib
 import pickle
@@ -12,20 +14,7 @@ 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 makeStrRLEcompacted(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])]
@@ -54,22 +43,25 @@ def convertNDArrayToStr(arrayTarget: numpy.ndarray, identifierName: str) -> str:
     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)
+    datatypeLarge = keywordArguments.get('datatypeLarge', datatypeLargeDEFAULT)
+    datatypeMedium = keywordArguments.get('datatypeMedium', datatypeMediumDEFAULT)
+    datatypeSmall = keywordArguments.get('datatypeSmall', datatypeSmallDEFAULT)
+    datatypeModule = keywordArguments.get('datatypeModule', datatypeModuleDEFAULT)
 
-    numpy_dtypeLarge = make_dtype(datatypeLargeAsStr) # type: ignore
-    numpy_dtypeMedium = make_dtype(datatypeMediumAsStr) # type: ignore
-    numpy_dtypeSmall = make_dtype(datatypeSmallAsStr) # type: ignore
+    dtypeLarge = make_dtype(datatypeLarge, datatypeModule) # type: ignore
+    dtypeMedium = make_dtype(datatypeMedium, datatypeModule) # type: ignore
+    dtypeSmall = make_dtype(datatypeSmall, datatypeModule) # type: ignore
 
-    pathFilenameJob = makeStateJob(listDimensions, dtypeLarge = numpy_dtypeLarge, dtypeMedium = numpy_dtypeMedium, dtypeSmall = numpy_dtypeSmall)
+    pathFilenameJob = makeStateJob(listDimensions, dtypeLarge = dtypeLarge, dtypeMedium = dtypeMedium, dtypeSmall = dtypeSmall)
     stateJob: computationState = pickle.loads(pathFilenameJob.read_bytes())
     pathFilenameFoldsTotal = getPathFilenameFoldsTotal(stateJob['mapShape'], pathFilenameJob.parent)
 
-    codeSource = inspect.getsource(countSequential)
+    from syntheticModules import countSequential
+    algorithmSource = countSequential
+    codeSource = inspect.getsource(algorithmSource)
 
     # forceinline=True might actually be useful
-    parametersNumba = f"numba.types.{datatypeLargeAsStr}(), \
+    parametersNumba = f"numba.types.{datatypeLarge}(), \
 cache=True, \
 nopython=True, \
 fastmath=True, \
@@ -96,14 +88,14 @@ no_cpython_wrapper=False, \
     ImaIndent = '    '
     linesDataDynamic = """"""
     linesDataDynamic = "\n".join([linesDataDynamic
-            , ImaIndent + f"foldsTotal = numba.types.{datatypeLargeAsStr}(0)"
-            , ImaIndent + convertNDArrayToStr(stateJob['foldGroups'], 'foldGroups')
-            , ImaIndent + convertNDArrayToStr(stateJob['gapsWhere'], 'gapsWhere')
+            , ImaIndent + f"foldsTotal = numba.types.{datatypeLarge}(0)"
+            , ImaIndent + makeStrRLEcompacted(stateJob['foldGroups'], 'foldGroups')
+            , ImaIndent + makeStrRLEcompacted(stateJob['gapsWhere'], 'gapsWhere')
             ])
 
     linesDataStatic = """"""
     linesDataStatic = "\n".join([linesDataStatic
-            , ImaIndent + convertNDArrayToStr(stateJob['connectionGraph'], 'connectionGraph')
+            , ImaIndent + makeStrRLEcompacted(stateJob['connectionGraph'], 'connectionGraph')
             ])
 
     my = stateJob['my']
@@ -127,7 +119,7 @@ no_cpython_wrapper=False, \
         elif 'track[indexTrack.' in lineSource:
             # leafAbove = track[indexTrack.leafAbove.value]
             identifier, statement = lineSource.split('=')
-            lineSource = ImaIndent + convertNDArrayToStr(eval(statement.strip()), identifier.strip())
+            lineSource = ImaIndent + makeStrRLEcompacted(eval(statement.strip()), identifier.strip())
 
         linesAlgorithm = "\n".join([linesAlgorithm
                             , lineSource
@@ -163,8 +155,16 @@ if __name__ == '__main__':
     return pathFilenameDestination
 
 if __name__ == '__main__':
-    listDimensions = [3,15]
+    listDimensions = [6,6]
     datatypeLarge = 'int64'
     datatypeMedium = 'uint8'
     datatypeSmall = datatypeMedium
-    writeModuleWithNumba(listDimensions, datatypeLarge=datatypeLarge, datatypeMedium=datatypeMedium, datatypeSmall=datatypeSmall)
+    pathFilenameModule = writeModuleWithNumba(listDimensions, datatypeLarge=datatypeLarge, datatypeMedium=datatypeMedium, datatypeSmall=datatypeSmall)
+    # Induce numba.jit compilation
+    moduleSpec = importlib.util.spec_from_file_location(pathFilenameModule.stem, pathFilenameModule)
+    if moduleSpec is None:
+        raise ImportError(f"Could not load module specification from {pathFilenameModule}")
+    module = importlib.util.module_from_spec(moduleSpec)
+    if moduleSpec.loader is None:
+        raise ImportError(f"Could not load module from {moduleSpec}")
+    moduleSpec.loader.exec_module(module)

someAssemblyRequired/synthesizeModules.py

@@ -1,18 +1,10 @@
-from mapFolding import indexMy, indexTrack, theDao, datatypeMedium, datatypeLarge, datatypeSmall
-import ast
+from mapFolding import indexMy, indexTrack, getAlgorithmSource
+from mapFolding import datatypeLargeDEFAULT, datatypeMediumDEFAULT, datatypeSmallDEFAULT
+from someAssemblyRequired import makeInlineFunction
 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',
-    }
+algorithmSource = getAlgorithmSource()
 
 def getDictionaryEnumValues():
     dictionaryEnumValues = {}
@@ -21,110 +13,6 @@ def getDictionaryEnumValues():
             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()
-
-    def inlineFunctionBody(self, functionName):
-        if functionName in self.processed:
-            return None
-
-        self.processed.add(functionName)
-        inlineDefinition = self.dictionaryFunctions[functionName]
-        # Recursively process the function body
-        for node in ast.walk(inlineDefinition):
-            self.visit(node)
-        return inlineDefinition
-
-    def visit_Attribute(self, node):
-        # Substitute enum identifiers (e.g., indexMy.leaf1ndex.value)
-        if isinstance(node.value, ast.Attribute) and isinstance(node.value.value, ast.Name):
-            enumPath = f"{node.value.value.id}.{node.value.attr}.{node.attr}"
-            if enumPath in self.dictionaryEnumValues:
-                return ast.Constant(value=self.dictionaryEnumValues[enumPath])
-        return self.generic_visit(node)
-
-    def visit_Call(self, node):
-        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):
-                lastStmt = inlineDefinition.body[-1]
-                if isinstance(lastStmt, ast.Return) and lastStmt.value is not None:
-                    return self.visit(lastStmt.value)
-                elif isinstance(lastStmt, ast.Expr) and lastStmt.value is not None:
-                    return self.visit(lastStmt.value)
-                return None
-        return callNode
-
-    def visit_Expr(self, node):
-        if isinstance(node.value, ast.Call):
-            if isinstance(node.value.func, ast.Name) and node.value.func.id in self.dictionaryFunctions:
-                inlineDefinition = self.inlineFunctionBody(node.value.func.id)
-                if inlineDefinition:
-                    return [self.visit(stmt) for stmt in inlineDefinition.body]
-        return self.generic_visit(node)
-
-def findRequiredImports(node):
-    """Find all modules that need to be imported based on AST analysis.
-    NOTE: due to hardcoding, this is a glorified regex. No, wait, this is less versatile than regex."""
-    requiredImports = set()
-
-    class ImportFinder(ast.NodeVisitor):
-        def visit_Name(self, node):
-            if node.id in {'numba'}:
-                requiredImports.add(node.id)
-            self.generic_visit(node)
-
-        def visitDecorator(self, node):
-            if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
-                if node.func.id == 'jit':
-                    requiredImports.add('numba')
-            self.generic_visit(node)
-
-    ImportFinder().visit(node)
-    return requiredImports
-
-def generateImports(requiredImports):
-    """Generate import statements based on required modules."""
-    importStatements = {'import numba', 'from mapFolding import indexMy, indexTrack'}
-
-    importMapping = {
-        'numba': 'import numba',
-    }
-
-    for moduleName in sorted(requiredImports):
-        if moduleName in importMapping:
-            importStatements.add(importMapping[moduleName])
-
-    return '\n'.join(importStatements)
-
-def inlineFunctions(sourceCode, targetFunctionName, dictionaryEnumValues, skipEnum=False):
-    if skipEnum:
-        dictionaryEnumValues = {}
-    dictionaryParsed = ast.parse(sourceCode)
-    dictionaryFunctions = {
-        element.name: element
-        for element in dictionaryParsed.body
-        if isinstance(element, ast.FunctionDef)
-    }
-    nodeTarget = dictionaryFunctions[targetFunctionName]
-    nodeInliner = RecursiveInlinerWithEnum(dictionaryFunctions, dictionaryEnumValues)
-    nodeInlined = nodeInliner.visit(nodeTarget)
-    ast.fix_missing_locations(nodeInlined)
-
-    requiredImports = findRequiredImports(nodeInlined)
-    importStatements = generateImports(requiredImports)
-
-    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',
@@ -166,7 +54,10 @@ def unpackArrays(codeInlined: str, callableTarget: str) -> str:
 
     return codeInlined
 
-def Z0Z_inlineMapFolding():
+def inlineMapFoldingNumba(**keywordArguments):
+    datatypeLarge = keywordArguments.get('datatypeLarge', datatypeLargeDEFAULT)
+    datatypeMedium = keywordArguments.get('datatypeMedium', datatypeMediumDEFAULT)
+    datatypeSmall = keywordArguments.get('datatypeSmall', datatypeSmallDEFAULT)
     dictionaryEnumValues = getDictionaryEnumValues()
     codeSource = inspect.getsource(algorithmSource)
     pathFilenameAlgorithm = pathlib.Path(inspect.getfile(algorithmSource))
@@ -177,11 +68,11 @@ def Z0Z_inlineMapFolding():
     for callableTarget in listCallables:
         skipEnum = (callableTarget == 'countInitialize')
         skipEnum = (callableTarget == 'countSequential')
-        pathFilenameDestination = pathFilenameAlgorithm.parent / "someAssemblyRequired" / pathFilenameAlgorithm.with_stem(callableTarget).name
-        codeInlined = inlineFunctions(codeSource, callableTarget, dictionaryEnumValues, skipEnum)
+        pathFilenameDestination = pathFilenameAlgorithm.parent / "syntheticModules" / pathFilenameAlgorithm.with_stem(callableTarget).name
+        codeInlined, callableInlinedDecorators, importsRequired = makeInlineFunction(codeSource, callableTarget, dictionaryEnumValues, skipEnum, datatypeLarge=datatypeLarge, datatypeMedium=datatypeMedium, datatypeSmall=datatypeSmall)
         codeUnpacked = unpackArrays(codeInlined, callableTarget)
-        pathFilenameDestination.write_text(codeUnpacked)
+        pathFilenameDestination.write_text(importsRequired + "\n" + codeUnpacked)
         listPathFilenamesDestination.append(pathFilenameDestination)
 
 if __name__ == '__main__':
-    Z0Z_inlineMapFolding()
+    inlineMapFoldingNumba()

syntheticModules/__init__.py

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

{someAssemblyRequired → syntheticModules}/countInitialize.py

@@ -1,6 +1,5 @@
 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:

{someAssemblyRequired → syntheticModules}/countParallel.py

@@ -1,6 +1,5 @@
 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]):

{someAssemblyRequired → syntheticModules}/countSequential.py

@@ -1,6 +1,5 @@
 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

mapFolding-0.3.2.dist-info/RECORD

@@ -1,22 +0,0 @@
-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.2.dist-info/METADATA,sha256=ejEa_RncO5HszEWrbPK7VdUPEvJaufxfQVVsLm46fdA,7526
-mapFolding-0.3.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapFolding-0.3.2.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapFolding-0.3.2.dist-info/top_level.txt,sha256=yHhQq-bIJhB4pZcof5hXDTIjan0nxcFuOEWb7gy1DuU,42
-mapFolding-0.3.2.dist-info/RECORD,,