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

citations/updateCitation.py

@@ -1,48 +1,18 @@
 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
+from packaging.metadata import Metadata as PyPAMetadata
+from typing import Any, Dict, List
+import attrs
 import cffconvert
-import pathlib
-import packaging.metadata
-import tomli
-import inspect
-import json
-import ruamel.yaml
+import tempfile
 import packaging
-from packaging.metadata import Metadata as PyPAMetadata
+import packaging.metadata
 import packaging.utils
 import packaging.version
+import pathlib
+import ruamel.yaml
+import tomli
 
-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
+listProjectURLsTarget: List[str] = ["homepage", "license", "repository"]
 
 """
 Tentative plan:
@@ -55,34 +25,194 @@ 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
-cff-version: pathFilenameCitationSSOT
-commit: workflows['Make GitHub Release']
-contact: pathFilenamePackageSSOT
-date-released: workflows['Make GitHub Release']
-doi: pathFilenameCitationSSOT
-identifiers: workflows['Make GitHub Release']
-license-url: pathFilenamePackageSSOT
-message: pathFilenameCitationSSOT
-preferred-citation: pathFilenameCitationSSOT
-references: to be determined
-repository-artifact: (https://pypi.org/pypi/{package_name}/json').json()['releases']
-repository-code: workflows['Make GitHub Release']
-type: pathFilenameCitationSSOT
-
-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
-"""
+
+@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
-    packageName: str = 'mapFolding'
+    packageNameHARDCODED: str = 'mapFolding'
+
+    packageName: str = packageNameHARDCODED
     pathRepoRoot = pathlib.Path(__file__).parent.parent.parent
     pathFilenamePackageSSOT = pathRepoRoot / 'pyproject.toml'
     filenameGitHubAction = 'updateCitation.yml'
@@ -93,24 +223,16 @@ def logistics():
     pathFilenameCitationSSOT = pathCitations / filenameCitationDOTcff
     pathFilenameCitationDOTcffRepo = pathRepoRoot / filenameCitationDOTcff
 
-    citationObject: cffconvert.Citation = create_citation(infile=pathFilenameCitationSSOT, url=None)
-    print(citationObject._parse().as_cff())
+    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)
 
-    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)
+    nexusCitation = addPypaMetadata(nexusCitation, pypaMetadata)
+    nexusCitation = add_pyprojectDOTtoml(nexusCitation, tomlPackageData)
+
+    writeCitation(nexusCitation, pathFilenameCitationSSOT, pathFilenameCitationDOTcffRepo)
 
 if __name__ == '__main__':
     logistics()
-
-    # 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))

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

@@ -1,12 +1,12 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.3.6
+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: Homepage, https://github.com/hunterhogan/mapFolding
 Project-URL: Donate, https://www.patreon.com/integrated
-Project-URL: repository, https://github.com/hunterhogan/mapFolding.git
+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
@@ -30,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.6.dist-info → mapFolding-0.3.7.dist-info}/RECORD

@@ -1,6 +1,5 @@
 benchmarks/benchmarking.py,sha256=HD_0NSvuabblg94ftDre6LFnXShTe8MYj3hIodW-zV0,3076
-citations/updateCitation.py,sha256=PPxOERlYnw9b9xydiZL8utTU-sC2B4rBfOgjXc1S0OY,5264
-citations/updateCitationgpt.py,sha256=NtgSP4BCO5YcaYcYYb31vOxXcp3hmooug8VYpbhTc_w,4751
+citations/updateCitation.py,sha256=2MI8wHzLZg8eg2tAkbtynXPttxg3tTrd5ezEZIVyW48,10956
 reference/flattened.py,sha256=6blZ2Y9G8mu1F3gV8SKndPE398t2VVFlsgKlyeJ765A,16538
 reference/hunterNumba.py,sha256=HWndRgsajOf76rbb2LDNEZ6itsdYbyV-k3wgOFjeR6c,7104
 reference/irvineJavaPort.py,sha256=Sj-63Z-OsGuDoEBXuxyjRrNmmyl0d7Yz_XuY7I47Oyg,4250
@@ -11,17 +10,16 @@ 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/synthesizeModuleJob.py,sha256=n6_2LUO2mf4PUuzN357EJiTATFB1TIAMDMgE5JvkcB0,7426
 someAssemblyRequired/synthesizeModules.py,sha256=foxk-mG-HGVap2USiA3ppCyWWXUmkLFzQiKacp5DD9M,11569
-syntheticModules/Initialize.py,sha256=KIAxLSyblzDTL8QJYINmdRjk2iRVYzXOWeqY8P6wPgw,4024
+syntheticModules/Initialize.py,sha256=Ut6rWt08LQ-kP9y-r25hwJjW82lO2DQfLBijhkKGaUo,4024
 syntheticModules/Parallel.py,sha256=Kq1uo5kfeeczk871yxaagsaNz8zaM8GWy0S3hZAEQz4,5343
-syntheticModules/Sequential.py,sha256=JwpHNFt_w77J0RBVoBji-OLnYNSTMnusRlYU-6b4P2w,3643
+syntheticModules/Sequential.py,sha256=8KDiuK977s8hkyNw5pCZPNi0RHWDoCxwOteZ8CLuIEM,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,,
+mapFolding-0.3.7.dist-info/METADATA,sha256=BnMb2zDVlBgxU57qquN7iLYDSRHMkGmsL0ovLA_2G7k,7729
+mapFolding-0.3.7.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapFolding-0.3.7.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapFolding-0.3.7.dist-info/top_level.txt,sha256=yVG9dNZywoaddcsUdEDg7o0XOBzJd_4Z-sDaXGHpiMY,69
+mapFolding-0.3.7.dist-info/RECORD,,

someAssemblyRequired/synthesizeModuleJob.py

@@ -116,10 +116,11 @@ def writeModuleWithNumba(listDimensions, **keywordArguments: Optional[str]) -> p
     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

syntheticModules/Initialize.py

@@ -1,8 +1,8 @@
-import numba
-from numpy import integer
-from mapFolding import indexMy, indexTrack
 import numpy
 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]))
 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]]]):

syntheticModules/Sequential.py

@@ -1,6 +1,6 @@
 from numpy import integer
-import numba
 from typing import Any, Tuple
+import numba
 from mapFolding import indexMy, indexTrack
 import numpy
 

citations/updateCitationgpt.py

@@ -1,125 +0,0 @@
-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()

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)