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

citations/updateCitation.py

@@ -1,354 +0,0 @@
-from cffconvert.cli.create_citation import create_citation
-from mapFolding.citations.constants import GITHUB_API_VERSION_HEADER
-from packaging.metadata import Metadata as PyPAMetadata
-from typing import Any, Dict, List
-import attrs
-import cffconvert
-import os
-import packaging
-import packaging.metadata
-import packaging.utils
-import packaging.version
-import pathlib
-import requests
-import ruamel.yaml
-import tomli
-
-listProjectURLsTarget: List[str] = ["homepage", "license", "repository"]
-
-"""
-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: but the commit field isn't even working right now
-"""
-
-@attrs.define
-class CitationNexus:
-    """
-    - one-to-one correlation with `cffconvert.lib.cff_1_2_x.citation` class Citation_1_2_x.cffobj
-    """
-    cffDASHversion: str
-    message: str
-
-    abstract: str | None = None
-    authors: list[dict[str,str]] = attrs.field(factory=list)
-    # GitHub TODO
-    commit: str | None = None
-    contact: list[dict[str,str]] = attrs.field(factory=list)
-    dateDASHreleased: str | None = None
-    doi: str | None = None
-    identifiers: list[str] = attrs.field(factory=list)
-    keywords: list[str] = attrs.field(factory=list)
-    license: str | None = None
-    licenseDASHurl: str | None = None
-    preferredDASHcitation: str | None = None
-    # TODO bibtex files in pathCitationSSOT. Conversion method and timing TBD.
-    references: list[str] = attrs.field(factory=list)
-    repository: str | None = None
-    repositoryDASHartifact: str | None = None
-    repositoryDASHcode: str | None = None
-    title: str | None = None
-    type: str | None = None
-    url: str | None = None
-    version: str | None = None
-
-    def setInStone(self, prophet: str) -> "CitationNexus":
-        match prophet:
-            case "Citation":
-                pass
-                # "freeze" these items
-                # setattr(self.cffDASHversion, 'type', Final[str])
-                # setattr(self.doi, 'type', Final[str])
-                # cffDASHversion: str
-                # message: str
-                # abstract: str | None = None
-                # doi: str | None = None
-                # preferredDASHcitation: str | None = None
-                # type: str | None = None
-            case "GitHub":
-                pass
-                # "freeze" these items
-                # setattr(self.commit, 'type', Final[str])
-                # setattr(self.dateDASHreleased, 'type', Final[str])
-                # setattr(self.identifiers, 'type', Final[list[str]])
-                # setattr(self.repositoryDASHcode, 'type', Final[str])
-            case "PyPA":
-                pass
-                # "freeze" these items
-                # setattr(self.keywords, 'type', Final[list[str]])
-                # setattr(self.license, 'type', Final[str])
-                # setattr(self.licenseDASHurl, 'type', Final[str])
-                # setattr(self.repository, 'type', Final[str])
-                # setattr(self.url, 'type', Final[str])
-                # setattr(self.version, 'type', Final[str])
-            case "PyPI":
-                pass
-                # "freeze" these items
-                # setattr(self.repositoryDASHartifact, 'type', Final[str])
-            case "pyprojectDOTtoml":
-                pass
-                # "freeze" these items
-                # setattr(self.authors, 'type', Final[list[dict[str,str]]])
-                # setattr(self.contact, 'type', Final[list[dict[str,str]]])
-                # setattr(self.title, 'type', Final[str])
-        return self
-
-def addPypaMetadata(nexusCitation: CitationNexus, metadata: PyPAMetadata) -> CitationNexus:
-    if not metadata.name:
-        raise ValueError("Metadata name is required.")
-
-    nexusCitation.title = metadata.name
-    if metadata.version: nexusCitation.version = str(metadata.version)
-    if metadata.keywords: nexusCitation.keywords = metadata.keywords
-    if metadata.license_expression: nexusCitation.license = metadata.license_expression
-
-    Z0Z_lookup: Dict[str, str] = {
-        "homepage": "url",
-        "license": "licenseDASHurl",
-        "repository": "repository",
-    }
-    if metadata.project_urls:
-        for urlTarget in listProjectURLsTarget:
-            url = metadata.project_urls.get(urlTarget, None)
-            if url:
-                setattr(nexusCitation, Z0Z_lookup[urlTarget], url)
-
-    nexusCitation = nexusCitation.setInStone("PyPA")
-    return nexusCitation
-
-def add_pyprojectDOTtoml(nexusCitation: CitationNexus, packageData: Dict[str, Any]) -> CitationNexus:
-    def Z0Z_ImaNotValidatingNoNames(person: Dict[str, str]) -> Dict[str, str]:
-        cffPerson: Dict[str, str] = {}
-        if person.get('name', None):
-            cffPerson['given-names'], cffPerson['family-names'] = person['name'].split(' ', 1)
-        if person.get('email', None):
-            cffPerson['email'] = person['email']
-        return cffPerson
-    listAuthors = packageData.get("authors", None)
-    if not listAuthors:
-        raise ValueError("Authors are required.")
-    else:
-        listPersons = []
-        for person in listAuthors:
-            listPersons.append(Z0Z_ImaNotValidatingNoNames(person))
-            nexusCitation.authors = listPersons
-    if packageData.get("maintainers", None):
-        listPersons = []
-        for person in packageData["maintainers"]:
-            listPersons.append(Z0Z_ImaNotValidatingNoNames(person))
-            nexusCitation.contact = listPersons
-    nexusCitation.title = packageData["name"]
-    nexusCitation = nexusCitation.setInStone("pyprojectDOTtoml")
-    return nexusCitation
-
-def getGitHubRelease(nexusCitation: CitationNexus) -> Dict[str, Any]:
-    """Return a dictionary with GitHub release data.
-
-    The dictionary contains the following keys:
-        commit: The commit hash (using the API field 'target_commitish').
-        date-released: The published date (in YYYY-MM-DD format).
-        identifiers: A list with one identifier object, whose description is
-            'The URL for {nexusCitation.title} {nexusCitation.version}.'
-        repository-code: A URL for the commit in the repository.
-
-    Raises:
-        ValueError: If the nexusCitation.repository is not set or cannot be parsed.
-        RuntimeError: If the HTTP request to GitHub fails.
-    """
-    if not nexusCitation.repository:
-        raise ValueError("Repository URL is required to get GitHub release info.")
-
-    urlparts = nexusCitation.repository.replace("https://github.com", "", 1).strip("/").split("/") + [None] * 5
-    ownername, reponame, _2, refvalue, *_filename_parts = urlparts
-    reponame = reponame.replace(".git", "") # type: ignore # Remove .git from the repository name, if present.
-    assert ownername is not None, "URL should include the name of the owner/organization."
-    assert reponame is not None, "URL should include the name of the repository."
-    if refvalue is None:
-        repos_api = f"https://api.github.com/repos/{ownername}/{reponame}/releases/latest"
-        headers = GITHUB_API_VERSION_HEADER
-        headers.update({"Accept": "application/vnd.github+json"})
-        token = os.environ.get("GITHUB_TOKEN")
-        headers.update({"Authorization": f"Bearer { token }"})
-        response = requests.get(repos_api, headers=headers)
-        if response.status_code != 200:
-            raise RuntimeError(f"Failed to get GitHub release info: {response.status_code}")
-
-    releaseData = response.json()
-    # commitHash = releaseData.get("target_commitish")
-    publishedAt = releaseData.get("published_at")
-    if publishedAt:
-        # Convert ISO timestamp (e.g., "2020-12-31T12:34:56Z") to "YYYY-MM-DD".
-        publishedAt = publishedAt.split("T")[0]
-
-    releaseHtmlUrl = releaseData.get("html_url")
-    identifierDescription = f"The URL for {nexusCitation.title} {nexusCitation.version}."
-    return {
-        # "commit": commitHash,
-        "dateDASHreleased": publishedAt,
-        "identifiers": [{
-            "type": "url",
-            "value": releaseHtmlUrl,
-            "description": identifierDescription,
-        }],
-        "repositoryDASHcode": releaseHtmlUrl,
-    }
-
-def addGitHubRelease(nexusCitation: CitationNexus) -> CitationNexus:
-    """
-    Update the nexusCitation with GitHub release information.
-
-    This function populates the following fields on the nexusCitation:
-        - commit: using the commit hash from GitHub.
-        - dateDASHreleased: the release date.
-        - identifiers: appends a GitHub-specific identifier.
-        - repositoryDASHcode: the URL to view the commit in the repository.
-
-    Returns:
-        The updated CitationNexus instance.
-
-    Raises:
-        Any exception raised by getGitHubRelease.
-    """
-    gitHubReleaseData = getGitHubRelease(nexusCitation)
-    nexusCitation.commit = gitHubReleaseData.get("commit")
-    nexusCitation.dateDASHreleased = gitHubReleaseData.get("dateDASHreleased")
-    # Overwrite the existing list of identifiers. This could be better
-    nexusCitation.identifiers = gitHubReleaseData.get("identifiers", [])
-    nexusCitation.repositoryDASHcode = gitHubReleaseData.get("repositoryDASHcode")
-    return nexusCitation
-
-def getPyPIrelease(nexusCitation: CitationNexus) -> Dict[str, Any]:
-    if not nexusCitation.title:
-        raise ValueError("Package name (title) is required to get PyPI release info.")
-    if not nexusCitation.version:
-        raise ValueError("Package version is required to get PyPI release info.")
-
-    packageName = packaging.utils.canonicalize_name(nexusCitation.title)
-    version = str(nexusCitation.version)
-    return {
-        "repositoryDASHartifact": f"https://pypi.org/project/{packageName}/{version}/"
-    }
-
-def addPyPIrelease(nexusCitation: CitationNexus) -> CitationNexus:
-    pypiReleaseData = getPyPIrelease(nexusCitation)
-    nexusCitation.repositoryDASHartifact = pypiReleaseData.get("repositoryDASHartifact")
-    return nexusCitation
-
-def getNexusCitation(pathFilenameCitationSSOT: pathlib.Path) -> CitationNexus:
-
-    # `cffconvert.cli.create_citation.create_citation()` is PAINFULLY mundane, but a major problem
-    # in the CFF ecosystem is divergence. Therefore, I will use this function so that my code
-    # converges with the CFF ecosystem.
-    citationObject: cffconvert.Citation = create_citation(infile=pathFilenameCitationSSOT, url=None)
-    # `._parse()` is a yaml loader: use it for convergence
-    cffobj: Dict[Any, Any] = citationObject._parse()
-
-    nexusCitation = CitationNexus(
-        cffDASHversion=cffobj["cff-version"],
-        message=cffobj["message"],
-    )
-
-    Z0Z_list: List[attrs.Attribute] = list(attrs.fields(type(nexusCitation)))
-    for Z0Z_field in Z0Z_list:
-        cffobjKeyName: str = Z0Z_field.name.replace("DASH", "-")
-        cffobjValue = cffobj.get(cffobjKeyName)
-        if cffobjValue: # An empty list will be False
-            setattr(nexusCitation, Z0Z_field.name, cffobjValue)
-
-    nexusCitation = nexusCitation.setInStone("Citation")
-    return nexusCitation
-
-def getPypaMetadata(packageData: Dict[str, Any]) -> PyPAMetadata:
-    """
-    Create a PyPA metadata object (version 2.4) from packageData.
-    https://packaging.python.org/en/latest/specifications/core-metadata/
-    """
-    dictionaryProjectURLs: Dict[str, str] = {}
-    for urlName, url in packageData.get("urls", {}).items():
-        urlName = urlName.lower()
-        if urlName in listProjectURLsTarget:
-            dictionaryProjectURLs[urlName] = url
-
-    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), # packaging.metadata.InvalidMetadata: 'name' is a required field
-        project_urls=dictionaryProjectURLs,
-        version=packageData.get("version", None),
-    )
-
-    metadata = PyPAMetadata().from_raw(metadataRaw)
-    return metadata
-
-def writeCitation(nexusCitation: CitationNexus, pathFilenameCitationSSOT: pathlib.Path, pathFilenameCitationDOTcffRepo: pathlib.Path):
-    # NOTE embarrassingly hacky process to follow
-    parameterIndent= 2
-    parameterLineWidth = 60
-    yamlWorkhorse = ruamel.yaml.YAML()
-
-    def srsly(Z0Z_filed, Z0Z_value):
-        if Z0Z_value: # empty lists
-            return True
-        else:
-            return False
-
-    dictionaryCitation = attrs.asdict(nexusCitation, filter=srsly)
-    for keyName in list(dictionaryCitation.keys()):
-        dictionaryCitation[keyName.replace("DASH", "-")] = dictionaryCitation.pop(keyName)
-
-    pathFilenameForValidation = pathFilenameCitationSSOT.with_stem('validation')
-
-    def writeStream(pathFilename):
-        with open(pathFilename, 'w') as pathlibIsAStealthContextManagerThatRuamelCannotDetectAndRefusesToWorkWith:
-            yamlWorkhorse.dump(dictionaryCitation, pathlibIsAStealthContextManagerThatRuamelCannotDetectAndRefusesToWorkWith)
-
-    writeStream(pathFilenameForValidation)
-
-    citationObject: cffconvert.Citation = create_citation(infile=pathFilenameForValidation, url=None)
-    if citationObject.validate() is None:
-        writeStream(pathFilenameCitationSSOT)
-        writeStream(pathFilenameCitationDOTcffRepo)
-
-    pathFilenameForValidation.unlink()
-
-def logistics():
-    # Prefer reliable, dynamic values over hardcoded ones
-    pathRepoRoot = pathlib.Path(__file__).parent.parent.parent
-    pathFilenamePackageSSOT = pathRepoRoot / 'pyproject.toml'
-
-    tomlPackageData: Dict[str, Any] = tomli.loads(pathFilenamePackageSSOT.read_text())['project']
-    # https://packaging.python.org/en/latest/specifications/pyproject-toml/
-
-    packageName: str = tomlPackageData.get("name", None)
-    if not packageName:
-        raise ValueError("Package name is required.")
-
-    filenameCitationDOTcff = 'CITATION.cff'
-    pathCitations = pathRepoRoot / packageName / 'citations'
-    pathFilenameCitationSSOT = pathCitations / filenameCitationDOTcff
-    pathFilenameCitationDOTcffRepo = pathRepoRoot / filenameCitationDOTcff
-
-    nexusCitation = getNexusCitation(pathFilenameCitationSSOT)
-
-    pypaMetadata: PyPAMetadata = getPypaMetadata(tomlPackageData)
-
-    nexusCitation = addPypaMetadata(nexusCitation, pypaMetadata)
-    nexusCitation = add_pyprojectDOTtoml(nexusCitation, tomlPackageData)
-
-    nexusCitation = addGitHubRelease(nexusCitation)
-    nexusCitation = addPyPIrelease(nexusCitation)
-
-    filenameGitHubAction = 'updateCitation.yml'
-    pathFilenameGitHubAction = pathRepoRoot / '.github' / 'workflows' / filenameGitHubAction
-
-    writeCitation(nexusCitation, pathFilenameCitationSSOT, pathFilenameCitationDOTcffRepo)
-
-if __name__ == '__main__':
-    logistics()

mapFolding-0.3.8.dist-info/RECORD

@@ -1,26 +0,0 @@
-benchmarks/benchmarking.py,sha256=HD_0NSvuabblg94ftDre6LFnXShTe8MYj3hIodW-zV0,3076
-citations/constants.py,sha256=1n3AC_18LOjmMLJWDo8YOGEIvDY7oZyLtI4QwqdB6z4,73
-citations/updateCitation.py,sha256=ihZFafY1TtVgQ1cnVNAHGCJMgoBUR8cm1qvGobwjNKA,14949
-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/getLLVMforNoReason.py,sha256=FtJzw2pZS3A4NimWdZsegXaU-vKeCw8m67kcfb5wvGM,894
-someAssemblyRequired/makeJob.py,sha256=UUCNdkFnSrlhRAjkQp2_Qv4joKGXRnNJhZ4OdxI_aqU,2628
-someAssemblyRequired/synthesizeModuleJobNumba.py,sha256=TCYNNI19vCw0C1FLP691VPpYknkedj-zpx-xQFVIVJU,9851
-someAssemblyRequired/synthesizeModulesNumba.py,sha256=aOst0EC5zStLbUSDTpyMoyQe_8_3CLX7JSdHdPmlAsY,22847
-syntheticModules/__init__.py,sha256=XMjNt8x24M82i1eCNVcWpIIhXwfVCnjfbb-y36RAafA,131
-syntheticModules/numbaInitialize.py,sha256=H8Y22wwE5kYyroztAJ5HJ2W6qfw7Fu4iVrUsCPmnFjY,4088
-syntheticModules/numbaParallel.py,sha256=fvprhBepBxQkY5yQInYRWb7agDVMArypGC6Y510tAcU,5452
-syntheticModules/numbaSequential.py,sha256=Knru1I7BBvsBDTex7NfxO2U3IEcQfz-uG4Lpw2tLhOI,3629
-mapFolding-0.3.8.dist-info/METADATA,sha256=hgOrdxAEB5vsBdIK41JvUc65iHQladkMBbbXwg-YPnc,7729
-mapFolding-0.3.8.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapFolding-0.3.8.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapFolding-0.3.8.dist-info/top_level.txt,sha256=yVG9dNZywoaddcsUdEDg7o0XOBzJd_4Z-sDaXGHpiMY,69
-mapFolding-0.3.8.dist-info/RECORD,,

mapFolding-0.3.8.dist-info/top_level.txt

@@ -1,5 +0,0 @@
-benchmarks
-citations
-reference
-someAssemblyRequired
-syntheticModules

someAssemblyRequired/__init__.py

@@ -1 +0,0 @@
-from .makeJob import makeStateJob

someAssemblyRequired/synthesizeModuleJobNumba.py

@@ -1,212 +0,0 @@
-from mapFolding import getPathFilenameFoldsTotal, indexMy, indexTrack
-from mapFolding import setDatatypeElephino, setDatatypeFoldsTotal, setDatatypeLeavesTotal, setDatatypeModule, hackSSOTdatatype
-from someAssemblyRequired import makeStateJob
-from typing import Optional
-import importlib
-import importlib.util
-import inspect
-import more_itertools
-import numpy
-import pathlib
-import python_minifier
-
-identifierCallableLaunch = "goGoGadgetAbsurdity"
-
-def makeStrRLEcompacted(arrayTarget: numpy.ndarray, identifierName: str) -> str:
-    """Converts a NumPy array into a compressed string representation using run-length encoding (RLE).
-
-    This function takes a NumPy array and converts it into an optimized string representation by:
-    1. Compressing consecutive sequences of numbers into range objects
-    2. Minimizing repeated zeros using array multiplication syntax
-    3. Converting the result into a valid Python array initialization statement
-
-    Parameters:
-        arrayTarget (numpy.ndarray): The input NumPy array to be converted
-        identifierName (str): The variable name to use in the output string
-
-    Returns:
-        str: A string containing Python code that recreates the input array in compressed form.
-            Format: "{identifierName} = numpy.array({compressed_data}, dtype=numpy.{dtype})"
-
-    Example:
-        >>> arr = numpy.array([[0,0,0,1,2,3,4,0,0]])
-        >>> print(makeStrRLEcompacted(arr, "myArray"))
-        "myArray = numpy.array([[0]*3,*range(1,5),[0]*2], dtype=numpy.int64)"
-
-    Notes:
-        - Sequences of 4 or fewer numbers are kept as individual values
-        - Sequences longer than 4 numbers are converted to range objects
-        - Consecutive zeros are compressed using multiplication syntax
-        - The function preserves the original array's dtype
-    """
-
-    def compressRangesNDArrayNoFlatten(arraySlice):
-        if isinstance(arraySlice, numpy.ndarray) and arraySlice.ndim > 1:
-            return [compressRangesNDArrayNoFlatten(arraySlice[index]) for index in range(arraySlice.shape[0])]
-        elif isinstance(arraySlice, numpy.ndarray) and arraySlice.ndim == 1:
-            listWithRanges = []
-            for group in more_itertools.consecutive_groups(arraySlice.tolist()):
-                ImaSerious = list(group)
-                if len(ImaSerious) <= 4:
-                    listWithRanges += ImaSerious
-                else:
-                    ImaRange = [range(ImaSerious[0], ImaSerious[-1] + 1)]
-                    listWithRanges += ImaRange
-            return listWithRanges
-        return arraySlice
-
-    arrayAsNestedLists = compressRangesNDArrayNoFlatten(arrayTarget)
-
-    stringMinimized = python_minifier.minify(str(arrayAsNestedLists))
-    commaZeroMaximum = arrayTarget.shape[-1] - 1
-    stringMinimized = stringMinimized.replace('[0' + ',0'*commaZeroMaximum + ']', '[0]*'+str(commaZeroMaximum+1))
-    for countZeros in range(commaZeroMaximum, 2, -1):
-        stringMinimized = stringMinimized.replace(',0'*countZeros + ']', ']+[0]*'+str(countZeros))
-
-    stringMinimized = stringMinimized.replace('range', '*range')
-
-    return f"{identifierName} = numpy.array({stringMinimized}, dtype=numpy.{arrayTarget.dtype})"
-
-def writeModuleWithNumba(listDimensions) -> pathlib.Path:
-    """
-    Writes a Numba-optimized Python module for map folding calculations.
-
-    This function takes map dimensions and generates a specialized Python module with Numba
-    optimizations. It processes a sequential counting algorithm, adds Numba decorators and
-    necessary data structures, and writes the resulting code to a file.
-
-    Parameters:
-        listDimensions: List of integers representing the dimensions of the map to be folded.
-
-    Returns:
-        pathlib.Path: Path to the generated Python module file.
-
-    The generated module includes:
-    - Numba JIT compilation decorators for performance optimization
-    - Required numpy and numba imports
-    - Dynamic and static data structures needed for folding calculations
-    - Processed algorithm from the original sequential counter
-    - Launch code for standalone execution
-    - Code to write the final fold count to a file
-    The function handles:
-    - Translation of original code to Numba-compatible syntax
-    - Insertion of pre-calculated values from the state job
-    - Management of variable declarations and assignments
-    - Setup of proper data types for Numba optimization
-    - Organization of the output file structure
-
-    Note:
-        The generated module requires Numba and numpy to be installed.
-        The output file will be placed in the same directory as the folds total file,
-        with a .py extension.
-    """
-    stateJob = makeStateJob(listDimensions, writeJob=False)
-    pathFilenameFoldsTotal = getPathFilenameFoldsTotal(stateJob['mapShape'])
-
-    from syntheticModules import countSequential
-    algorithmSource = countSequential
-    codeSource = inspect.getsource(algorithmSource)
-
-    lineNumba = f"@numba.jit(numba.types.{hackSSOTdatatype('datatypeFoldsTotal')}(), cache=True, nopython=True, fastmath=True, forceinline=True, inline='always', looplift=False, _nrt=True, error_model='numpy', parallel=False, boundscheck=False, no_cfunc_wrapper=False, no_cpython_wrapper=False)"
-
-    linesImport = "\n".join([
-                        "import numpy"
-                        , "import numba"
-                        ])
-
-    ImaIndent = '    '
-    linesDataDynamic = """"""
-    linesDataDynamic = "\n".join([linesDataDynamic
-            , ImaIndent + makeStrRLEcompacted(stateJob['gapsWhere'], 'gapsWhere')
-            ])
-
-    linesDataStatic = """"""
-    linesDataStatic = "\n".join([linesDataStatic
-            , ImaIndent + makeStrRLEcompacted(stateJob['connectionGraph'], 'connectionGraph')
-            ])
-
-    my = stateJob['my']
-    track = stateJob['track']
-    linesAlgorithm = """"""
-    for lineSource in codeSource.splitlines():
-        if lineSource.startswith(('#', 'import', 'from', '@numba.jit')):
-            continue
-        elif not lineSource:
-            continue
-        elif lineSource.startswith('def '):
-            lineSource = "\n".join([lineNumba
-                                , f"def {identifierCallableLaunch}():"
-                                , linesDataDynamic
-                                , linesDataStatic
-                                ])
-        elif 'taskIndex' in lineSource:
-            continue
-        elif 'my[indexMy.' in lineSource:
-            if 'dimensionsTotal' in lineSource:
-                continue
-            # Statements are in the form: leaf1ndex = my[indexMy.leaf1ndex.value]
-            identifier, statement = lineSource.split('=')
-            lineSource = ImaIndent + identifier.strip() + f"=numba.types.{hackSSOTdatatype(identifier.strip())}({str(eval(statement.strip()))})"
-        elif ': int =' in lineSource or ':int=' in lineSource:
-            if 'dimensionsTotal' in lineSource:
-                continue
-            # Statements are in the form: groupsOfFolds: int = 0
-            assignment, statement = lineSource.split('=')
-            identifier = assignment.split(':')[0].strip()
-            lineSource = ImaIndent + identifier.strip() + f"=numba.types.{hackSSOTdatatype(identifier.strip())}({str(eval(statement.strip()))})"
-        elif 'track[indexTrack.' in lineSource:
-            # Statements are in the form: leafAbove = track[indexTrack.leafAbove.value]
-            identifier, statement = lineSource.split('=')
-            lineSource = ImaIndent + makeStrRLEcompacted(eval(statement.strip()), identifier.strip())
-        elif 'foldGroups[-1]' in lineSource:
-            lineSource = lineSource.replace('foldGroups[-1]', str(stateJob['foldGroups'][-1]))
-        elif 'dimensionsTotal' in lineSource:
-            lineSource = lineSource.replace('dimensionsTotal', str(stateJob['my'][indexMy.dimensionsTotal]))
-
-        linesAlgorithm = "\n".join([linesAlgorithm
-                            , lineSource
-                            ])
-
-    linesLaunch = """"""
-    linesLaunch = linesLaunch + f"""
-if __name__ == '__main__':
-    # import time
-    # timeStart = time.perf_counter()
-    {identifierCallableLaunch}()
-    # print(time.perf_counter() - timeStart)
-"""
-
-    linesWriteFoldsTotal = """"""
-    linesWriteFoldsTotal = "\n".join([linesWriteFoldsTotal
-                                    , f"    groupsOfFolds *= {str(stateJob['foldGroups'][-1])}"
-                                    , "    print(groupsOfFolds)"
-                                    , "    with numba.objmode():"
-                                    , f"        open('{pathFilenameFoldsTotal.as_posix()}', 'w').write(str(groupsOfFolds))"
-                                    , "    return groupsOfFolds"
-                                    ])
-
-    linesAll = "\n".join([
-                        linesImport
-                        , linesAlgorithm
-                        , linesWriteFoldsTotal
-                        , linesLaunch
-                        ])
-
-    pathFilenameDestination = pathFilenameFoldsTotal.with_suffix(".py")
-    pathFilenameDestination.write_text(linesAll)
-
-    return pathFilenameDestination
-
-if __name__ == '__main__':
-    listDimensions = [5,5]
-    setDatatypeFoldsTotal('int64', sourGrapes=True)
-    setDatatypeElephino('uint8', sourGrapes=True)
-    setDatatypeLeavesTotal('int8', sourGrapes=True)
-    pathFilenameModule = writeModuleWithNumba(listDimensions)
-
-    # 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)

syntheticModules/__init__.py

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