mapFolding 0.3.6__py3-none-any.whl → 0.3.8__py3-none-any.whl

syntheticModules/{Parallel.py → numbaParallel.py}

@@ -1,13 +1,17 @@
-from numpy import integer
 from typing import Any, Tuple
-import numba
-from mapFolding import indexMy, indexTrack
+from numpy import integer
 import numpy
+from mapFolding import indexMy, indexTrack
+import numba
 
 @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 = numba.types.int64(0)
+def countParallel(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]]]):
+    gapsWherePARALLEL = gapsWhere.copy()
+    myPARALLEL = my.copy()
+    trackPARALLEL = track.copy()
+    taskDivisionsPrange = myPARALLEL[indexMy.taskDivisions.value]
+    for indexSherpa in numba.prange(taskDivisionsPrange):
+        groupsOfFolds: int = 0
         gapsWhere = gapsWherePARALLEL.copy()
         my = myPARALLEL.copy()
         my[indexMy.taskIndex.value] = indexSherpa

syntheticModules/{Sequential.py → numbaSequential.py}

@@ -1,8 +1,8 @@
-from numpy import integer
-import numba
 from typing import Any, Tuple
-from mapFolding import indexMy, indexTrack
+from numpy import integer
 import numpy
+from mapFolding import indexMy, indexTrack
+import numba
 
 @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]]]):
@@ -19,7 +19,7 @@ def countSequential(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.d
     indexMiniGap = my[indexMy.indexMiniGap.value]
     gap1ndex = my[indexMy.gap1ndex.value]
     taskIndex = my[indexMy.taskIndex.value]
-    groupsOfFolds = numba.types.int64(0)
+    groupsOfFolds: int = 0
     doFindGaps = True
     while leaf1ndex:
         if (doFindGaps := (leaf1ndex <= 1 or leafBelow[0] == 1)) and leaf1ndex > foldGroups[-1]:

citations/updateCitationgpt.py

@@ -1,125 +0,0 @@
-from cffconvert.cli.create_citation import create_citation
-from cffconvert.cli.validate_or_write_output import validate_or_write_output
-from typing import Any, Dict
-import cffconvert
-import pathlib
-import packaging.metadata
-import tomli
-import ruamel.yaml
-import packaging
-from packaging.metadata import Metadata as PyPAMetadata
-import packaging.utils
-import packaging.version
-
-def addPypaMetadata(citation: cffconvert.Citation, metadata: PyPAMetadata) -> cffconvert.Citation:
-    """
-    Map the PyPA metadata to the citation's internal representation.
-
-    Mapping:
-      - title: metadata.name
-      - version: metadata.version (converted to string)
-      - keywords: metadata.keywords
-      - license: metadata.license_expression
-      - url: from project URLs (homepage)
-      - repository: from project URLs (repository)
-    """
-    # Access the internal dictionary (used for conversion)
-    citationData: Dict[str, Any] = citation._cffobj
-
-    # Update title from PyPA metadata name
-    if metadata.name:
-        citationData["title"] = metadata.name
-
-    # Update version from PyPA metadata version
-    if metadata.version:
-        citationData["version"] = str(metadata.version)
-
-    # Update keywords from PyPA metadata keywords
-    if metadata.keywords:
-        citationData["keywords"] = metadata.keywords
-
-    # Update license from PyPA metadata license_expression
-    if metadata.license_expression:
-        citationData["license"] = metadata.license_expression
-
-    # Retrieve the project URLs that were attached in getPypaMetadata
-    projectURLs: Dict[str, str] = getattr(metadata, "_project_urls", {})
-
-    # Update the homepage URL
-    if "homepage" in projectURLs:
-        citationData["url"] = projectURLs["homepage"]
-
-    # Update the repository URL
-    if "repository" in projectURLs:
-        citationData["repository"] = projectURLs["repository"]
-
-    return citation
-
-def getPypaMetadata(packageData: Dict[str, Any]) -> PyPAMetadata:
-    """
-    Create a PyPA metadata object (version 2.4) from packageData.
-
-    Mapping for project URLs:
-      - 'homepage' and 'repository' are accepted from packageData['urls'].
-    """
-    dictionaryProjectURLs: Dict[str, str] = {}
-    for urlKey, urlValue in packageData.get("urls", {}).items():
-        lowerUrlKey = urlKey.lower()
-        if lowerUrlKey in ("homepage", "repository"):
-            dictionaryProjectURLs[lowerUrlKey] = urlValue
-
-    metadataRaw = packaging.metadata.RawMetadata(
-        keywords=packageData.get("keywords", []),
-        license_expression=packageData.get("license", {}).get("text", ""),
-        metadata_version="2.4",
-        name=packaging.utils.canonicalize_name(packageData.get("name", None), validate=True),
-        project_urls=dictionaryProjectURLs,
-        version=packageData.get("version", None),
-    )
-
-    metadata = PyPAMetadata().from_raw(metadataRaw)
-    # Attach the project URLs dictionary so it can be used later.
-    setattr(metadata, "_project_urls", dictionaryProjectURLs)
-    return metadata
-
-def logistics():
-    # Determine paths from your SSOT.
-    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
-
-    # Create a citation object from the SSOT citation file.
-    citationObject: cffconvert.Citation = create_citation(infile=pathFilenameCitationSSOT, url=None)
-    # Print the current citation in CFF format (for debugging) using the as_cff method.
-    print(citationObject.as_cff())
-
-    # Load package metadata from pyproject.toml.
-    tomlPackageData: Dict[str, Any] = tomli.loads(pathFilenamePackageSSOT.read_text())["project"]
-    pypaMetadata: PyPAMetadata = getPypaMetadata(tomlPackageData)
-
-    # Map the PyPA metadata into the citation's internal representation.
-    citationObject = addPypaMetadata(citation=citationObject, metadata=pypaMetadata)
-
-    # Validate and write out the updated citation file in both locations.
-    # validate_or_write_output(
-    #     outfile=pathFilenameCitationSSOT,
-    #     outputformat="cff",
-    #     validate_only=False,
-    #     citation=citationObject,
-    # )
-    validate_or_write_output(
-        outfile=pathFilenameCitationDOTcffRepo,
-        outputformat="cff",
-        validate_only=False,
-        citation=citationObject,
-    )
-
-if __name__ == "__main__":
-    logistics()

mapFolding-0.3.6.dist-info/RECORD

@@ -1,27 +0,0 @@
-benchmarks/benchmarking.py,sha256=HD_0NSvuabblg94ftDre6LFnXShTe8MYj3hIodW-zV0,3076
-citations/updateCitation.py,sha256=PPxOERlYnw9b9xydiZL8utTU-sC2B4rBfOgjXc1S0OY,5264
-citations/updateCitationgpt.py,sha256=NtgSP4BCO5YcaYcYYb31vOxXcp3hmooug8VYpbhTc_w,4751
-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=3JnAKXfaYPtmxV_4AnZ6KpCosT_0GFV5Nw7K8sz4-Uo,34
-someAssemblyRequired/generalizeSourceCode.py,sha256=qyJD0ZdG0t-SYTItL_JjaIXm3-joWt3e-2nMSAH4Dbg,6392
-someAssemblyRequired/getLLVMforNoReason.py,sha256=FtJzw2pZS3A4NimWdZsegXaU-vKeCw8m67kcfb5wvGM,894
-someAssemblyRequired/makeJob.py,sha256=RTC80FhDrR19GqHtEeo6GpmlWZQESuf8FXqBqVzdOpk,1465
-someAssemblyRequired/synthesizeModuleJob.py,sha256=uyODwdI1_a76Pu21JsCNEapVW78yUD-CfInX-vg8U-w,7419
-someAssemblyRequired/synthesizeModules.py,sha256=foxk-mG-HGVap2USiA3ppCyWWXUmkLFzQiKacp5DD9M,11569
-syntheticModules/Initialize.py,sha256=KIAxLSyblzDTL8QJYINmdRjk2iRVYzXOWeqY8P6wPgw,4024
-syntheticModules/Parallel.py,sha256=Kq1uo5kfeeczk871yxaagsaNz8zaM8GWy0S3hZAEQz4,5343
-syntheticModules/Sequential.py,sha256=JwpHNFt_w77J0RBVoBji-OLnYNSTMnusRlYU-6b4P2w,3643
-syntheticModules/__init__.py,sha256=lUDBXOiislfP2sIxT13_GZgElaytoYqk0ODUsucMYew,117
-mapFolding-0.3.6.dist-info/METADATA,sha256=ViqnejEpnb4391VOp-nqnGXqyAwaXiqwUx3wpZbqyxM,7688
-mapFolding-0.3.6.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapFolding-0.3.6.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapFolding-0.3.6.dist-info/top_level.txt,sha256=yVG9dNZywoaddcsUdEDg7o0XOBzJd_4Z-sDaXGHpiMY,69
-mapFolding-0.3.6.dist-info/RECORD,,

someAssemblyRequired/generalizeSourceCode.py

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

someAssemblyRequired/synthesizeModules.py

@@ -1,216 +0,0 @@
-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())
-
-    if astCallable.name == 'countInitialize':
-        parametersNumba = {}
-    else:
-        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 inlineMapFoldingNumba(**keywordArguments: Optional[str]):
-    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)
-
-            moduleAST = ast.Module(body=cast(List[ast.stmt], list(codeSourceImportStatements) + [callableDecorated]), type_ignores=[])
-            ast.fix_missing_locations(moduleAST)
-            moduleSource = ast.unparse(moduleAST)
-
-            pathFilenameDestination = pathFilenameAlgorithm.parent / "syntheticModules" / pathFilenameAlgorithm.with_stem(callableTarget).name[5:None]
-            pathFilenameDestination.write_text(moduleSource)
-            listPathFilenamesDestination.append(pathFilenameDestination)
-
-if __name__ == '__main__':
-    inlineMapFoldingNumba()