mapFolding 0.3.5__tar.gz → 0.3.7__tar.gz

{mapfolding-0.3.5 → mapfolding-0.3.7}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.3.5
+Version: 0.3.7
 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: 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
@@ -29,12 +30,13 @@ Requires-Dist: jupyter; extra == "benchmark"
 Requires-Dist: pandas; extra == "benchmark"
 Requires-Dist: tqdm; extra == "benchmark"
 Provides-Extra: testing
+Requires-Dist: attrs; extra == "testing"
 Requires-Dist: cffconvert; extra == "testing"
 Requires-Dist: more_itertools; extra == "testing"
-Requires-Dist: pytest; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: pytest-env; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
+Requires-Dist: pytest; extra == "testing"
 Requires-Dist: python_minifier; extra == "testing"
 Requires-Dist: tomli; extra == "testing"
 

mapfolding-0.3.7/mapFolding/citations/updateCitation.py

@@ -0,0 +1,238 @@
+from cffconvert.cli.create_citation import create_citation
+from packaging.metadata import Metadata as PyPAMetadata
+from typing import Any, Dict, List
+import attrs
+import cffconvert
+import tempfile
+import packaging
+import packaging.metadata
+import packaging.utils
+import packaging.version
+import pathlib
+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
+"""
+
+@attrs.define
+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
+
+    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 # pathFilenameCitationSSOT
+                # message: str # pathFilenameCitationSSOT
+                # abstract: str | None = None # pathFilenameCitationSSOT
+                # doi: str | None = None # pathFilenameCitationSSOT
+                # preferredDASHcitation: str | None = None # pathFilenameCitationSSOT
+                # type: str | None = None # pathFilenameCitationSSOT
+            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 "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 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.")
+
+    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 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 = pathlib.Path(tempfile.mktemp())
+
+    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(verbose=True) is None:
+        writeStream(pathFilenameCitationSSOT)
+        writeStream(pathFilenameCitationDOTcffRepo)
+
+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
+
+    filenameCitationDOTcff = 'CITATION.cff'
+    pathCitations = pathRepoRoot / packageName / 'citations'
+    pathFilenameCitationSSOT = pathCitations / filenameCitationDOTcff
+    pathFilenameCitationDOTcffRepo = pathRepoRoot / filenameCitationDOTcff
+
+    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)
+
+    writeCitation(nexusCitation, pathFilenameCitationSSOT, pathFilenameCitationDOTcffRepo)
+
+if __name__ == '__main__':
+    logistics()

{mapfolding-0.3.5 → mapfolding-0.3.7}/mapFolding/mapFolding.egg-info/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.3.5
+Version: 0.3.7
 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: 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
@@ -29,12 +30,13 @@ Requires-Dist: jupyter; extra == "benchmark"
 Requires-Dist: pandas; extra == "benchmark"
 Requires-Dist: tqdm; extra == "benchmark"
 Provides-Extra: testing
+Requires-Dist: attrs; extra == "testing"
 Requires-Dist: cffconvert; extra == "testing"
 Requires-Dist: more_itertools; extra == "testing"
-Requires-Dist: pytest; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: pytest-env; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
+Requires-Dist: pytest; extra == "testing"
 Requires-Dist: python_minifier; extra == "testing"
 Requires-Dist: tomli; extra == "testing"
 

{mapfolding-0.3.5 → mapfolding-0.3.7}/mapFolding/mapFolding.egg-info/SOURCES.txt

@@ -18,15 +18,14 @@ mapFolding/reference/lunnanWhile.py
 mapFolding/reference/rotatedEntryPoint.py
 mapFolding/reference/total_countPlus1vsPlusN.py
 mapFolding/someAssemblyRequired/__init__.py
-mapFolding/someAssemblyRequired/generalizeSourceCode.py
 mapFolding/someAssemblyRequired/getLLVMforNoReason.py
 mapFolding/someAssemblyRequired/makeJob.py
 mapFolding/someAssemblyRequired/synthesizeModuleJob.py
 mapFolding/someAssemblyRequired/synthesizeModules.py
+mapFolding/syntheticModules/Initialize.py
+mapFolding/syntheticModules/Parallel.py
+mapFolding/syntheticModules/Sequential.py
 mapFolding/syntheticModules/__init__.py
-mapFolding/syntheticModules/countInitialize.py
-mapFolding/syntheticModules/countParallel.py
-mapFolding/syntheticModules/countSequential.py
 tests/test_oeis.py
 tests/test_other.py
 tests/test_tasks.py

{mapfolding-0.3.5 → mapfolding-0.3.7}/mapFolding/mapFolding.egg-info/requires.txt

@@ -9,11 +9,12 @@ pandas
 tqdm
 
 [testing]
+attrs
 cffconvert
 more_itertools
-pytest
 pytest-cov
 pytest-env
 pytest-xdist
+pytest
 python_minifier
 tomli

mapfolding-0.3.7/mapFolding/someAssemblyRequired/__init__.py

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

mapfolding-0.3.7/mapFolding/someAssemblyRequired/makeJob.py

@@ -0,0 +1,34 @@
+from mapFolding import getPathFilenameFoldsTotal, computationState
+from mapFolding import outfitCountFolds
+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:
+    ...
+
+@overload
+def makeStateJob(listDimensions: Sequence[int], writeJob: Literal[False] = False
+                 , **keywordArguments: Optional[Type[Any]]) -> computationState:
+    ...
+
+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)])
+    pathJob.mkdir(parents=True, exist_ok=True)
+    pathFilenameJob = pathJob / 'stateJob.pkl'
+
+    pathFilenameJob.write_bytes(pickle.dumps(stateUniversal))
+    return pathFilenameJob

{mapfolding-0.3.5 → mapfolding-0.3.7}/mapFolding/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
@@ -128,18 +116,19 @@ no_cpython_wrapper=False, \
     linesLaunch = """"""
     linesLaunch = linesLaunch + f"""
 if __name__ == '__main__':
-    import time
-    timeStart = time.perf_counter()
+    # import time
+    # timeStart = time.perf_counter()
     {identifierCallableLaunch}()
-    print(time.perf_counter() - timeStart)"""
+    # print(time.perf_counter() - timeStart)
+"""
 
     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 +138,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 +149,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)

{mapfolding-0.3.5 → mapfolding-0.3.7}/mapFolding/someAssemblyRequired/synthesizeModules.py

@@ -82,7 +82,10 @@ def decorateCallableWithNumba(astCallable: ast.FunctionDef, parallel: bool=False
 
     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)
@@ -117,10 +120,7 @@ class UnpackArrayAccesses(ast.NodeTransformer):
                     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
-                )
+                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:
@@ -131,7 +131,6 @@ class UnpackArrayAccesses(ast.NodeTransformer):
         # 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
@@ -152,11 +151,7 @@ class UnpackArrayAccesses(ast.NodeTransformer):
                 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()
-                )
+                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:
@@ -170,44 +165,20 @@ class UnpackArrayAccesses(ast.NodeTransformer):
         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
-                    )
-                )
+                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.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()
-                        )
-                    )
-                )
+                                    attr=name, ctx=ast.Load()), attr='value', ctx=ast.Load()), ctx=ast.Load())))
 
         node.body = initializations + node.body
         return node
 
-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 inlineMapFoldingNumba(**keywordArguments: Optional[str]):
-    dictionaryEnumValues = getDictionaryEnumValues()
     codeSource = inspect.getsource(algorithmSource)
     pathFilenameAlgorithm = pathlib.Path(inspect.getfile(algorithmSource))
 
@@ -233,11 +204,12 @@ def inlineMapFoldingNumba(**keywordArguments: Optional[str]):
                 callableDecorated = cast(ast.FunctionDef, trackUnpacker.visit(callableDecorated))
                 ast.fix_missing_locations(callableDecorated)
 
-            callableInlined = ast.unparse(callableDecorated)
-            importsRequired = "\n".join([ast.unparse(importStatement) for importStatement in codeSourceImportStatements])
+            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" + callableInlined)
+            pathFilenameDestination = pathFilenameAlgorithm.parent / "syntheticModules" / pathFilenameAlgorithm.with_stem(callableTarget).name[5:None]
+            pathFilenameDestination.write_text(moduleSource)
             listPathFilenamesDestination.append(pathFilenameDestination)
 
 if __name__ == '__main__':

mapfolding-0.3.5/mapFolding/syntheticModules/countInitialize.py → mapfolding-0.3.7/mapFolding/syntheticModules/Initialize.py

@@ -3,9 +3,10 @@ from typing import Any, Tuple
 from mapFolding import indexMy, indexTrack
 import numba
 from numpy import integer
-@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]]]

mapfolding-0.3.5/mapFolding/syntheticModules/countParallel.py → mapfolding-0.3.7/mapFolding/syntheticModules/Parallel.py

@@ -3,15 +3,16 @@ 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: int = 0
+        groupsOfFolds = numba.types.int64(0)
         gapsWhere = gapsWherePARALLEL.copy()
         my = myPARALLEL.copy()
         my[indexMy.taskIndex.value] = indexSherpa
         track = trackPARALLEL.copy()
-        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 += 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]]]

mapfolding-0.3.5/mapFolding/syntheticModules/countSequential.py → mapfolding-0.3.7/mapFolding/syntheticModules/Sequential.py

@@ -3,6 +3,7 @@ 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=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]]]):
     leafBelow = track[indexTrack.leafBelow.value]
@@ -18,9 +19,9 @@ def countSequential(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.d
     indexMiniGap = my[indexMy.indexMiniGap.value]
     gap1ndex = my[indexMy.gap1ndex.value]
     taskIndex = my[indexMy.taskIndex.value]
-    groupsOfFolds: int = 0
+    groupsOfFolds = numba.types.int64(0)
     doFindGaps = True
-    while leaf1ndex > 0:
+    while leaf1ndex:
         if (doFindGaps := (leaf1ndex <= 1 or leafBelow[0] == 1)) and leaf1ndex > foldGroups[-1]:
             groupsOfFolds += 1
         elif doFindGaps:
@@ -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]]

mapfolding-0.3.7/mapFolding/syntheticModules/__init__.py

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

{mapfolding-0.3.5 → mapfolding-0.3.7}/pyproject.toml

@@ -28,7 +28,8 @@ keywords = [
     "map folding",
     "OEIS",
     "stamp folding",]
-license = { text = "CC-BY-NC-4.0" }
+license = { 'text' = "CC-BY-NC-4.0" }
+maintainers = []
 name = "mapFolding"
 optional-dependencies = { benchmark = [
     "ipywidgets",
@@ -36,19 +37,20 @@ optional-dependencies = { benchmark = [
     "pandas",
     "tqdm",
 ], testing = [
+    "attrs",
     "cffconvert",
     "more_itertools",
-    "pytest",
     "pytest-cov",
     "pytest-env",
     "pytest-xdist",
+    "pytest",
     "python_minifier",
     "tomli",] }
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10,<3.14"
 scripts = { getOEISids = "mapFolding.oeis:getOEISids", clearOEIScache = "mapFolding.oeis:clearOEIScache", OEIS_for_n = "mapFolding.oeis:OEIS_for_n" }
-urls = { Homepage = "https://github.com/hunterhogan/mapFolding", Donate = "https://www.patreon.com/integrated" }
-version = "0.3.5"
+urls = { Homepage = "https://github.com/hunterhogan/mapFolding", Donate = "https://www.patreon.com/integrated", Repository = "https://github.com/hunterhogan/mapFolding.git" }
+version = "0.3.7"
 
 [tool.coverage]
 report = { exclude_lines = [

mapfolding-0.3.5/mapFolding/citations/updateCitation.py

@@ -1,67 +0,0 @@
-from cffconvert.cli.create_citation import create_citation
-from typing import Any, Dict
-import cffconvert
-import pathlib
-import tomli
-import inspect
-import json
-
-"""
-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
-"""
-
-"""cffconvert.Citation fields and the source of truth
-abstract: pathFilenameCitationSSOT
-authors: pathFilenamePackageSSOT
-cff-version: pathFilenameCitationSSOT
-commit: workflows['Make GitHub Release']
-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
-"""
-# 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
-
-tomlPackageData: Dict[str, Any] = tomli.loads(pathFilenamePackageSSOT.read_text())['project']
-
-citationObject: cffconvert.Citation = create_citation(infile=pathFilenameCitationSSOT, url=None)
-
-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))

mapfolding-0.3.5/mapFolding/someAssemblyRequired/__init__.py

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

mapfolding-0.3.5/mapFolding/someAssemblyRequired/generalizeSourceCode.py

@@ -1,122 +0,0 @@
-from mapFolding import datatypeLargeDEFAULT, datatypeMediumDEFAULT, datatypeSmallDEFAULT
-from typing import Dict, Optional, List, Set, Union
-import ast
-
-class RecursiveInlinerWithEnum(ast.NodeTransformer):
-    """Process AST nodes to inline functions and substitute enum values.
-    Also handles function decorators during inlining."""
-
-    def __init__(self, dictionaryFunctions: Dict[str, ast.FunctionDef], dictionaryEnumValues: Dict[str, int]) -> None:
-        self.dictionaryFunctions = dictionaryFunctions
-        self.dictionaryEnumValues = dictionaryEnumValues
-        self.processed = set()
-
-    def inlineFunctionBody(self, functionName: str) -> Optional[ast.FunctionDef]:
-        if functionName in self.processed:
-            return None
-
-        self.processed.add(functionName)
-        inlineDefinition = self.dictionaryFunctions[functionName]
-        # Recursively process the function body
-        for node in ast.walk(inlineDefinition):
-            self.visit(node)
-        return inlineDefinition
-
-    def visit_Attribute(self, node: ast.Attribute) -> ast.AST:
-        # Substitute enum identifiers (e.g., indexMy.leaf1ndex.value)
-        if isinstance(node.value, ast.Attribute) and isinstance(node.value.value, ast.Name):
-            enumPath = f"{node.value.value.id}.{node.value.attr}.{node.attr}"
-            if enumPath in self.dictionaryEnumValues:
-                return ast.Constant(value=self.dictionaryEnumValues[enumPath])
-        return self.generic_visit(node)
-
-    def visit_Call(self, node: ast.Call) -> ast.AST:
-        callNode = self.generic_visit(node)
-        if isinstance(callNode, ast.Call) and isinstance(callNode.func, ast.Name) and callNode.func.id in self.dictionaryFunctions:
-            inlineDefinition = self.inlineFunctionBody(callNode.func.id)
-            if (inlineDefinition and inlineDefinition.body):
-                lastStmt = inlineDefinition.body[-1]
-                if isinstance(lastStmt, ast.Return) and lastStmt.value is not None:
-                    return self.visit(lastStmt.value)
-                elif isinstance(lastStmt, ast.Expr) and lastStmt.value is not None:
-                    return self.visit(lastStmt.value)
-                return ast.Constant(value=None)
-        return callNode
-
-    def visit_Expr(self, node: ast.Expr) -> Union[ast.AST, List[ast.AST]]:
-        if isinstance(node.value, ast.Call):
-            if isinstance(node.value.func, ast.Name) and node.value.func.id in self.dictionaryFunctions:
-                inlineDefinition = self.inlineFunctionBody(node.value.func.id)
-                if inlineDefinition:
-                    return [self.visit(stmt) for stmt in inlineDefinition.body]
-        return self.generic_visit(node)
-
-def findRequiredImports(node: ast.AST) -> Set[str]:
-    """Find all modules that need to be imported based on AST analysis.
-    NOTE: due to hardcoding, this is a glorified regex. No, wait, this is less versatile than regex."""
-    requiredImports = set()
-
-    class ImportFinder(ast.NodeVisitor):
-        def visit_Name(self, node: ast.Name) -> None:
-            if node.id in {'numba'}:
-                requiredImports.add(node.id)
-            self.generic_visit(node)
-
-        def visitDecorator(self, node: ast.AST) -> None:
-            if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
-                if node.func.id == 'jit':
-                    requiredImports.add('numba')
-            self.generic_visit(node)
-
-    ImportFinder().visit(node)
-    return requiredImports
-
-def generateImports(requiredImports: Set[str]) -> str:
-    """Generate import statements based on required modules."""
-    importStatements = {'import numba', 'from mapFolding import indexMy, indexTrack'}
-
-    importMapping = {
-        'numba': 'import numba',
-    }
-
-    for moduleName in sorted(requiredImports):
-        if moduleName in importMapping:
-            importStatements.add(importMapping[moduleName])
-
-    return '\n'.join(importStatements)
-
-def makeInlineFunction(sourceCode: str, targetFunctionName: str, dictionaryEnumValues: Dict[str, int], skipEnum: bool=False, **keywordArguments: Optional[str]):
-    datatypeLarge = keywordArguments.get('datatypeLarge', datatypeLargeDEFAULT)
-    datatypeMedium = keywordArguments.get('datatypeMedium', datatypeMediumDEFAULT)
-    datatypeSmall = keywordArguments.get('datatypeSmall', datatypeSmallDEFAULT)
-    if skipEnum:
-        dictionaryEnumValues = {}
-    dictionaryParsed = ast.parse(sourceCode)
-    dictionaryFunctions = {
-        element.name: element
-        for element in dictionaryParsed.body
-        if isinstance(element, ast.FunctionDef)
-    }
-    nodeTarget = dictionaryFunctions[targetFunctionName]
-    nodeInliner = RecursiveInlinerWithEnum(dictionaryFunctions, dictionaryEnumValues)
-    nodeInlined = nodeInliner.visit(nodeTarget)
-    ast.fix_missing_locations(nodeInlined)
-    callableInlinedDecorators = [decorator for decorator in nodeInlined.decorator_list]
-
-    requiredImports = findRequiredImports(nodeInlined)
-    importStatements = generateImports(requiredImports)
-    importsRequired = importStatements
-    dictionaryDecoratorsNumba={
-        'countInitialize':
-        f'@numba.jit((numba.{datatypeSmall}[:,:,::1], numba.{datatypeMedium}[::1], numba.{datatypeSmall}[::1], numba.{datatypeMedium}[:,::1]), parallel=False, boundscheck=False, cache=True, error_model="numpy", fastmath=True, looplift=False, nogil=True, nopython=True)\n',
-        'countParallel':
-        f'@numba.jit((numba.{datatypeSmall}[:,:,::1], numba.{datatypeLarge}[::1], numba.{datatypeMedium}[::1], numba.{datatypeSmall}[::1], numba.{datatypeMedium}[:,::1]), parallel=True, boundscheck=False, cache=True, error_model="numpy", fastmath=True, looplift=False, nogil=True, nopython=True)\n',
-        'countSequential':
-        f'@numba.jit((numba.{datatypeSmall}[:,:,::1], numba.{datatypeLarge}[::1], numba.{datatypeMedium}[::1], numba.{datatypeSmall}[::1], numba.{datatypeMedium}[:,::1]), parallel=False, boundscheck=False, cache=True, error_model="numpy", fastmath=True, looplift=False, nogil=True, nopython=True)\n',
-        }
-
-    lineNumbaDecorator = dictionaryDecoratorsNumba[targetFunctionName]
-
-    # inlinedCode = ast.unparse(ast.Module(body=[nodeInlined], type_ignores=[]))
-    callableInlined = lineNumbaDecorator + ast.unparse(nodeInlined)
-    return (callableInlined, callableInlinedDecorators, importsRequired)

mapfolding-0.3.5/mapFolding/someAssemblyRequired/makeJob.py

@@ -1,21 +0,0 @@
-from mapFolding import getPathFilenameFoldsTotal
-from mapFolding import outfitCountFolds
-from typing import Any, Optional, Sequence, Type
-import pathlib
-import pickle
-
-def makeStateJob(listDimensions: Sequence[int], **keywordArguments: Optional[Type[Any]]) -> pathlib.Path:
-
-    stateUniversal = outfitCountFolds(listDimensions, computationDivisions=None, CPUlimit=None, **keywordArguments)
-
-    from syntheticModules import countInitialize
-    countInitialize(stateUniversal['connectionGraph'], stateUniversal['gapsWhere'], stateUniversal['my'], stateUniversal['track'])
-
-    pathFilenameChopChop = getPathFilenameFoldsTotal(stateUniversal['mapShape'])
-    suffix = pathFilenameChopChop.suffix
-    pathJob = pathlib.Path(str(pathFilenameChopChop)[0:-len(suffix)])
-    pathJob.mkdir(parents=True, exist_ok=True)
-    pathFilenameJob = pathJob / 'stateJob.pkl'
-
-    pathFilenameJob.write_bytes(pickle.dumps(stateUniversal))
-    return pathFilenameJob

mapfolding-0.3.5/mapFolding/syntheticModules/__init__.py

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