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

citations/constants.py

@@ -0,0 +1,3 @@
+GITHUB_API_VERSION_HEADER = {
+    "X-GitHub-Api-Version": "2022-11-28"
+}

citations/updateCitation.py

@@ -1,14 +1,16 @@
 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 tempfile
+import os
 import packaging
 import packaging.metadata
 import packaging.utils
 import packaging.version
 import pathlib
+import requests
 import ruamel.yaml
 import tomli
 
@@ -23,7 +25,7 @@ Tentative plan:
     - pathFilenameCitationDOTcffRepo
 - Commit and push to GitHub
     - this complicates things
-    - I want the updated citation to be in the `commit` field of itself
+    - 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
@@ -31,28 +33,30 @@ class CitationNexus:
     """
     - one-to-one correlation with `cffconvert.lib.cff_1_2_x.citation` class Citation_1_2_x.cffobj
     """
-    cffDASHversion: str # pathFilenameCitationSSOT
-    message: str # pathFilenameCitationSSOT
-
-    abstract: str | None = None # pathFilenameCitationSSOT
-    authors: list[dict[str,str]] = attrs.field(factory=list) # pathFilenamePackageSSOT; pyproject.toml authors
-    commit: str | None = None # workflows['Make GitHub Release']
-    contact: list[dict[str,str]] = attrs.field(factory=list) # pathFilenamePackageSSOT; pyproject.toml maintainers
-    dateDASHreleased: str | None = None # workflows['Make GitHub Release']
-    doi: str | None = None # pathFilenameCitationSSOT
-    identifiers: list[str] = attrs.field(factory=list) # workflows['Make GitHub Release']
-    keywords: list[str] = attrs.field(factory=list) # pathFilenamePackageSSOT; packaging.metadata.Metadata.keywords
-    license: str | None = None # pathFilenamePackageSSOT; packaging.metadata.Metadata.license_expression
-    licenseDASHurl: str | None = None # pathFilenamePackageSSOT; packaging.metadata.Metadata.project_urls: license or pyproject.toml urls license
-    preferredDASHcitation: str | None = None # pathFilenameCitationSSOT
-    references: list[str] = attrs.field(factory=list) # bibtex files in pathCitationSSOT. Conversion method and timing TBD.
-    repositoryDASHartifact: str | None = None # (https://pypi.org/pypi/{package_name}/json').json()['releases']
-    repositoryDASHcode: str | None = None # workflows['Make GitHub Release']
-    repository: str | None = None # pathFilenamePackageSSOT; packaging.metadata.Metadata.project_urls: repository
-    title: str | None = None # pathFilenamePackageSSOT; pyproject.toml name (packaging normalizes the names)
-    type: str | None = None # pathFilenameCitationSSOT
-    url: str | None = None # pathFilenamePackageSSOT; packaging.metadata.Metadata.project_urls: homepage
-    version: str | None = None # pathFilenamePackageSSOT; packaging.metadata.Metadata.version
+    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:
@@ -61,12 +65,19 @@ class CitationNexus:
                 # "freeze" these items
                 # setattr(self.cffDASHversion, 'type', Final[str])
                 # setattr(self.doi, 'type', Final[str])
-                # cffDASHversion: str # pathFilenameCitationSSOT
-                # message: str # pathFilenameCitationSSOT
-                # abstract: str | None = None # pathFilenameCitationSSOT
-                # doi: str | None = None # pathFilenameCitationSSOT
-                # preferredDASHcitation: str | None = None # pathFilenameCitationSSOT
-                # type: str | None = None # pathFilenameCitationSSOT
+                # 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
@@ -76,6 +87,10 @@ class CitationNexus:
                 # 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
@@ -84,53 +99,6 @@ class CitationNexus:
                 # setattr(self.title, 'type', Final[str])
         return self
 
-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 addPypaMetadata(nexusCitation: CitationNexus, metadata: PyPAMetadata) -> CitationNexus:
     if not metadata.name:
         raise ValueError("Metadata name is required.")
@@ -179,6 +147,146 @@ def add_pyprojectDOTtoml(nexusCitation: CitationNexus, packageData: Dict[str, An
     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
@@ -195,7 +303,7 @@ def writeCitation(nexusCitation: CitationNexus, pathFilenameCitationSSOT: pathli
     for keyName in list(dictionaryCitation.keys()):
         dictionaryCitation[keyName.replace("DASH", "-")] = dictionaryCitation.pop(keyName)
 
-    pathFilenameForValidation = pathlib.Path(tempfile.mktemp())
+    pathFilenameForValidation = pathFilenameCitationSSOT.with_stem('validation')
 
     def writeStream(pathFilename):
         with open(pathFilename, 'w') as pathlibIsAStealthContextManagerThatRuamelCannotDetectAndRefusesToWorkWith:
@@ -204,19 +312,23 @@ def writeCitation(nexusCitation: CitationNexus, pathFilenameCitationSSOT: pathli
     writeStream(pathFilenameForValidation)
 
     citationObject: cffconvert.Citation = create_citation(infile=pathFilenameForValidation, url=None)
-    if citationObject.validate(verbose=True) is None:
+    if citationObject.validate() is None:
         writeStream(pathFilenameCitationSSOT)
         writeStream(pathFilenameCitationDOTcffRepo)
 
+    pathFilenameForValidation.unlink()
+
 def logistics():
     # Prefer reliable, dynamic values over hardcoded ones
-    packageNameHARDCODED: str = 'mapFolding'
-
-    packageName: str = packageNameHARDCODED
     pathRepoRoot = pathlib.Path(__file__).parent.parent.parent
     pathFilenamePackageSSOT = pathRepoRoot / 'pyproject.toml'
-    filenameGitHubAction = 'updateCitation.yml'
-    pathFilenameGitHubAction = pathRepoRoot / '.github' / 'workflows' / filenameGitHubAction
+
+    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'
@@ -225,13 +337,17 @@ def logistics():
 
     nexusCitation = getNexusCitation(pathFilenameCitationSSOT)
 
-    tomlPackageData: Dict[str, Any] = tomli.loads(pathFilenamePackageSSOT.read_text())['project']
-    # https://packaging.python.org/en/latest/specifications/pyproject-toml/
     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__':

{mapFolding-0.3.7.dist-info → mapFolding-0.3.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.3.7
+Version: 0.3.8
 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.8.dist-info/RECORD

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

someAssemblyRequired/makeJob.py

@@ -1,25 +1,53 @@
-from mapFolding import getPathFilenameFoldsTotal, computationState
-from mapFolding import outfitCountFolds
+import importlib.util
+from mapFolding import getPathFilenameFoldsTotal, computationState, outfitCountFolds, getAlgorithmSource
 from typing import Any, Literal, Optional, Sequence, Type, overload
 import pathlib
 import pickle
 
 @overload
 def makeStateJob(listDimensions: Sequence[int], writeJob: Literal[True] = True
-                 , **keywordArguments: Optional[Type[Any]]) -> pathlib.Path:
+                 , **keywordArguments: Optional[str]) -> pathlib.Path:
     ...
 
 @overload
 def makeStateJob(listDimensions: Sequence[int], writeJob: Literal[False] = False
-                 , **keywordArguments: Optional[Type[Any]]) -> computationState:
+                 , **keywordArguments: Optional[str]) -> computationState:
     ...
 
-def makeStateJob(listDimensions: Sequence[int], writeJob: bool = True, **keywordArguments: Optional[Type[Any]]) -> computationState | pathlib.Path:
+def makeStateJob(listDimensions: Sequence[int], writeJob: bool = True, **keywordArguments: Optional[str]) -> computationState | pathlib.Path:
+    """
+    Creates a computation state job for map folding calculations and optionally saves it to disk.
+
+    This function initializes a computation state for map folding calculations based on the given dimensions,
+    sets up the initial counting configuration, and can optionally save the state to a pickle file.
+
+    Parameters
+    ----------
+    listDimensions : Sequence[int]
+        The dimensions of the map to be folded, typically as [height, width].
+    writeJob : bool, optional
+        If True, saves the computation state to disk. If False, returns the state object directly.
+        Default is True.
+    **keywordArguments : Optional[str]
+        Additional keyword arguments to be passed to the outfitCountFolds function.
+
+    Returns
+    -------
+    Union[computationState, pathlib.Path]
+        If writeJob is False, returns the computation state object.
+        If writeJob is True, returns the Path object pointing to the saved state file.
+
+    Notes
+    -----
+    The function creates necessary directories and saves the state as a pickle file
+    when writeJob is True. The file is saved in a directory structure based on the map shape.
+    """
 
     stateUniversal: computationState = outfitCountFolds(listDimensions, computationDivisions=None, CPUlimit=None, **keywordArguments)
 
-    from mapFolding.syntheticModules import countInitialize
-    countInitialize(stateUniversal['connectionGraph'], stateUniversal['gapsWhere'], stateUniversal['my'], stateUniversal['track'])
+
+    moduleSource = getAlgorithmSource()
+    moduleSource.countInitialize(stateUniversal['connectionGraph'], stateUniversal['gapsWhere'], stateUniversal['my'], stateUniversal['track'])
 
     if not writeJob:
         return stateUniversal

someAssemblyRequired/{synthesizeModuleJob.py → synthesizeModuleJobNumba.py}

@@ -1,5 +1,5 @@
 from mapFolding import getPathFilenameFoldsTotal, indexMy, indexTrack
-from mapFolding import make_dtype, datatypeLargeDEFAULT, datatypeMediumDEFAULT, datatypeSmallDEFAULT, datatypeModuleDEFAULT
+from mapFolding import setDatatypeElephino, setDatatypeFoldsTotal, setDatatypeLeavesTotal, setDatatypeModule, hackSSOTdatatype
 from someAssemblyRequired import makeStateJob
 from typing import Optional
 import importlib
@@ -13,9 +13,36 @@ import python_minifier
 identifierCallableLaunch = "goGoGadgetAbsurdity"
 
 def makeStrRLEcompacted(arrayTarget: numpy.ndarray, identifierName: str) -> str:
-    def process_nested_array(arraySlice):
+    """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 [process_nested_array(arraySlice[index]) for index in range(arraySlice.shape[0])]
+            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()):
@@ -28,7 +55,7 @@ def makeStrRLEcompacted(arrayTarget: numpy.ndarray, identifierName: str) -> str:
             return listWithRanges
         return arraySlice
 
-    arrayAsNestedLists = process_nested_array(arrayTarget)
+    arrayAsNestedLists = compressRangesNDArrayNoFlatten(arrayTarget)
 
     stringMinimized = python_minifier.minify(str(arrayAsNestedLists))
     commaZeroMaximum = arrayTarget.shape[-1] - 1
@@ -40,25 +67,47 @@ def makeStrRLEcompacted(arrayTarget: numpy.ndarray, identifierName: str) -> str:
 
     return f"{identifierName} = numpy.array({stringMinimized}, dtype=numpy.{arrayTarget.dtype})"
 
-def writeModuleWithNumba(listDimensions, **keywordArguments: Optional[str]) -> pathlib.Path:
-    datatypeLarge = keywordArguments.get('datatypeLarge', datatypeLargeDEFAULT)
-    datatypeMedium = keywordArguments.get('datatypeMedium', datatypeMediumDEFAULT)
-    datatypeSmall = keywordArguments.get('datatypeSmall', datatypeSmallDEFAULT)
-    datatypeModule = keywordArguments.get('datatypeModule', datatypeModuleDEFAULT)
-
-    dtypeLarge = make_dtype(datatypeLarge, datatypeModule) # type: ignore
-    dtypeMedium = make_dtype(datatypeMedium, datatypeModule) # type: ignore
-    dtypeSmall = make_dtype(datatypeSmall, datatypeModule) # type: ignore
-
-    stateJob = makeStateJob(listDimensions, writeJob=False, dtypeLarge = dtypeLarge, dtypeMedium = dtypeMedium, dtypeSmall = dtypeSmall)
+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)
 
-    if datatypeLarge:
-        lineNumba = f"@numba.jit(numba.types.{datatypeLarge}(), cache=True, nopython=True, fastmath=True, forceinline=True, inline='always', looplift=False, _nrt=True, error_model='numpy', parallel=False, boundscheck=False, no_cfunc_wrapper=True, no_cpython_wrapper=False)"
+    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"
@@ -68,8 +117,6 @@ def writeModuleWithNumba(listDimensions, **keywordArguments: Optional[str]) -> p
     ImaIndent = '    '
     linesDataDynamic = """"""
     linesDataDynamic = "\n".join([linesDataDynamic
-            # , ImaIndent + f"foldsTotal = numba.types.{datatypeLarge}(0)"
-            # , ImaIndent + makeStrRLEcompacted(stateJob['foldGroups'], 'foldGroups')
             , ImaIndent + makeStrRLEcompacted(stateJob['gapsWhere'], 'gapsWhere')
             ])
 
@@ -97,11 +144,18 @@ def writeModuleWithNumba(listDimensions, **keywordArguments: Optional[str]) -> p
         elif 'my[indexMy.' in lineSource:
             if 'dimensionsTotal' in lineSource:
                 continue
-            # leaf1ndex = my[indexMy.leaf1ndex.value]
+            # Statements are in the form: leaf1ndex = my[indexMy.leaf1ndex.value]
             identifier, statement = lineSource.split('=')
-            lineSource = ImaIndent + identifier.strip() + f"=numba.types.{datatypeSmall}({str(eval(statement.strip()))})"
+            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:
-            # leafAbove = track[indexTrack.leafAbove.value]
+            # 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:
@@ -144,11 +198,11 @@ if __name__ == '__main__':
     return pathFilenameDestination
 
 if __name__ == '__main__':
-    listDimensions = [6,6]
-    datatypeLarge = 'int64'
-    datatypeMedium = 'uint8'
-    datatypeSmall = datatypeMedium
-    pathFilenameModule = writeModuleWithNumba(listDimensions, datatypeLarge=datatypeLarge, datatypeMedium=datatypeMedium, datatypeSmall=datatypeSmall)
+    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)