mapFolding 0.3.4__tar.gz → 0.3.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.3.4
+Version: 0.3.5
 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.3.4
+Version: 0.3.5
 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

mapfolding-0.3.5/mapFolding/someAssemblyRequired/synthesizeModules.py

@@ -0,0 +1,244 @@
+from mapFolding import indexMy, indexTrack, getAlgorithmSource, ParametersNumba, parametersNumbaDEFAULT, hackSSOTdtype
+from mapFolding import datatypeLargeDEFAULT, datatypeMediumDEFAULT, datatypeSmallDEFAULT, EnumIndices
+import pathlib
+import inspect
+import numpy
+import numba
+from typing import Dict, Optional, List, Union, Sequence, Type, cast
+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]) -> ast.FunctionDef:
+    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: Sequence[ast.expr] = [ast.Slice() for axis in range(len(annotationShape.slice.elts))]
+                shapeAsListSlices[-1] = ast.Slice(step=ast.Constant(value=1))
+                shapeAST = ast.Tuple(elts=list(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: Sequence[ast.expr] = []
+    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
+
+class UnpackArrayAccesses(ast.NodeTransformer):
+    """AST transformer that replaces array accesses with simpler variables."""
+
+    def __init__(self, enumIndexClass: Type[EnumIndices], arrayName: str):
+        self.enumIndexClass = enumIndexClass
+        self.arrayName = arrayName
+        self.substitutions = {}
+
+    def extract_member_name(self, node: ast.AST) -> Optional[str]:
+        """Recursively extract enum member name from any node in the AST."""
+        if isinstance(node, ast.Attribute) and node.attr == 'value':
+            innerAttribute = node.value
+            while isinstance(innerAttribute, ast.Attribute):
+                if (isinstance(innerAttribute.value, ast.Name) and innerAttribute.value.id == self.enumIndexClass.__name__):
+                    return innerAttribute.attr
+                innerAttribute = innerAttribute.value
+        return None
+
+    def transform_slice_element(self, node: ast.AST) -> ast.AST:
+        """Transform any enum references within a slice element."""
+        if isinstance(node, ast.Subscript):
+            if isinstance(node.slice, ast.Attribute):
+                member_name = self.extract_member_name(node.slice)
+                if member_name:
+                    return ast.Name(id=member_name, ctx=node.ctx)
+            elif isinstance(node, ast.Tuple):
+                # Handle tuple slices by transforming each element
+                return ast.Tuple(
+                    elts=cast(List[ast.expr], [self.transform_slice_element(elt) for elt in node.elts]),
+                    ctx=node.ctx
+                )
+        elif isinstance(node, ast.Attribute):
+            member_name = self.extract_member_name(node)
+            if member_name:
+                return ast.Name(id=member_name, ctx=ast.Load())
+        return node
+
+    def visit_Subscript(self, node: ast.Subscript) -> ast.AST:
+        # Recursively visit any nested subscripts in value or slice
+        node.value = self.visit(node.value)
+        node.slice = self.visit(node.slice)
+
+        # If node.value is not our arrayName, just return node
+        if not (isinstance(node.value, ast.Name) and node.value.id == self.arrayName):
+            return node
+
+        # Handle scalar array access
+        if isinstance(node.slice, ast.Attribute):
+            memberName = self.extract_member_name(node.slice)
+            if memberName:
+                self.substitutions[memberName] = ('scalar', node)
+                return ast.Name(id=memberName, ctx=ast.Load())
+
+        # Handle array slice access
+        if isinstance(node.slice, ast.Tuple) and node.slice.elts:
+            firstElement = node.slice.elts[0]
+            memberName = self.extract_member_name(firstElement)
+            sliceRemainder = [self.visit(elem) for elem in node.slice.elts[1:]]
+            if memberName:
+                self.substitutions[memberName] = ('array', node)
+                if len(sliceRemainder) == 0:
+                    return ast.Name(id=memberName, ctx=ast.Load())
+                return ast.Subscript(
+                    value=ast.Name(id=memberName, ctx=ast.Load()),
+                    slice=ast.Tuple(elts=sliceRemainder, ctx=ast.Load()) if len(sliceRemainder) > 1 else sliceRemainder[0],
+                    ctx=ast.Load()
+                )
+
+        # If single-element tuple, unwrap
+        if isinstance(node.slice, ast.Tuple) and len(node.slice.elts) == 1:
+            node.slice = node.slice.elts[0]
+
+        return node
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.FunctionDef:
+        node = cast(ast.FunctionDef, self.generic_visit(node))
+
+        initializations = []
+        for name, (kind, original_node) in self.substitutions.items():
+            if kind == 'scalar':
+                initializations.append(
+                    ast.Assign(
+                        targets=[ast.Name(id=name, ctx=ast.Store())],
+                        value=original_node
+                    )
+                )
+            else:  # array
+                initializations.append(
+                    ast.Assign(
+                        targets=[ast.Name(id=name, ctx=ast.Store())],
+                        value=ast.Subscript(
+                            value=ast.Name(id=self.arrayName, ctx=ast.Load()),
+                            slice=ast.Attribute(
+                                value=ast.Attribute(
+                                    value=ast.Name(id=self.enumIndexClass.__name__, ctx=ast.Load()),
+                                    attr=name,
+                                    ctx=ast.Load()
+                                ),
+                                attr='value',
+                                ctx=ast.Load()
+                            ),
+                            ctx=ast.Load()
+                        )
+                    )
+                )
+
+        node.body = initializations + node.body
+        return node
+
+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 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)
+
+            if callableTarget == 'countSequential':
+                myUnpacker = UnpackArrayAccesses(indexMy, 'my')
+                callableDecorated = cast(ast.FunctionDef, myUnpacker.visit(callableDecorated))
+                ast.fix_missing_locations(callableDecorated)
+
+                trackUnpacker = UnpackArrayAccesses(indexTrack, 'track')
+                callableDecorated = cast(ast.FunctionDef, trackUnpacker.visit(callableDecorated))
+                ast.fix_missing_locations(callableDecorated)
+
+            callableInlined = ast.unparse(callableDecorated)
+            importsRequired = "\n".join([ast.unparse(importStatement) for importStatement in codeSourceImportStatements])
+
+            pathFilenameDestination = pathFilenameAlgorithm.parent / "syntheticModules" / pathFilenameAlgorithm.with_stem(callableTarget).name
+            pathFilenameDestination.write_text(importsRequired + "\n" + callableInlined)
+            listPathFilenamesDestination.append(pathFilenameDestination)
+
+if __name__ == '__main__':
+    inlineMapFoldingNumba()

{mapfolding-0.3.4 → mapfolding-0.3.5}/mapFolding/syntheticModules/countInitialize.py

@@ -1,8 +1,8 @@
-from numpy import integer
-import numba
 import numpy
-from mapFolding import indexMy, indexTrack
 from typing import Any, Tuple
+from mapFolding import indexMy, indexTrack
+import numba
+from numpy import integer
 @numba.jit((numba.uint8[:, :, ::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=False, inline='never', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=False)
 def countInitialize(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]):
     while my[indexMy.leaf1ndex.value] > 0:

{mapfolding-0.3.4 → mapfolding-0.3.5}/mapFolding/syntheticModules/countParallel.py

@@ -6,15 +6,15 @@ import numpy
 @numba.jit((numba.uint8[:, :, ::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=False, inline='never', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=True)
 def countParallel(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], foldGroups: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], gapsWherePARALLEL: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], myPARALLEL: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], trackPARALLEL: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]):
     for indexSherpa in numba.prange(myPARALLEL[indexMy.taskDivisions.value]):
+        groupsOfFolds: int = 0
         gapsWhere = gapsWherePARALLEL.copy()
         my = myPARALLEL.copy()
         my[indexMy.taskIndex.value] = indexSherpa
         track = trackPARALLEL.copy()
-        groupsOfFolds: int = 0
         while my[indexMy.leaf1ndex.value] > 0:
             if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
                 if my[indexMy.leaf1ndex.value] > foldGroups[-1]:
-                    groupsOfFolds = groupsOfFolds + 1
+                    groupsOfFolds += 1
                 else:
                     my[indexMy.dimensionsUnconstrained.value] = my[indexMy.dimensionsTotal.value]
                     my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]

{mapfolding-0.3.4 → mapfolding-0.3.5}/mapFolding/syntheticModules/countSequential.py

@@ -5,24 +5,24 @@ from mapFolding import indexMy, indexTrack
 import numpy
 @numba.jit((numba.uint8[:, :, ::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=False, inline='never', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=False)
 def countSequential(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], foldGroups: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]):
-    doFindGaps = True
-    dimensionsTotal = my[indexMy.dimensionsTotal.value]
+    leafBelow = track[indexTrack.leafBelow.value]
+    gapRangeStart = track[indexTrack.gapRangeStart.value]
+    countDimensionsGapped = track[indexTrack.countDimensionsGapped.value]
+    leafAbove = track[indexTrack.leafAbove.value]
+    leaf1ndex = my[indexMy.leaf1ndex.value]
     dimensionsUnconstrained = my[indexMy.dimensionsUnconstrained.value]
-    gap1ndex = my[indexMy.gap1ndex.value]
+    dimensionsTotal = my[indexMy.dimensionsTotal.value]
     gap1ndexCeiling = my[indexMy.gap1ndexCeiling.value]
     indexDimension = my[indexMy.indexDimension.value]
-    indexMiniGap = my[indexMy.indexMiniGap.value]
-    leaf1ndex = my[indexMy.leaf1ndex.value]
     leafConnectee = my[indexMy.leafConnectee.value]
+    indexMiniGap = my[indexMy.indexMiniGap.value]
+    gap1ndex = my[indexMy.gap1ndex.value]
     taskIndex = my[indexMy.taskIndex.value]
-    leafAbove = track[indexTrack.leafAbove.value]
-    leafBelow = track[indexTrack.leafBelow.value]
-    countDimensionsGapped = track[indexTrack.countDimensionsGapped.value]
-    gapRangeStart = track[indexTrack.gapRangeStart.value]
     groupsOfFolds: int = 0
+    doFindGaps = True
     while leaf1ndex > 0:
         if (doFindGaps := (leaf1ndex <= 1 or leafBelow[0] == 1)) and leaf1ndex > foldGroups[-1]:
-            groupsOfFolds = groupsOfFolds + 1
+            groupsOfFolds += 1
         elif doFindGaps:
             dimensionsUnconstrained = dimensionsTotal
             gap1ndexCeiling = gapRangeStart[leaf1ndex - 1]

{mapfolding-0.3.4 → mapfolding-0.3.5}/pyproject.toml

@@ -48,7 +48,7 @@ readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10,<3.14"
 scripts = { getOEISids = "mapFolding.oeis:getOEISids", clearOEIScache = "mapFolding.oeis:clearOEIScache", OEIS_for_n = "mapFolding.oeis:OEIS_for_n" }
 urls = { Homepage = "https://github.com/hunterhogan/mapFolding", Donate = "https://www.patreon.com/integrated" }
-version = "0.3.4"
+version = "0.3.5"
 
 [tool.coverage]
 report = { exclude_lines = [

mapfolding-0.3.4/mapFolding/someAssemblyRequired/synthesizeModules.py

@@ -1,170 +0,0 @@
-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()