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

citations/updateCitation.py

@@ -1,10 +1,48 @@
 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 inspect
 import json
+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:
+    # https://github.com/citation-file-format/cff-initializer-javascript
+    """
+keywords: pathFilenamePackageSSOT; packaging.metadata.Metadata.keywords
+license: pathFilenamePackageSSOT; packaging.metadata.Metadata.license_expression
+title: pathFilenamePackageSSOT; packaging.metadata.Metadata.name
+url: pathFilenamePackageSSOT; packaging.metadata.Metadata.project_urls: homepage
+repository: pathFilenamePackageSSOT; packaging.metadata.Metadata.project_urls: repository
+version: pathFilenamePackageSSOT; packaging.metadata.Metadata.version
+    """
+    return citation
+
+def getPypaMetadata(packageData: Dict[str, Any]) -> PyPAMetadata:
+    # https://packaging.python.org/en/latest/specifications/core-metadata/
+    dictionaryProjectURLs = {}
+    for urlKey, urlValue in packageData.get('urls', {}).items():
+        if urlKey.lower() in ('homepage', 'repository'):
+            dictionaryProjectURLs[urlKey] = 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)
+    return metadata
 
 """
 Tentative plan:
@@ -17,7 +55,6 @@ Tentative plan:
     - this complicates things
     - I want the updated citation to be in the `commit` field of itself
 """
-
 """cffconvert.Citation fields and the source of truth
 abstract: pathFilenameCitationSSOT
 authors: pathFilenamePackageSSOT
@@ -27,41 +64,53 @@ contact: pathFilenamePackageSSOT
 date-released: workflows['Make GitHub Release']
 doi: pathFilenameCitationSSOT
 identifiers: workflows['Make GitHub Release']
-keywords: pathFilenamePackageSSOT
-license: pathFilenamePackageSSOT
 license-url: pathFilenamePackageSSOT
 message: pathFilenameCitationSSOT
 preferred-citation: pathFilenameCitationSSOT
 references: to be determined
-repository: pathFilenamePackageSSOT
 repository-artifact: (https://pypi.org/pypi/{package_name}/json').json()['releases']
 repository-code: workflows['Make GitHub Release']
-title: pathFilenamePackageSSOT
 type: pathFilenameCitationSSOT
-url: pathFilenamePackageSSOT
-version: pathFilenamePackageSSOT
+
+keywords: pathFilenamePackageSSOT; packaging.metadata.Metadata.keywords
+license: pathFilenamePackageSSOT; packaging.metadata.Metadata.license_expression
+title: pathFilenamePackageSSOT; packaging.metadata.Metadata.name
+url: pathFilenamePackageSSOT; packaging.metadata.Metadata.project_urls: homepage
+repository: pathFilenamePackageSSOT; packaging.metadata.Metadata.project_urls: repository
+version: pathFilenamePackageSSOT; packaging.metadata.Metadata.version
 """
-# Prefer reliable, dynamic values over hardcoded ones
-packageName: str = 'mapFolding'
-pathRepoRoot = pathlib.Path(__file__).parent.parent.parent
-pathFilenamePackageSSOT = pathRepoRoot / 'pyproject.toml'
 
-filenameGitHubAction = 'updateCitation.yml'
-pathFilenameGitHubAction = pathRepoRoot / '.github' / 'workflows' / filenameGitHubAction
+def logistics():
+    # Prefer reliable, dynamic values over hardcoded ones
+    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
+
+    citationObject: cffconvert.Citation = create_citation(infile=pathFilenameCitationSSOT, url=None)
+    print(citationObject._parse().as_cff())
 
-filenameCitationDOTcff = 'CITATION.cff'
-pathCitations = pathRepoRoot / packageName / 'citations'
-pathFilenameCitationSSOT = pathCitations / filenameCitationDOTcff
-pathFilenameCitationDOTcffRepo = pathRepoRoot / filenameCitationDOTcff
+    tomlPackageData: Dict[str, Any] = tomli.loads(pathFilenamePackageSSOT.read_text())['project']
+    # https://packaging.python.org/en/latest/specifications/pyproject-toml/
+    pypaMetadata: PyPAMetadata = getPypaMetadata(tomlPackageData)
 
-tomlPackageData: Dict[str, Any] = tomli.loads(pathFilenamePackageSSOT.read_text())['project']
+    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)
 
-citationObject: cffconvert.Citation = create_citation(infile=pathFilenameCitationSSOT, url=None)
+if __name__ == '__main__':
+    logistics()
 
-path_cffconvert = pathlib.Path(inspect.getfile(cffconvert)).parent
-pathFilenameSchema = path_cffconvert / "schemas/1.2.0/schema.json"
-scheme: Dict[str, Any] = json.loads(pathFilenameSchema.read_text())
-schemaSpecifications: Dict[str, Any] = scheme['properties']
+    # print(f"{pypaMetadata.name=}, {pypaMetadata.version=}, {pypaMetadata.keywords=}, {pypaMetadata.license_expression=}, {pypaMetadata.project_urls=}")
+# path_cffconvert = pathlib.Path(inspect.getfile(cffconvert)).parent
+# pathFilenameSchema = path_cffconvert / "schemas/1.2.0/schema.json"
+# scheme: Dict[str, Any] = json.loads(pathFilenameSchema.read_text())
+# schemaSpecifications: Dict[str, Any] = scheme['properties']
 
-for property, subProperties in schemaSpecifications.items():
-    print(property, subProperties.get('items', None))
+# for property, subProperties in schemaSpecifications.items():
+#     print(property, subProperties.get('items', None))

citations/updateCitationgpt.py

@@ -0,0 +1,125 @@
+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.4.dist-info → mapFolding-0.3.6.dist-info}/METADATA

@@ -1,11 +1,12 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.3.4
+Version: 0.3.6
 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
-Project-URL: Homepage, https://github.com/hunterhogan/mapFolding
+Project-URL: homepage, https://github.com/hunterhogan/mapFolding
 Project-URL: Donate, https://www.patreon.com/integrated
+Project-URL: repository, https://github.com/hunterhogan/mapFolding.git
 Keywords: A001415,A001416,A001417,A001418,A195646,folding,map folding,OEIS,stamp folding
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console

mapFolding-0.3.6.dist-info/RECORD

@@ -0,0 +1,27 @@
+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/__init__.py

@@ -1,2 +1 @@
 from .makeJob import makeStateJob
-# from .generalizeSourceCode import makeInlineFunction

someAssemblyRequired/makeJob.py

@@ -1,16 +1,29 @@
-from mapFolding import getPathFilenameFoldsTotal
+from mapFolding import getPathFilenameFoldsTotal, computationState
 from mapFolding import outfitCountFolds
-from typing import Any, Optional, Sequence, Type
+from typing import Any, Literal, Optional, Sequence, Type, overload
 import pathlib
 import pickle
 
-def makeStateJob(listDimensions: Sequence[int], **keywordArguments: Optional[Type[Any]]) -> pathlib.Path:
+@overload
+def makeStateJob(listDimensions: Sequence[int], writeJob: Literal[True] = True
+                 , **keywordArguments: Optional[Type[Any]]) -> pathlib.Path:
+    ...
 
-    stateUniversal = outfitCountFolds(listDimensions, computationDivisions=None, CPUlimit=None, **keywordArguments)
+@overload
+def makeStateJob(listDimensions: Sequence[int], writeJob: Literal[False] = False
+                 , **keywordArguments: Optional[Type[Any]]) -> computationState:
+    ...
 
-    from syntheticModules import countInitialize
+def makeStateJob(listDimensions: Sequence[int], writeJob: bool = True, **keywordArguments: Optional[Type[Any]]) -> computationState | pathlib.Path:
+
+    stateUniversal: computationState = outfitCountFolds(listDimensions, computationDivisions=None, CPUlimit=None, **keywordArguments)
+
+    from mapFolding.syntheticModules import countInitialize
     countInitialize(stateUniversal['connectionGraph'], stateUniversal['gapsWhere'], stateUniversal['my'], stateUniversal['track'])
 
+    if not writeJob:
+        return stateUniversal
+
     pathFilenameChopChop = getPathFilenameFoldsTotal(stateUniversal['mapShape'])
     suffix = pathFilenameChopChop.suffix
     pathJob = pathlib.Path(str(pathFilenameChopChop)[0:-len(suffix)])

someAssemblyRequired/synthesizeModuleJob.py

@@ -1,15 +1,13 @@
-from mapFolding import getPathFilenameFoldsTotal
+from mapFolding import getPathFilenameFoldsTotal, indexMy, indexTrack
 from mapFolding import make_dtype, datatypeLargeDEFAULT, datatypeMediumDEFAULT, datatypeSmallDEFAULT, datatypeModuleDEFAULT
-from mapFolding import computationState
 from someAssemblyRequired import makeStateJob
 from typing import Optional
-import more_itertools
-import inspect
 import importlib
 import importlib.util
+import inspect
+import more_itertools
 import numpy
 import pathlib
-import pickle
 import python_minifier
 
 identifierCallableLaunch = "goGoGadgetAbsurdity"
@@ -52,33 +50,15 @@ def writeModuleWithNumba(listDimensions, **keywordArguments: Optional[str]) -> p
     dtypeMedium = make_dtype(datatypeMedium, datatypeModule) # type: ignore
     dtypeSmall = make_dtype(datatypeSmall, datatypeModule) # type: ignore
 
-    pathFilenameJob = makeStateJob(listDimensions, dtypeLarge = dtypeLarge, dtypeMedium = dtypeMedium, dtypeSmall = dtypeSmall)
-    stateJob: computationState = pickle.loads(pathFilenameJob.read_bytes())
-    pathFilenameFoldsTotal = getPathFilenameFoldsTotal(stateJob['mapShape'], pathFilenameJob.parent)
+    stateJob = makeStateJob(listDimensions, writeJob=False, dtypeLarge = dtypeLarge, dtypeMedium = dtypeMedium, dtypeSmall = dtypeSmall)
+    pathFilenameFoldsTotal = getPathFilenameFoldsTotal(stateJob['mapShape'])
 
     from syntheticModules import countSequential
     algorithmSource = countSequential
     codeSource = inspect.getsource(algorithmSource)
 
-    # forceinline=True might actually be useful
-    parametersNumba = f"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=False, \
-no_cpython_wrapper=False, \
-"
-# no_cfunc_wrapper=True, \
-# no_cpython_wrapper=True, \
-
-    lineNumba = f"@numba.jit({parametersNumba})"
+    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)"
 
     linesImport = "\n".join([
                         "import numpy"
@@ -88,8 +68,8 @@ no_cpython_wrapper=False, \
     ImaIndent = '    '
     linesDataDynamic = """"""
     linesDataDynamic = "\n".join([linesDataDynamic
-            , ImaIndent + f"foldsTotal = numba.types.{datatypeLarge}(0)"
-            , ImaIndent + makeStrRLEcompacted(stateJob['foldGroups'], 'foldGroups')
+            # , ImaIndent + f"foldsTotal = numba.types.{datatypeLarge}(0)"
+            # , ImaIndent + makeStrRLEcompacted(stateJob['foldGroups'], 'foldGroups')
             , ImaIndent + makeStrRLEcompacted(stateJob['gapsWhere'], 'gapsWhere')
             ])
 
@@ -112,14 +92,22 @@ no_cpython_wrapper=False, \
                                 , linesDataDynamic
                                 , linesDataStatic
                                 ])
+        elif 'taskIndex' in lineSource:
+            continue
         elif 'my[indexMy.' in lineSource:
+            if 'dimensionsTotal' in lineSource:
+                continue
             # leaf1ndex = my[indexMy.leaf1ndex.value]
             identifier, statement = lineSource.split('=')
-            lineSource = ImaIndent + identifier.strip() + '=' + str(eval(statement.strip()))
+            lineSource = ImaIndent + identifier.strip() + f"=numba.types.{datatypeSmall}({str(eval(statement.strip()))})"
         elif 'track[indexTrack.' in lineSource:
             # 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
@@ -135,11 +123,11 @@ if __name__ == '__main__':
 
     linesWriteFoldsTotal = """"""
     linesWriteFoldsTotal = "\n".join([linesWriteFoldsTotal
-                                    , "    foldsTotal = foldGroups[0:-1].sum() * foldGroups[-1]"
-                                    , "    print(foldsTotal)"
+                                    , f"    groupsOfFolds *= {str(stateJob['foldGroups'][-1])}"
+                                    , "    print(groupsOfFolds)"
                                     , "    with numba.objmode():"
-                                    , f"        open('{pathFilenameFoldsTotal.as_posix()}', 'w').write(str(foldsTotal))"
-                                    , "    return foldsTotal"
+                                    , f"        open('{pathFilenameFoldsTotal.as_posix()}', 'w').write(str(groupsOfFolds))"
+                                    , "    return groupsOfFolds"
                                     ])
 
     linesAll = "\n".join([
@@ -149,7 +137,7 @@ if __name__ == '__main__':
                         , linesLaunch
                         ])
 
-    pathFilenameDestination = pathFilenameJob.with_stem(pathFilenameJob.parent.name).with_suffix(".py")
+    pathFilenameDestination = pathFilenameFoldsTotal.with_suffix(".py")
     pathFilenameDestination.write_text(linesAll)
 
     return pathFilenameDestination
@@ -160,11 +148,10 @@ if __name__ == '__main__':
     datatypeMedium = 'uint8'
     datatypeSmall = datatypeMedium
     pathFilenameModule = writeModuleWithNumba(listDimensions, datatypeLarge=datatypeLarge, datatypeMedium=datatypeMedium, datatypeSmall=datatypeSmall)
+
     # 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}")
+    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}")
+    if moduleSpec.loader is None: raise ImportError(f"Could not load module from {moduleSpec}")
     moduleSpec.loader.exec_module(module)

someAssemblyRequired/synthesizeModules.py

@@ -1,10 +1,10 @@
 from mapFolding import indexMy, indexTrack, getAlgorithmSource, ParametersNumba, parametersNumbaDEFAULT, hackSSOTdtype
-from mapFolding import datatypeLargeDEFAULT, datatypeMediumDEFAULT, datatypeSmallDEFAULT
+from mapFolding import datatypeLargeDEFAULT, datatypeMediumDEFAULT, datatypeSmallDEFAULT, EnumIndices
 import pathlib
 import inspect
 import numpy
 import numba
-from typing import Dict, Optional, List, Set, Union, Sequence
+from typing import Dict, Optional, List, Union, Sequence, Type, cast
 import ast
 
 algorithmSource = getAlgorithmSource()
@@ -15,7 +15,7 @@ class RecursiveInliner(ast.NodeTransformer):
         self.processed = set()
 
     def inlineFunctionBody(self, functionName: str) -> Optional[ast.FunctionDef]:
-        if functionName in self.processed:
+        if (functionName in self.processed):
             return None
 
         self.processed.add(functionName)
@@ -27,39 +27,38 @@ class RecursiveInliner(ast.NodeTransformer):
 
     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:
+        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:
+                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:
+                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:
+        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:
+                if (inlineDefinition):
                     return [self.visit(stmt) for stmt in inlineDefinition.body]
         return self.generic_visit(node)
 
-def decorateCallableWithNumba(astCallable: ast.FunctionDef, parallel: bool=False, **keywordArguments: Optional[str]):
+def 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 = [ast.Slice() for axis in range(len(annotationShape.slice.elts))]
+                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=shapeAsListSlices, ctx=ast.Load())
+                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):
+            if (isinstance(annotationDtype, ast.Subscript) and isinstance(annotationDtype.slice, ast.Attribute)):
                 datatypeAST = annotationDtype.slice.attr
             else:
                 datatypeAST = None
@@ -75,15 +74,18 @@ def decorateCallableWithNumba(astCallable: ast.FunctionDef, parallel: bool=False
 
     # callableSourceDecorators = [decorator for decorator in callableInlined.decorator_list]
 
-    listNumbaParameterSignature: List[ast.Subscript] = []
+    listNumbaParameterSignature: Sequence[ast.expr] = []
     for parameter in astCallable.args.args:
         signatureElement = makeNumbaParameterSignatureElement(parameter)
-        if signatureElement:
+        if (signatureElement):
             listNumbaParameterSignature.append(signatureElement)
 
     astArgsNumbaSignature = ast.Tuple(elts=listNumbaParameterSignature, ctx=ast.Load())
 
-    parametersNumba = parametersNumbaDEFAULT if not parallel else ParametersNumba({**parametersNumbaDEFAULT, 'parallel': True})
+    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)
@@ -91,56 +93,92 @@ def decorateCallableWithNumba(astCallable: ast.FunctionDef, parallel: bool=False
     astCallable.decorator_list = [astDecoratorNumba]
     return astCallable
 
-def getDictionaryEnumValues() -> Dict[str, int]:
-    dictionaryEnumValues = {}
-    for enumIndex in [indexMy, indexTrack]:
-        for memberName, memberValue in enumIndex._member_map_.items():
-            dictionaryEnumValues[f"{enumIndex.__name__}.{memberName}.value"] = memberValue.value
-    return dictionaryEnumValues
-
-def unpackArrays(codeInlined: str) -> str:
-    dictionaryReplaceScalars = {
-        'my[indexMy.dimensionsTotal.value]': 'dimensionsTotal',
-        'my[indexMy.dimensionsUnconstrained.value]': 'dimensionsUnconstrained',
-        'my[indexMy.gap1ndex.value]': 'gap1ndex',
-        'my[indexMy.gap1ndexCeiling.value]': 'gap1ndexCeiling',
-        'my[indexMy.indexDimension.value]': 'indexDimension',
-        # 'my[indexMy.indexLeaf.value]': 'indexLeaf',
-        'my[indexMy.indexMiniGap.value]': 'indexMiniGap',
-        'my[indexMy.leaf1ndex.value]': 'leaf1ndex',
-        'my[indexMy.leafConnectee.value]': 'leafConnectee',
-        # 'my[indexMy.taskDivisions.value]': 'taskDivisions',
-        'my[indexMy.taskIndex.value]': 'taskIndex',
-        # 'foldGroups[-1]': 'leavesTotal',
-    }
-
-    dictionaryReplaceArrays = {
-        "track[indexTrack.leafAbove.value, ": 'leafAbove[',
-        "track[indexTrack.leafBelow.value, ": 'leafBelow[',
-        'track[indexTrack.countDimensionsGapped.value, ': 'countDimensionsGapped[',
-        'track[indexTrack.gapRangeStart.value, ': 'gapRangeStart[',
-    }
-
-    ImaIndent = "    "
-    linesInitialize = """"""
-
-    for find, replace in dictionaryReplaceScalars.items():
-        linesInitialize += f"{ImaIndent}{replace} = {find}\n"
-        codeInlined = codeInlined.replace(find, replace)
-
-    for find, replace in dictionaryReplaceArrays.items():
-        linesInitialize += f"{ImaIndent}{replace[0:-1]} = {find[0:-2]}]\n"
-        codeInlined = codeInlined.replace(find, replace)
-
-    ourGuyOnTheInside = "    doFindGaps = True\n"
-    linesInitialize = ourGuyOnTheInside + linesInitialize
-
-    codeInlined = codeInlined.replace(ourGuyOnTheInside, linesInitialize)
-
-    return codeInlined
+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]):
-    dictionaryEnumValues = getDictionaryEnumValues()
     codeSource = inspect.getsource(algorithmSource)
     pathFilenameAlgorithm = pathlib.Path(inspect.getfile(algorithmSource))
 
@@ -157,13 +195,21 @@ def inlineMapFoldingNumba(**keywordArguments: Optional[str]):
             ast.fix_missing_locations(callableInlined)
             callableDecorated = decorateCallableWithNumba(callableInlined, parallel, **keywordArguments)
 
-            importsRequired = "\n".join([ast.unparse(importStatement) for importStatement in codeSourceImportStatements])
-            callableInlined = ast.unparse(callableDecorated)
-            codeUnpacked = unpackArrays(callableInlined) if callableTarget == 'countSequential' else callableInlined
-            # inlinedCode = ast.unparse(ast.Module(body=[nodeInlined], type_ignores=[]))
+            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
-            pathFilenameDestination.write_text(importsRequired + "\n" + codeUnpacked)
+            pathFilenameDestination = pathFilenameAlgorithm.parent / "syntheticModules" / pathFilenameAlgorithm.with_stem(callableTarget).name[5:None]
+            pathFilenameDestination.write_text(moduleSource)
             listPathFilenamesDestination.append(pathFilenameDestination)
 
 if __name__ == '__main__':

syntheticModules/{countInitialize.py → Initialize.py}

@@ -1,11 +1,12 @@
-from numpy import integer
 import numba
-import numpy
+from numpy import integer
 from mapFolding import indexMy, indexTrack
+import numpy
 from typing import Any, Tuple
-@numba.jit((numba.uint8[:, :, ::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=False, inline='never', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=False)
+
+@numba.jit((numba.uint8[:, :, ::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]))
 def countInitialize(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]):
-    while my[indexMy.leaf1ndex.value] > 0:
+    while my[indexMy.leaf1ndex.value]:
         if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
             my[indexMy.dimensionsUnconstrained.value] = my[indexMy.dimensionsTotal.value]
             my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
@@ -35,7 +36,7 @@ def countInitialize(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.d
                     my[indexMy.gap1ndex.value] += 1
                 track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
                 my[indexMy.indexMiniGap.value] += 1
-        if my[indexMy.leaf1ndex.value] > 0:
+        if my[indexMy.leaf1ndex.value]:
             my[indexMy.gap1ndex.value] -= 1
             track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]] = gapsWhere[my[indexMy.gap1ndex.value]]
             track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]] = track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]]

syntheticModules/{countParallel.py → Parallel.py}

@@ -3,18 +3,19 @@ from typing import Any, Tuple
 import numba
 from mapFolding import indexMy, indexTrack
 import numpy
+
 @numba.jit((numba.uint8[:, :, ::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=False, inline='never', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=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)
         gapsWhere = gapsWherePARALLEL.copy()
         my = myPARALLEL.copy()
         my[indexMy.taskIndex.value] = indexSherpa
         track = trackPARALLEL.copy()
-        groupsOfFolds: int = 0
-        while my[indexMy.leaf1ndex.value] > 0:
+        while my[indexMy.leaf1ndex.value]:
             if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
                 if my[indexMy.leaf1ndex.value] > foldGroups[-1]:
-                    groupsOfFolds = groupsOfFolds + 1
+                    groupsOfFolds += 1
                 else:
                     my[indexMy.dimensionsUnconstrained.value] = my[indexMy.dimensionsTotal.value]
                     my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
@@ -39,11 +40,11 @@ def countParallel(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dty
                             my[indexMy.gap1ndex.value] += 1
                         track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
                         my[indexMy.indexMiniGap.value] += 1
-            while my[indexMy.leaf1ndex.value] > 0 and my[indexMy.gap1ndex.value] == track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]:
+            while my[indexMy.leaf1ndex.value] and my[indexMy.gap1ndex.value] == track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]:
                 my[indexMy.leaf1ndex.value] -= 1
                 track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]
                 track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]
-            if my[indexMy.leaf1ndex.value] > 0:
+            if my[indexMy.leaf1ndex.value]:
                 my[indexMy.gap1ndex.value] -= 1
                 track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]] = gapsWhere[my[indexMy.gap1ndex.value]]
                 track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]] = track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]]

syntheticModules/{countSequential.py → Sequential.py}

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

syntheticModules/__init__.py

@@ -1,3 +1,4 @@
-from .countSequential import countSequential
-from .countParallel import countParallel
-from .countInitialize import countInitialize
+from .Initialize import countInitialize
+from .Parallel import countParallel
+from .Sequential import countSequential
+

mapFolding-0.3.4.dist-info/RECORD

@@ -1,26 +0,0 @@
-benchmarks/benchmarking.py,sha256=HD_0NSvuabblg94ftDre6LFnXShTe8MYj3hIodW-zV0,3076
-citations/updateCitation.py,sha256=3AUPo9_4SfH8AwQBMRl7KygAXoMRjQSqFl3ERWxtrtk,2541
-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=7iODZE6dM4h52spgivUvAuVsvYdSx-_YcSTz1gX82Vw,89
-someAssemblyRequired/generalizeSourceCode.py,sha256=qyJD0ZdG0t-SYTItL_JjaIXm3-joWt3e-2nMSAH4Dbg,6392
-someAssemblyRequired/getLLVMforNoReason.py,sha256=FtJzw2pZS3A4NimWdZsegXaU-vKeCw8m67kcfb5wvGM,894
-someAssemblyRequired/makeJob.py,sha256=iaLjr-FhFloTF6wSuwOpurgpqJulZht9CxNo9MDidbg,949
-someAssemblyRequired/synthesizeModuleJob.py,sha256=xLak-ZZ1zQ92jBobhJqbnA1Fua9ofiRvLdK1fmD8s_s,7271
-someAssemblyRequired/synthesizeModules.py,sha256=JGOx69DGCcCntRtw7aOXXcmERCHqVyhFo1oiKh3P8Mg,8842
-syntheticModules/__init__.py,sha256=nDtS5UFMKN-F5pTp0qKA0J0I-XR3n3OFxV2bosieBu8,131
-syntheticModules/countInitialize.py,sha256=QqKfQxCmUJuJutNxOZ0VfqYEHnuk7XSkCYx7RKz3kn4,4239
-syntheticModules/countParallel.py,sha256=77JzO3TsccjSUJRExZ0Nxdqowd_Sm0_2bRziVx5XMI4,5355
-syntheticModules/countSequential.py,sha256=QixgcN9R5zcrmJjxSO4oOCYViWogA35HbDNlni9hw8o,3655
-mapFolding-0.3.4.dist-info/METADATA,sha256=v8MJLZBzqS2hBp4trsRjjLzn8RAsddUPg16IiI9J1cg,7617
-mapFolding-0.3.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapFolding-0.3.4.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapFolding-0.3.4.dist-info/top_level.txt,sha256=yVG9dNZywoaddcsUdEDg7o0XOBzJd_4Z-sDaXGHpiMY,69
-mapFolding-0.3.4.dist-info/RECORD,,