mapFolding 0.2.2__tar.gz → 0.2.4__tar.gz

{mapfolding-0.2.2 → mapfolding-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.2.2
+Version: 0.2.4
 Summary: Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 Project-URL: homepage, https://github.com/hunterhogan/mapFolding
@@ -22,10 +22,12 @@ Requires-Dist: pytest; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: pytest-env; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
+Requires-Dist: pytest-order; extra == "testing"
+Requires-Dist: pytest-dependency; extra == "testing"
 
 # Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
 
-`mapFolding.countFolds()` will accept arbitrary values for the map's dimensions.
+The function `mapFolding.countFolds()` counts distinct ways to fold maps and strips of stamps. The function accepts two or more dimensions:
 
 ```python
 from mapFolding import countFolds
@@ -34,12 +36,12 @@ foldsTotal = countFolds( [2,10] )
 
 The directory [mapFolding/reference](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/reference) has
 
-- a verbatim transcription of the "procedure" published in _The Computer Journal_,
+- a verbatim transcription of Lunnon's "procedure" published in 1971 by _The Computer Journal_,
 - multiple referential versions of the procedure with explanatory comments including
 - [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.
 
-[![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml)
+[![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml) [![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/) ![Static Badge](https://img.shields.io/badge/stinkin'%20badges-don't%20need-b98e5e) ![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.2.2 → mapfolding-0.2.4}/README.md

@@ -1,6 +1,6 @@
 # Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
 
-`mapFolding.countFolds()` will accept arbitrary values for the map's dimensions.
+The function `mapFolding.countFolds()` counts distinct ways to fold maps and strips of stamps. The function accepts two or more dimensions:
 
 ```python
 from mapFolding import countFolds
@@ -9,12 +9,12 @@ foldsTotal = countFolds( [2,10] )
 
 The directory [mapFolding/reference](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/reference) has
 
-- a verbatim transcription of the "procedure" published in _The Computer Journal_,
+- a verbatim transcription of Lunnon's "procedure" published in 1971 by _The Computer Journal_,
 - multiple referential versions of the procedure with explanatory comments including
 - [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.
 
-[![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml)
+[![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml) [![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/) ![Static Badge](https://img.shields.io/badge/stinkin'%20badges-don't%20need-b98e5e) ![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.2.2 → mapfolding-0.2.4}/mapFolding/__init__.py

@@ -1,7 +1,6 @@
 from .theSSOT import *
 from Z0Z_tools import defineConcurrencyLimit, intInnit, oopsieKwargsie
-from .beDRY import getTaskDivisions, makeConnectionGraph, outfitFoldings, setCPUlimit
-from .beDRY import getLeavesTotal, parseDimensions, validateListDimensions
+from .beDRY import getFilenameFoldsTotal, outfitCountFolds
 from .startHere import countFolds
 from .oeis import oeisIDfor_n, getOEISids, clearOEIScache
 

{mapfolding-0.2.2 → mapfolding-0.2.4}/mapFolding/babbage.py

@@ -1,4 +1,5 @@
-from mapFolding.lovelace import countFoldsCompiled
+from mapFolding.importSelector import countSequential, countParallel, countInitialize
+from mapFolding import indexThe
 from numpy import integer
 from numpy.typing import NDArray
 from typing import Any, Tuple
@@ -6,7 +7,7 @@ import numba
 import numpy
 
 @numba.jit(cache=True)
-def _countFolds(connectionGraph: NDArray[integer[Any]], foldsTotal: NDArray[integer[Any]], mapShape: Tuple[int, ...], my: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]) -> int:
+def _countFolds(connectionGraph: NDArray[integer[Any]], foldsSubTotals: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], mapShape: Tuple[int, ...], my: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]):
     """
     What in tarnation is this stupid module and function?
 
@@ -25,6 +26,10 @@ def _countFolds(connectionGraph: NDArray[integer[Any]], foldsTotal: NDArray[inte
         - and just a few dozen-jillion other things.
 
     """
-    # TODO learn if I really must change this jitted function to get the super jit to recompile
-    # print('babbage')
-    return countFoldsCompiled(connectionGraph, foldsTotal, my, gapsWhere, the, track)
+    # print("babbage")
+    countInitialize(connectionGraph=connectionGraph, gapsWhere=gapsWhere, my=my, the=the, track=track)
+
+    if the[indexThe.taskDivisions.value] > 0:
+        countParallel(connectionGraph=connectionGraph, foldsSubTotals=foldsSubTotals, gapsWherePARALLEL=gapsWhere, myPARALLEL=my, the=the, trackPARALLEL=track)
+    else:
+        countSequential(connectionGraph=connectionGraph, foldsSubTotals=foldsSubTotals, gapsWhere=gapsWhere, my=my, the=the, track=track)

{mapfolding-0.2.2 → mapfolding-0.2.4}/mapFolding/beDRY.py

@@ -1,14 +1,16 @@
 """A relatively stable API for oft-needed functionality."""
-from mapFolding import intInnit, defineConcurrencyLimit, oopsieKwargsie
+from mapFolding import dtypeDefault, dtypeLarge
 from mapFolding import indexMy, indexThe, indexTrack, computationState
-from mapFolding import dtypeDefault, dtypeLarge, dtypeSmall
+from mapFolding import intInnit, defineConcurrencyLimit, oopsieKwargsie
+from numpy import integer
+from numpy.typing import NDArray
 from typing import Any, List, Optional, Sequence, Type, Union
-import numpy
 import numba
-from numpy.typing import NDArray
-from numpy import integer
+import numpy
 import sys
-import operator
+
+def getFilenameFoldsTotal(listDimensions: Sequence[int]) -> str:
+    return str(sorted(listDimensions)).replace(' ', '') + '.foldsTotal'
 
 def getLeavesTotal(listDimensions: Sequence[int]) -> int:
     """
@@ -146,7 +148,7 @@ def makeDataContainer(shape, datatype: Optional[Type] = None):
         datatype = dtypeDefault
     return numpy.zeros(shape, dtype=datatype)
 
-def outfitFoldings(listDimensions: Sequence[int], computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[bool, float, int]] = None, **keywordArguments: Optional[Type]) -> computationState:
+def outfitCountFolds(listDimensions: Sequence[int], computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[bool, float, int]] = None, **keywordArguments: Optional[Type]) -> computationState:
     """
     Initializes and configures the computation state for map folding computations.
 
@@ -155,21 +157,33 @@ def outfitFoldings(listDimensions: Sequence[int], computationDivisions: Optional
     listDimensions:
         The dimensions of the map to be folded
     computationDivisions (None):
-        Specifies how to divide the computation tasks
+        Specifies how to divide computations:
+        - None: no division of the computation into tasks; sets task divisions to 0
+        - int: direct set the number of task divisions; cannot exceed the map's total leaves
+        - "maximum": divides into `leavesTotal`-many `taskDivisions`
+        - "cpu": limits the divisions to the number of available CPUs, i.e. `concurrencyLimit`
     CPUlimit (None):
-        Limits the CPU usage for computations
+        Whether and how to limit the CPU usage. See notes for details.
 
     Returns
     -------
     computationState
         An initialized computation state containing:
         - connectionGraph: Graph representing connections in the map
-        - foldsTotal: Array tracking total folds
+        - foldsSubTotals: Array tracking total folds
         - mapShape: Validated and sorted dimensions of the map
         - my: Array for internal state tracking
         - gapsWhere: Array tracking gap positions
         - the: Static settings and metadata
         - track: Array for tracking computation progress
+
+    Limits on CPU usage `CPUlimit`:
+        - `False`, `None`, or `0`: No limits on CPU usage; uses all available CPUs. All other values will potentially limit CPU usage.
+        - `True`: Yes, limit the CPU usage; limits to 1 CPU.
+        - Integer `>= 1`: Limits usage to the specified number of CPUs.
+        - Decimal value (`float`) between 0 and 1: Fraction of total CPUs to use.
+        - Decimal value (`float`) between -1 and 0: Fraction of CPUs to *not* use.
+        - Integer `<= -1`: Subtract the absolute value from total CPUs.
     """
     datatypeDefault = keywordArguments.get('datatypeDefault', dtypeDefault)
     datatypeLarge = keywordArguments.get('datatypeLarge', dtypeLarge)
@@ -181,10 +195,10 @@ def outfitFoldings(listDimensions: Sequence[int], computationDivisions: Optional
     the[indexThe.dimensionsTotal] = len(mapShape)
     concurrencyLimit = setCPUlimit(CPUlimit)
     the[indexThe.taskDivisions] = getTaskDivisions(computationDivisions, concurrencyLimit, CPUlimit, listDimensions)
-    
+
     stateInitialized = computationState(
         connectionGraph = makeConnectionGraph(mapShape, datatype=datatypeDefault),
-        foldsTotal = makeDataContainer(the[indexThe.leavesTotal], datatypeLarge),
+        foldsSubTotals = makeDataContainer(the[indexThe.leavesTotal], datatypeLarge),
         mapShape = mapShape,
         my = makeDataContainer(len(indexMy), datatypeLarge),
         gapsWhere = makeDataContainer(int(the[indexThe.leavesTotal]) * int(the[indexThe.leavesTotal]) + 1, datatypeDefault),
@@ -216,9 +230,6 @@ def parseDimensions(dimensions: Sequence[int], parameterName: str = 'unnamed par
             raise ValueError(f"Dimension {dimension} must be non-negative")
         listNonNegative.append(dimension)
 
-    if not listNonNegative:
-        raise ValueError("At least one dimension must be non-negative")
-
     return listNonNegative
 
 def setCPUlimit(CPUlimit: Union[bool, float, int, None]) -> int:

{mapfolding-0.2.2 → mapfolding-0.2.4}/mapFolding/benchmarks/benchmarking.py

@@ -1,5 +1,6 @@
-import multiprocessing
+"""An incompetent benchmarking module for mapFolding."""
 from typing import Callable
+import multiprocessing
 import numpy
 import pathlib
 import time
@@ -57,7 +58,7 @@ def runBenchmarks(benchmarkIterations: int = 30) -> None:
     listCartesianProduct = list(itertools.product(listParametersOEIS, range(benchmarkIterations)))
     with ProcessPoolExecutor(max_workers) as concurrencyManager:
         listConcurrency = [concurrencyManager.submit(oeisIDfor_n, *parameters[0]) for parameters in listCartesianProduct]
-        for complete in tqdm(as_completed(listConcurrency), total=len(listCartesianProduct)):
+        for _complete in tqdm(as_completed(listConcurrency), total=len(listCartesianProduct)):
             pass
 
 if __name__ == '__main__':

mapfolding-0.2.4/mapFolding/countInitialize.py

@@ -0,0 +1,44 @@
+import numba
+
+@numba.jit((numba.int64[:, :, ::1], numba.int64[::1], numba.int64[::1], numba.int64[::1], numba.int64[:, ::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def countInitialize(connectionGraph, gapsWhere, my, the, track):
+    while my[6] > 0:
+        if my[6] <= 1 or track[1, 0] == 1:
+            my[1] = 0
+            my[3] = track[3, my[6] - 1]
+            my[0] = 1
+            while my[0] <= the[0]:
+                if connectionGraph[my[0], my[6], my[6]] == my[6]:
+                    my[1] += 1
+                else:
+                    my[7] = connectionGraph[my[0], my[6], my[6]]
+                    while my[7] != my[6]:
+                        gapsWhere[my[3]] = my[7]
+                        if track[2, my[7]] == 0:
+                            my[3] += 1
+                        track[2, my[7]] += 1
+                        my[7] = connectionGraph[my[0], my[6], track[1, my[7]]]
+                my[0] += 1
+            if my[1] == the[0]:
+                my[4] = 0
+                while my[4] < my[6]:
+                    gapsWhere[my[3]] = my[4]
+                    my[3] += 1
+                    my[4] += 1
+            my[5] = my[2]
+            while my[5] < my[3]:
+                gapsWhere[my[2]] = gapsWhere[my[5]]
+                if track[2, gapsWhere[my[5]]] == the[0] - my[1]:
+                    my[2] += 1
+                track[2, gapsWhere[my[5]]] = 0
+                my[5] += 1
+        if my[6] > 0:
+            my[2] -= 1
+            track[0, my[6]] = gapsWhere[my[2]]
+            track[1, my[6]] = track[1, track[0, my[6]]]
+            track[1, track[0, my[6]]] = my[6]
+            track[0, track[1, my[6]]] = my[6]
+            track[3, my[6]] = my[2]
+            my[6] += 1
+        if my[2] > 0:
+            return

mapfolding-0.2.4/mapFolding/countParallel.py

@@ -0,0 +1,49 @@
+import numba
+
+@numba.jit((numba.int64[:, :, ::1], numba.int64[::1], numba.int64[::1], numba.int64[::1], numba.int64[::1], numba.int64[:, ::1]), parallel=True, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def countParallel(connectionGraph, foldsSubTotals, gapsWherePARALLEL, myPARALLEL, the, trackPARALLEL):
+    for indexSherpa in numba.prange(the[2]):
+        gapsWhere = gapsWherePARALLEL.copy()
+        my = myPARALLEL.copy()
+        my[8] = indexSherpa
+        track = trackPARALLEL.copy()
+        while my[6] > 0:
+            if my[6] <= 1 or track[1, 0] == 1:
+                if my[6] > the[1]:
+                    foldsSubTotals[my[8]] += the[1]
+                else:
+                    my[1] = 0
+                    my[3] = track[3, my[6] - 1]
+                    my[0] = 1
+                    while my[0] <= the[0]:
+                        if connectionGraph[my[0], my[6], my[6]] == my[6]:
+                            my[1] += 1
+                        else:
+                            my[7] = connectionGraph[my[0], my[6], my[6]]
+                            while my[7] != my[6]:
+                                if my[6] != the[2] or my[7] % the[2] == my[8]:
+                                    gapsWhere[my[3]] = my[7]
+                                    if track[2, my[7]] == 0:
+                                        my[3] += 1
+                                    track[2, my[7]] += 1
+                                my[7] = connectionGraph[my[0], my[6], track[1, my[7]]]
+                        my[0] += 1
+                    my[5] = my[2]
+                    while my[5] < my[3]:
+                        gapsWhere[my[2]] = gapsWhere[my[5]]
+                        if track[2, gapsWhere[my[5]]] == the[0] - my[1]:
+                            my[2] += 1
+                        track[2, gapsWhere[my[5]]] = 0
+                        my[5] += 1
+            while my[6] > 0 and my[2] == track[3, my[6] - 1]:
+                my[6] -= 1
+                track[1, track[0, my[6]]] = track[1, my[6]]
+                track[0, track[1, my[6]]] = track[0, my[6]]
+            if my[6] > 0:
+                my[2] -= 1
+                track[0, my[6]] = gapsWhere[my[2]]
+                track[1, my[6]] = track[1, track[0, my[6]]]
+                track[1, track[0, my[6]]] = my[6]
+                track[0, track[1, my[6]]] = my[6]
+                track[3, my[6]] = my[2]
+                my[6] += 1

mapfolding-0.2.4/mapFolding/countSequential.py

@@ -0,0 +1,43 @@
+import numba
+
+@numba.jit((numba.int64[:, :, ::1], numba.int64[::1], numba.int64[::1], numba.int64[::1], numba.int64[::1], numba.int64[:, ::1]), parallel=False, boundscheck=False, error_model='numpy', fastmath=True, looplift=False, nogil=True, nopython=True)
+def countSequential(connectionGraph, foldsSubTotals, gapsWhere, my, the, track):
+    while my[6] > 0:
+        if my[6] <= 1 or track[1, 0] == 1:
+            if my[6] > the[1]:
+                foldsSubTotals[my[8]] += the[1]
+            else:
+                my[1] = 0
+                my[3] = track[3, my[6] - 1]
+                my[0] = 1
+                while my[0] <= the[0]:
+                    if connectionGraph[my[0], my[6], my[6]] == my[6]:
+                        my[1] += 1
+                    else:
+                        my[7] = connectionGraph[my[0], my[6], my[6]]
+                        while my[7] != my[6]:
+                            gapsWhere[my[3]] = my[7]
+                            if track[2, my[7]] == 0:
+                                my[3] += 1
+                            track[2, my[7]] += 1
+                            my[7] = connectionGraph[my[0], my[6], track[1, my[7]]]
+                    my[0] += 1
+                my[5] = my[2]
+                while my[5] < my[3]:
+                    gapsWhere[my[2]] = gapsWhere[my[5]]
+                    if track[2, gapsWhere[my[5]]] == the[0] - my[1]:
+                        my[2] += 1
+                    track[2, gapsWhere[my[5]]] = 0
+                    my[5] += 1
+        while my[6] > 0 and my[2] == track[3, my[6] - 1]:
+            my[6] -= 1
+            track[1, track[0, my[6]]] = track[1, my[6]]
+            track[0, track[1, my[6]]] = track[0, my[6]]
+        if my[6] > 0:
+            my[2] -= 1
+            track[0, my[6]] = gapsWhere[my[2]]
+            track[1, my[6]] = track[1, track[0, my[6]]]
+            track[1, track[0, my[6]]] = my[6]
+            track[0, track[1, my[6]]] = my[6]
+            track[3, my[6]] = my[2]
+            my[6] += 1

mapfolding-0.2.4/mapFolding/importSelector.py

@@ -0,0 +1,12 @@
+# useLovelace = True
+useLovelace = False
+
+if useLovelace:
+    from mapFolding.lovelace import countSequential
+    from mapFolding.lovelace import countParallel
+    from mapFolding.lovelace import countInitialize
+
+else:
+    from mapFolding.countSequential import countSequential
+    from mapFolding.countParallel import countParallel
+    from mapFolding.countInitialize import countInitialize

mapfolding-0.2.4/mapFolding/inlineAfunction.py

@@ -0,0 +1,124 @@
+from mapFolding import indexMy, indexThe, indexTrack
+import ast
+import pathlib
+
+dictionaryEnumValues = {}
+for enumIndex in [indexMy, indexThe, indexTrack]:
+    for memberName, memberValue in enumIndex._member_map_.items():
+        dictionaryEnumValues[f"{enumIndex.__name__}.{memberName}.value"] = memberValue.value
+
+class RecursiveInliner(ast.NodeTransformer):
+    def __init__(self, dictionaryFunctions, dictionaryEnumValues):
+        self.dictionaryFunctions = dictionaryFunctions
+        self.dictionaryEnumValues = dictionaryEnumValues
+        self.processed = set()  # Track processed functions to avoid infinite recursion
+
+    def inline_function_body(self, functionName):
+        if functionName in self.processed:
+            return None
+
+        self.processed.add(functionName)
+        inlineDefinition = self.dictionaryFunctions[functionName]
+        # Recursively process the function body
+        for node in ast.walk(inlineDefinition):
+            self.visit(node)
+        return inlineDefinition
+
+    def visit_Attribute(self, node):
+        # Substitute enum identifiers (e.g., indexMy.leaf1ndex.value)
+        if isinstance(node.value, ast.Attribute) and isinstance(node.value.value, ast.Name):
+            enumPath = f"{node.value.value.id}.{node.value.attr}.{node.attr}"
+            if enumPath in self.dictionaryEnumValues:
+                return ast.Constant(value=self.dictionaryEnumValues[enumPath])
+        return self.generic_visit(node)
+
+    def visit_Call(self, node):
+        callNode = self.generic_visit(node)
+        if isinstance(callNode, ast.Call) and isinstance(callNode.func, ast.Name) and callNode.func.id in self.dictionaryFunctions:
+            inlineDefinition = self.inline_function_body(callNode.func.id)
+            if inlineDefinition and inlineDefinition.body:
+                lastStmt = inlineDefinition.body[-1]
+                if isinstance(lastStmt, ast.Return) and lastStmt.value is not None:
+                    return self.visit(lastStmt.value)
+                elif isinstance(lastStmt, ast.Expr) and lastStmt.value is not None:
+                    return self.visit(lastStmt.value)
+                return None
+        return callNode
+
+    def visit_Expr(self, node):
+        if isinstance(node.value, ast.Call):
+            if isinstance(node.value.func, ast.Name) and node.value.func.id in self.dictionaryFunctions:
+                inlineDefinition = self.inline_function_body(node.value.func.id)
+                if inlineDefinition:
+                    return [self.visit(stmt) for stmt in inlineDefinition.body]
+        return self.generic_visit(node)
+
+def find_required_imports(node):
+    """Find all modules that need to be imported based on AST analysis."""
+    requiredImports = set()
+
+    class ImportFinder(ast.NodeVisitor):
+        def visit_Name(self, node):
+            # Common modules we might need
+            if node.id in {'numba'}:
+                requiredImports.add(node.id)
+            self.generic_visit(node)
+
+        def visit_Decorator(self, node):
+            if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
+                if node.func.id == 'jit':
+                    requiredImports.add('numba')
+            self.generic_visit(node)
+
+    ImportFinder().visit(node)
+    return requiredImports
+
+def generate_imports(requiredImports):
+    """Generate import statements based on required modules."""
+    importStatements = []
+
+    # Map of module names to their import statements
+    importMapping = {
+        'numba': 'import numba',
+    }
+
+    for moduleName in sorted(requiredImports):
+        if moduleName in importMapping:
+            importStatements.append(importMapping[moduleName])
+
+    return '\n'.join(importStatements)
+
+def inline_functions(sourceCode, targetFunctionName, dictionaryEnumValues):
+    dictionaryParsed = ast.parse(sourceCode)
+    dictionaryFunctions = {
+        element.name: element
+        for element in dictionaryParsed.body
+        if isinstance(element, ast.FunctionDef)
+    }
+    nodeTarget = dictionaryFunctions[targetFunctionName]
+    nodeInliner = RecursiveInliner(dictionaryFunctions, dictionaryEnumValues)
+    nodeInlined = nodeInliner.visit(nodeTarget)
+    ast.fix_missing_locations(nodeInlined)
+
+    # Generate imports
+    requiredImports = find_required_imports(nodeInlined)
+    importStatements = generate_imports(requiredImports)
+
+    # Combine imports with inlined code
+    inlinedCode = importStatements + '\n\n' + ast.unparse(ast.Module(body=[nodeInlined], type_ignores=[]))
+    return inlinedCode
+
+pathFilenameSource = pathlib.Path("/apps/mapFolding/mapFolding/lovelace.py")
+codeSource = pathFilenameSource.read_text()
+
+listCallables = [
+    'countSequential',
+    'countParallel',
+    'countInitialize',
+]
+listPathFilenamesDestination = []
+for callableTarget in listCallables:
+    pathFilenameDestination = pathFilenameSource.with_stem(callableTarget)
+    codeInlined = inline_functions(codeSource, callableTarget, dictionaryEnumValues)
+    pathFilenameDestination.write_text(codeInlined)
+    listPathFilenamesDestination.append(pathFilenameDestination)