mapFolding 0.3.2__tar.gz → 0.3.4__tar.gz

{mapfolding-0.3.2 → mapfolding-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.3.2
+Version: 0.3.4
 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,12 +29,14 @@ Requires-Dist: jupyter; extra == "benchmark"
 Requires-Dist: pandas; extra == "benchmark"
 Requires-Dist: tqdm; extra == "benchmark"
 Provides-Extra: testing
+Requires-Dist: cffconvert; 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"
+Requires-Dist: tomli; extra == "testing"
 
 # Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
 
@@ -52,7 +54,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.2 → mapfolding-0.3.4}/README.md

@@ -14,7 +14,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.4/mapFolding/citations/updateCitation.py

@@ -0,0 +1,67 @@
+from cffconvert.cli.create_citation import create_citation
+from typing import Any, Dict
+import cffconvert
+import pathlib
+import tomli
+import inspect
+import json
+
+"""
+Tentative plan:
+- Commit and push to GitHub
+- GitHub Action gathers information from the sources of truth
+- If the citation needs to be updated, write to both
+    - pathFilenameCitationSSOT
+    - pathFilenameCitationDOTcffRepo
+- Commit and push to GitHub
+    - this complicates things
+    - I want the updated citation to be in the `commit` field of itself
+"""
+
+"""cffconvert.Citation fields and the source of truth
+abstract: pathFilenameCitationSSOT
+authors: pathFilenamePackageSSOT
+cff-version: pathFilenameCitationSSOT
+commit: workflows['Make GitHub Release']
+contact: pathFilenamePackageSSOT
+date-released: workflows['Make GitHub Release']
+doi: pathFilenameCitationSSOT
+identifiers: workflows['Make GitHub Release']
+keywords: pathFilenamePackageSSOT
+license: pathFilenamePackageSSOT
+license-url: pathFilenamePackageSSOT
+message: pathFilenameCitationSSOT
+preferred-citation: pathFilenameCitationSSOT
+references: to be determined
+repository: pathFilenamePackageSSOT
+repository-artifact: (https://pypi.org/pypi/{package_name}/json').json()['releases']
+repository-code: workflows['Make GitHub Release']
+title: pathFilenamePackageSSOT
+type: pathFilenameCitationSSOT
+url: pathFilenamePackageSSOT
+version: pathFilenamePackageSSOT
+"""
+# Prefer reliable, dynamic values over hardcoded ones
+packageName: str = 'mapFolding'
+pathRepoRoot = pathlib.Path(__file__).parent.parent.parent
+pathFilenamePackageSSOT = pathRepoRoot / 'pyproject.toml'
+
+filenameGitHubAction = 'updateCitation.yml'
+pathFilenameGitHubAction = pathRepoRoot / '.github' / 'workflows' / filenameGitHubAction
+
+filenameCitationDOTcff = 'CITATION.cff'
+pathCitations = pathRepoRoot / packageName / 'citations'
+pathFilenameCitationSSOT = pathCitations / filenameCitationDOTcff
+pathFilenameCitationDOTcffRepo = pathRepoRoot / filenameCitationDOTcff
+
+tomlPackageData: Dict[str, Any] = tomli.loads(pathFilenamePackageSSOT.read_text())['project']
+
+citationObject: cffconvert.Citation = create_citation(infile=pathFilenameCitationSSOT, url=None)
+
+path_cffconvert = pathlib.Path(inspect.getfile(cffconvert)).parent
+pathFilenameSchema = path_cffconvert / "schemas/1.2.0/schema.json"
+scheme: Dict[str, Any] = json.loads(pathFilenameSchema.read_text())
+schemaSpecifications: Dict[str, Any] = scheme['properties']
+
+for property, subProperties in schemaSpecifications.items():
+    print(property, subProperties.get('items', None))

{mapfolding-0.3.2 → mapfolding-0.3.4}/mapFolding/mapFolding.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.3.2
+Version: 0.3.4
 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,12 +29,14 @@ Requires-Dist: jupyter; extra == "benchmark"
 Requires-Dist: pandas; extra == "benchmark"
 Requires-Dist: tqdm; extra == "benchmark"
 Provides-Extra: testing
+Requires-Dist: cffconvert; 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"
+Requires-Dist: tomli; extra == "testing"
 
 # Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
 
@@ -52,7 +54,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.2 → mapfolding-0.3.4}/mapFolding/mapFolding.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 README.md
 pyproject.toml
 mapFolding/benchmarks/benchmarking.py
+mapFolding/citations/updateCitation.py
 mapFolding/mapFolding.egg-info/PKG-INFO
 mapFolding/mapFolding.egg-info/SOURCES.txt
 mapFolding/mapFolding.egg-info/dependency_links.txt
@@ -17,12 +18,15 @@ mapFolding/reference/lunnanWhile.py
 mapFolding/reference/rotatedEntryPoint.py
 mapFolding/reference/total_countPlus1vsPlusN.py
 mapFolding/someAssemblyRequired/__init__.py
-mapFolding/someAssemblyRequired/countInitialize.py
-mapFolding/someAssemblyRequired/countParallel.py
-mapFolding/someAssemblyRequired/countSequential.py
+mapFolding/someAssemblyRequired/generalizeSourceCode.py
 mapFolding/someAssemblyRequired/getLLVMforNoReason.py
-mapFolding/someAssemblyRequired/synthesizeJob.py
+mapFolding/someAssemblyRequired/makeJob.py
+mapFolding/someAssemblyRequired/synthesizeModuleJob.py
 mapFolding/someAssemblyRequired/synthesizeModules.py
+mapFolding/syntheticModules/__init__.py
+mapFolding/syntheticModules/countInitialize.py
+mapFolding/syntheticModules/countParallel.py
+mapFolding/syntheticModules/countSequential.py
 tests/test_oeis.py
 tests/test_other.py
 tests/test_tasks.py

{mapfolding-0.3.2 → mapfolding-0.3.4}/mapFolding/mapFolding.egg-info/requires.txt

@@ -9,9 +9,11 @@ pandas
 tqdm
 
 [testing]
+cffconvert
 more_itertools
 pytest
 pytest-cov
 pytest-env
 pytest-xdist
 python_minifier
+tomli

{mapfolding-0.3.2 → mapfolding-0.3.4}/mapFolding/mapFolding.egg-info/top_level.txt

@@ -2,3 +2,4 @@ benchmarks
 citations
 reference
 someAssemblyRequired
+syntheticModules

mapfolding-0.3.4/mapFolding/someAssemblyRequired/__init__.py

@@ -0,0 +1,2 @@
+from .makeJob import makeStateJob
+# from .generalizeSourceCode import makeInlineFunction

mapfolding-0.3.4/mapFolding/someAssemblyRequired/generalizeSourceCode.py

@@ -0,0 +1,122 @@
+from mapFolding import datatypeLargeDEFAULT, datatypeMediumDEFAULT, datatypeSmallDEFAULT
+from typing import Dict, Optional, List, Set, Union
+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: Dict[str, ast.FunctionDef], dictionaryEnumValues: Dict[str, int]) -> None:
+        self.dictionaryFunctions = dictionaryFunctions
+        self.dictionaryEnumValues = dictionaryEnumValues
+        self.processed = set()
+
+    def inlineFunctionBody(self, functionName: str) -> Optional[ast.FunctionDef]:
+        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: ast.Attribute) -> ast.AST:
+        # 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: ast.Call) -> ast.AST:
+        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 ast.Constant(value=None)
+        return callNode
+
+    def visit_Expr(self, node: ast.Expr) -> Union[ast.AST, List[ast.AST]]:
+        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: ast.AST) -> Set[str]:
+    """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: ast.Name) -> None:
+            if node.id in {'numba'}:
+                requiredImports.add(node.id)
+            self.generic_visit(node)
+
+        def visitDecorator(self, node: ast.AST) -> None:
+            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: Set[str]) -> str:
+    """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: str, targetFunctionName: str, dictionaryEnumValues: Dict[str, int], skipEnum: bool=False, **keywordArguments: Optional[str]):
+    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)

mapfolding-0.3.4/mapFolding/someAssemblyRequired/makeJob.py

@@ -0,0 +1,21 @@
+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:
+
+    stateUniversal = outfitCountFolds(listDimensions, computationDivisions=None, CPUlimit=None, **keywordArguments)
+
+    from syntheticModules import countInitialize
+    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

mapfolding-0.3.2/mapFolding/someAssemblyRequired/synthesizeJob.py → mapfolding-0.3.4/mapFolding/someAssemblyRequired/synthesizeModuleJob.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)

mapfolding-0.3.4/mapFolding/someAssemblyRequired/synthesizeModules.py

@@ -0,0 +1,170 @@
+from mapFolding import indexMy, indexTrack, getAlgorithmSource, ParametersNumba, parametersNumbaDEFAULT, hackSSOTdtype
+from mapFolding import datatypeLargeDEFAULT, datatypeMediumDEFAULT, datatypeSmallDEFAULT
+import pathlib
+import inspect
+import numpy
+import numba
+from typing import Dict, Optional, List, Set, Union, Sequence
+import ast
+
+algorithmSource = getAlgorithmSource()
+
+class RecursiveInliner(ast.NodeTransformer):
+    def __init__(self, dictionaryFunctions: Dict[str, ast.FunctionDef]):
+        self.dictionaryFunctions = dictionaryFunctions
+        self.processed = set()
+
+    def inlineFunctionBody(self, functionName: str) -> Optional[ast.FunctionDef]:
+        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_Call(self, node: ast.Call) -> ast.AST:
+        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 ast.Constant(value=None)
+        return callNode
+
+    def visit_Expr(self, node: ast.Expr) -> Union[ast.AST, List[ast.AST]]:
+        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 decorateCallableWithNumba(astCallable: ast.FunctionDef, parallel: bool=False, **keywordArguments: Optional[str]):
+    def makeNumbaParameterSignatureElement(signatureElement: ast.arg):
+        if isinstance(signatureElement.annotation, ast.Subscript) and isinstance(signatureElement.annotation.slice, ast.Tuple):
+
+            annotationShape = signatureElement.annotation.slice.elts[0]
+            if isinstance(annotationShape, ast.Subscript) and isinstance(annotationShape.slice, ast.Tuple):
+                shapeAsListSlices = [ast.Slice() for axis in range(len(annotationShape.slice.elts))]
+                shapeAsListSlices[-1] = ast.Slice(step=ast.Constant(value=1))
+                shapeAST = ast.Tuple(elts=shapeAsListSlices, ctx=ast.Load())
+            else:
+                shapeAST = ast.Slice(step=ast.Constant(value=1))
+
+            annotationDtype = signatureElement.annotation.slice.elts[1]
+            if isinstance(annotationDtype, ast.Subscript) and isinstance(annotationDtype.slice, ast.Attribute):
+                datatypeAST = annotationDtype.slice.attr
+            else:
+                datatypeAST = None
+
+            ndarrayName = signatureElement.arg
+            Z0Z_hackyStr = hackSSOTdtype[ndarrayName]
+            Z0Z_hackyStr = Z0Z_hackyStr[0] + 'ata' + Z0Z_hackyStr[1:]
+            datatype_attr = keywordArguments.get(Z0Z_hackyStr, None) or datatypeAST or eval(Z0Z_hackyStr+'DEFAULT')
+
+            datatypeNumba = ast.Attribute(value=ast.Name(id='numba', ctx=ast.Load()), attr=datatype_attr, ctx=ast.Load())
+
+            return ast.Subscript(value=datatypeNumba, slice=shapeAST, ctx=ast.Load())
+
+    # callableSourceDecorators = [decorator for decorator in callableInlined.decorator_list]
+
+    listNumbaParameterSignature: List[ast.Subscript] = []
+    for parameter in astCallable.args.args:
+        signatureElement = makeNumbaParameterSignatureElement(parameter)
+        if signatureElement:
+            listNumbaParameterSignature.append(signatureElement)
+
+    astArgsNumbaSignature = ast.Tuple(elts=listNumbaParameterSignature, ctx=ast.Load())
+
+    parametersNumba = parametersNumbaDEFAULT if not parallel else ParametersNumba({**parametersNumbaDEFAULT, 'parallel': True})
+    listKeywordsNumbaSignature = [ast.keyword(arg=parameterName, value=ast.Constant(value=parameterValue)) for parameterName, parameterValue in parametersNumba.items()]
+
+    astDecoratorNumba = ast.Call(func=ast.Attribute(value=ast.Name(id='numba', ctx=ast.Load()), attr='jit', ctx=ast.Load()), args=[astArgsNumbaSignature], keywords=listKeywordsNumbaSignature)
+
+    astCallable.decorator_list = [astDecoratorNumba]
+    return astCallable
+
+def getDictionaryEnumValues() -> Dict[str, int]:
+    dictionaryEnumValues = {}
+    for enumIndex in [indexMy, indexTrack]:
+        for memberName, memberValue in enumIndex._member_map_.items():
+            dictionaryEnumValues[f"{enumIndex.__name__}.{memberName}.value"] = memberValue.value
+    return dictionaryEnumValues
+
+def unpackArrays(codeInlined: 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 inlineMapFoldingNumba(**keywordArguments: Optional[str]):
+    dictionaryEnumValues = getDictionaryEnumValues()
+    codeSource = inspect.getsource(algorithmSource)
+    pathFilenameAlgorithm = pathlib.Path(inspect.getfile(algorithmSource))
+
+    listPathFilenamesDestination: list[pathlib.Path] = []
+    listCallables = [ 'countInitialize', 'countParallel', 'countSequential', ]
+    for callableTarget in listCallables:
+        codeParsed: ast.Module = ast.parse(codeSource, type_comments=True)
+        codeSourceImportStatements = {statement for statement in codeParsed.body if isinstance(statement, (ast.Import, ast.ImportFrom))}
+        dictionaryFunctions = {statement.name: statement for statement in codeParsed.body if isinstance(statement, ast.FunctionDef)}
+        callableInlinerWorkhorse = RecursiveInliner(dictionaryFunctions)
+        parallel = callableTarget == 'countParallel'
+        callableInlined = callableInlinerWorkhorse.inlineFunctionBody(callableTarget)
+        if callableInlined:
+            ast.fix_missing_locations(callableInlined)
+            callableDecorated = decorateCallableWithNumba(callableInlined, parallel, **keywordArguments)
+
+            importsRequired = "\n".join([ast.unparse(importStatement) for importStatement in codeSourceImportStatements])
+            callableInlined = ast.unparse(callableDecorated)
+            codeUnpacked = unpackArrays(callableInlined) if callableTarget == 'countSequential' else callableInlined
+            # inlinedCode = ast.unparse(ast.Module(body=[nodeInlined], type_ignores=[]))
+
+            pathFilenameDestination = pathFilenameAlgorithm.parent / "syntheticModules" / pathFilenameAlgorithm.with_stem(callableTarget).name
+            pathFilenameDestination.write_text(importsRequired + "\n" + codeUnpacked)
+            listPathFilenamesDestination.append(pathFilenameDestination)
+
+if __name__ == '__main__':
+    inlineMapFoldingNumba()