mapFolding 0.3.3__tar.gz → 0.3.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.3.3
+Version: 0.3.5
 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
@@ -29,12 +29,14 @@ Requires-Dist: jupyter; extra == "benchmark"
 Requires-Dist: pandas; extra == "benchmark"
 Requires-Dist: tqdm; extra == "benchmark"
 Provides-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: python_minifier; extra == "testing"
+Requires-Dist: tomli; extra == "testing"
 
 # Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
 

mapfolding-0.3.5/mapFolding/citations/updateCitation.py

@@ -0,0 +1,67 @@
+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.3 → mapfolding-0.3.5}/mapFolding/mapFolding.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.3.3
+Version: 0.3.5
 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
@@ -29,12 +29,14 @@ Requires-Dist: jupyter; extra == "benchmark"
 Requires-Dist: pandas; extra == "benchmark"
 Requires-Dist: tqdm; extra == "benchmark"
 Provides-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: python_minifier; extra == "testing"
+Requires-Dist: tomli; extra == "testing"
 
 # Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
 

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

@@ -1,6 +1,7 @@
 README.md
 pyproject.toml
 mapFolding/benchmarks/benchmarking.py
+mapFolding/citations/updateCitation.py
 mapFolding/mapFolding.egg-info/PKG-INFO
 mapFolding/mapFolding.egg-info/SOURCES.txt
 mapFolding/mapFolding.egg-info/dependency_links.txt
@@ -20,7 +21,7 @@ mapFolding/someAssemblyRequired/__init__.py
 mapFolding/someAssemblyRequired/generalizeSourceCode.py
 mapFolding/someAssemblyRequired/getLLVMforNoReason.py
 mapFolding/someAssemblyRequired/makeJob.py
-mapFolding/someAssemblyRequired/synthesizeJob.py
+mapFolding/someAssemblyRequired/synthesizeModuleJob.py
 mapFolding/someAssemblyRequired/synthesizeModules.py
 mapFolding/syntheticModules/__init__.py
 mapFolding/syntheticModules/countInitialize.py

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

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

mapfolding-0.3.5/mapFolding/someAssemblyRequired/__init__.py

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

{mapfolding-0.3.3 → mapfolding-0.3.5}/mapFolding/someAssemblyRequired/generalizeSourceCode.py

@@ -1,16 +1,17 @@
 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, dictionaryEnumValues):
+    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):
+    def inlineFunctionBody(self, functionName: str) -> Optional[ast.FunctionDef]:
         if functionName in self.processed:
             return None
 
@@ -21,7 +22,7 @@ class RecursiveInlinerWithEnum(ast.NodeTransformer):
             self.visit(node)
         return inlineDefinition
 
-    def visit_Attribute(self, node):
+    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}"
@@ -29,7 +30,7 @@ class RecursiveInlinerWithEnum(ast.NodeTransformer):
                 return ast.Constant(value=self.dictionaryEnumValues[enumPath])
         return self.generic_visit(node)
 
-    def visit_Call(self, 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)
@@ -39,10 +40,10 @@ class RecursiveInlinerWithEnum(ast.NodeTransformer):
                     return self.visit(lastStmt.value)
                 elif isinstance(lastStmt, ast.Expr) and lastStmt.value is not None:
                     return self.visit(lastStmt.value)
-                return None
+                return ast.Constant(value=None)
         return callNode
 
-    def visit_Expr(self, node):
+    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)
@@ -50,18 +51,18 @@ class RecursiveInlinerWithEnum(ast.NodeTransformer):
                     return [self.visit(stmt) for stmt in inlineDefinition.body]
         return self.generic_visit(node)
 
-def findRequiredImports(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):
+        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):
+        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')
@@ -70,7 +71,7 @@ def findRequiredImports(node):
     ImportFinder().visit(node)
     return requiredImports
 
-def generateImports(requiredImports):
+def generateImports(requiredImports: Set[str]) -> str:
     """Generate import statements based on required modules."""
     importStatements = {'import numba', 'from mapFolding import indexMy, indexTrack'}
 
@@ -84,7 +85,7 @@ def generateImports(requiredImports):
 
     return '\n'.join(importStatements)
 
-def makeInlineFunction(sourceCode, targetFunctionName, dictionaryEnumValues, skipEnum=False, **keywordArguments):
+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)

{mapfolding-0.3.3 → mapfolding-0.3.5}/mapFolding/someAssemblyRequired/makeJob.py

@@ -5,8 +5,10 @@ import pathlib
 import pickle
 
 def makeStateJob(listDimensions: Sequence[int], **keywordArguments: Optional[Type[Any]]) -> pathlib.Path:
-    from syntheticModules import countInitialize
+
     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'])

mapfolding-0.3.5/mapFolding/someAssemblyRequired/synthesizeModules.py

@@ -0,0 +1,244 @@
+from mapFolding import indexMy, indexTrack, getAlgorithmSource, ParametersNumba, parametersNumbaDEFAULT, hackSSOTdtype
+from mapFolding import datatypeLargeDEFAULT, datatypeMediumDEFAULT, datatypeSmallDEFAULT, EnumIndices
+import pathlib
+import inspect
+import numpy
+import numba
+from typing import Dict, Optional, List, Union, Sequence, Type, cast
+import ast
+
+algorithmSource = getAlgorithmSource()
+
+class RecursiveInliner(ast.NodeTransformer):
+    def __init__(self, dictionaryFunctions: Dict[str, ast.FunctionDef]):
+        self.dictionaryFunctions = dictionaryFunctions
+        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_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 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: 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=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)):
+                datatypeAST = annotationDtype.slice.attr
+            else:
+                datatypeAST = None
+
+            ndarrayName = signatureElement.arg
+            Z0Z_hackyStr = hackSSOTdtype[ndarrayName]
+            Z0Z_hackyStr = Z0Z_hackyStr[0] + 'ata' + Z0Z_hackyStr[1:]
+            datatype_attr = keywordArguments.get(Z0Z_hackyStr, None) or datatypeAST or eval(Z0Z_hackyStr+'DEFAULT')
+
+            datatypeNumba = ast.Attribute(value=ast.Name(id='numba', ctx=ast.Load()), attr=datatype_attr, ctx=ast.Load())
+
+            return ast.Subscript(value=datatypeNumba, slice=shapeAST, ctx=ast.Load())
+
+    # callableSourceDecorators = [decorator for decorator in callableInlined.decorator_list]
+
+    listNumbaParameterSignature: Sequence[ast.expr] = []
+    for parameter in astCallable.args.args:
+        signatureElement = makeNumbaParameterSignatureElement(parameter)
+        if (signatureElement):
+            listNumbaParameterSignature.append(signatureElement)
+
+    astArgsNumbaSignature = ast.Tuple(elts=listNumbaParameterSignature, ctx=ast.Load())
+
+    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)
+
+    astCallable.decorator_list = [astDecoratorNumba]
+    return astCallable
+
+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 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))
+
+    listPathFilenamesDestination: list[pathlib.Path] = []
+    listCallables = [ 'countInitialize', 'countParallel', 'countSequential', ]
+    for callableTarget in listCallables:
+        codeParsed: ast.Module = ast.parse(codeSource, type_comments=True)
+        codeSourceImportStatements = {statement for statement in codeParsed.body if isinstance(statement, (ast.Import, ast.ImportFrom))}
+        dictionaryFunctions = {statement.name: statement for statement in codeParsed.body if isinstance(statement, ast.FunctionDef)}
+        callableInlinerWorkhorse = RecursiveInliner(dictionaryFunctions)
+        parallel = callableTarget == 'countParallel'
+        callableInlined = callableInlinerWorkhorse.inlineFunctionBody(callableTarget)
+        if callableInlined:
+            ast.fix_missing_locations(callableInlined)
+            callableDecorated = decorateCallableWithNumba(callableInlined, parallel, **keywordArguments)
+
+            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)
+
+            callableInlined = ast.unparse(callableDecorated)
+            importsRequired = "\n".join([ast.unparse(importStatement) for importStatement in codeSourceImportStatements])
+
+            pathFilenameDestination = pathFilenameAlgorithm.parent / "syntheticModules" / pathFilenameAlgorithm.with_stem(callableTarget).name
+            pathFilenameDestination.write_text(importsRequired + "\n" + callableInlined)
+            listPathFilenamesDestination.append(pathFilenameDestination)
+
+if __name__ == '__main__':
+    inlineMapFoldingNumba()

mapfolding-0.3.5/mapFolding/syntheticModules/countInitialize.py

@@ -0,0 +1,47 @@
+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]), _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 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:
+        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]
+            my[indexMy.indexDimension.value] = 0
+            while my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]:
+                if connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]:
+                    my[indexMy.dimensionsUnconstrained.value] -= 1
+                else:
+                    my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
+                    while my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]:
+                        gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.leafConnectee.value]
+                        if track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] == 0:
+                            my[indexMy.gap1ndexCeiling.value] += 1
+                        track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
+                        my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
+                my[indexMy.indexDimension.value] += 1
+            if not my[indexMy.dimensionsUnconstrained.value]:
+                my[indexMy.indexLeaf.value] = 0
+                while my[indexMy.indexLeaf.value] < my[indexMy.leaf1ndex.value]:
+                    gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.indexLeaf.value]
+                    my[indexMy.gap1ndexCeiling.value] += 1
+                    my[indexMy.indexLeaf.value] += 1
+            my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
+            while my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]:
+                gapsWhere[my[indexMy.gap1ndex.value]] = gapsWhere[my[indexMy.indexMiniGap.value]]
+                if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == my[indexMy.dimensionsUnconstrained.value]:
+                    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:
+            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]]]
+            track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
+            track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
+            track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value]] = my[indexMy.gap1ndex.value]
+            my[indexMy.leaf1ndex.value] += 1
+        if my[indexMy.gap1ndex.value] > 0:
+            return

mapfolding-0.3.5/mapFolding/syntheticModules/countParallel.py

@@ -0,0 +1,54 @@
+from numpy import integer
+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
+        gapsWhere = gapsWherePARALLEL.copy()
+        my = myPARALLEL.copy()
+        my[indexMy.taskIndex.value] = indexSherpa
+        track = trackPARALLEL.copy()
+        while my[indexMy.leaf1ndex.value] > 0:
+            if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
+                if my[indexMy.leaf1ndex.value] > foldGroups[-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]
+                    my[indexMy.indexDimension.value] = 0
+                    while my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]:
+                        if connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]:
+                            my[indexMy.dimensionsUnconstrained.value] -= 1
+                        else:
+                            my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
+                            while my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]:
+                                if my[indexMy.leaf1ndex.value] != my[indexMy.taskDivisions.value] or my[indexMy.leafConnectee.value] % my[indexMy.taskDivisions.value] == my[indexMy.taskIndex.value]:
+                                    gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.leafConnectee.value]
+                                    if track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] == 0:
+                                        my[indexMy.gap1ndexCeiling.value] += 1
+                                    track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
+                                my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
+                        my[indexMy.indexDimension.value] += 1
+                    my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
+                    while my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]:
+                        gapsWhere[my[indexMy.gap1ndex.value]] = gapsWhere[my[indexMy.indexMiniGap.value]]
+                        if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == my[indexMy.dimensionsUnconstrained.value]:
+                            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]:
+                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:
+                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]]]
+                track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
+                track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
+                track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value]] = my[indexMy.gap1ndex.value]
+                my[indexMy.leaf1ndex.value] += 1
+        foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds

{mapfolding-0.3.3 → mapfolding-0.3.5}/mapFolding/syntheticModules/countSequential.py

@@ -1,25 +1,28 @@
-from mapFolding import indexMy, indexTrack
+from numpy import integer
+from typing import Any, Tuple
 import numba
-@numba.jit((numba.uint8[:,:,::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:,::1]), parallel=False, boundscheck=False, cache=True, error_model="numpy", fastmath=True, looplift=False, nogil=True, nopython=True)
-def countSequential(connectionGraph, foldGroups, gapsWhere, my, track):
-    doFindGaps = True
-    dimensionsTotal = my[indexMy.dimensionsTotal.value]
+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]
+    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
+    doFindGaps = True
     while leaf1ndex > 0:
         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]

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

@@ -15,8 +15,7 @@ classifiers = [
     "Operating System :: OS Independent",
     "Programming Language :: Python",
     "Topic :: Scientific/Engineering :: Mathematics",
-    "Typing :: Typed",
-]
+    "Typing :: Typed",]
 dependencies = ["numba", "numpy", "Z0Z_tools"]
 description = "Count distinct ways to fold a map (or a strip of stamps)"
 keywords = [
@@ -28,8 +27,7 @@ keywords = [
     "folding",
     "map folding",
     "OEIS",
-    "stamp folding",
-]
+    "stamp folding",]
 license = { text = "CC-BY-NC-4.0" }
 name = "mapFolding"
 optional-dependencies = { benchmark = [
@@ -38,18 +36,19 @@ optional-dependencies = { benchmark = [
     "pandas",
     "tqdm",
 ], testing = [
+    "cffconvert",
     "more_itertools",
     "pytest",
     "pytest-cov",
     "pytest-env",
     "pytest-xdist",
     "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.3"
+version = "0.3.5"
 
 [tool.coverage]
 report = { exclude_lines = [
@@ -65,8 +64,7 @@ run = { branch = true, concurrency = [
     "mapFolding/someAssemblyRequired/*",
     "Z0Z_*",
 ], parallel = true, source = [
-    "mapFolding",
-] }
+    "mapFolding",] }
 xml = { output = "tests/coverage/coverage.xml" }
 
 [tool.pytest.ini_options]

{mapfolding-0.3.3 → mapfolding-0.3.5}/tests/test_oeis.py

@@ -12,31 +12,31 @@ import re as regex
 import unittest
 import unittest.mock
 import urllib
-import urllib.error
+from urllib.error import URLError
 import urllib.request
 
 def test_algorithmSourceSequential(oeisID: str, useAlgorithmDirectly):
     for n in settingsOEIS[oeisID]['valuesTestValidation']:
-        standardComparison(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
+        standardizedEqualTo(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
 
 def test_aOFn_calculate_value(oeisID: str):
     for n in settingsOEIS[oeisID]['valuesTestValidation']:
-        standardComparison(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
+        standardizedEqualTo(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
 
 @pytest.mark.parametrize("badID", ["A999999", "  A999999  ", "A999999extra"])
 def test__validateOEISid_invalid_id(badID: str):
-    standardComparison(KeyError, _validateOEISid, badID)
+    standardizedEqualTo(KeyError, _validateOEISid, badID)
 
 def test__validateOEISid_partially_valid(oeisID_1random: str):
-    standardComparison(KeyError, _validateOEISid, f"{oeisID_1random}extra")
+    standardizedEqualTo(KeyError, _validateOEISid, f"{oeisID_1random}extra")
 
 def test__validateOEISid_valid_id(oeisID: str):
-    standardComparison(oeisID, _validateOEISid, oeisID)
+    standardizedEqualTo(oeisID, _validateOEISid, oeisID)
 
 def test__validateOEISid_valid_id_case_insensitive(oeisID: str):
-    standardComparison(oeisID.upper(), _validateOEISid, oeisID.lower())
-    standardComparison(oeisID.upper(), _validateOEISid, oeisID.upper())
-    standardComparison(oeisID.upper(), _validateOEISid, oeisID.swapcase())
+    standardizedEqualTo(oeisID.upper(), _validateOEISid, oeisID.lower())
+    standardizedEqualTo(oeisID.upper(), _validateOEISid, oeisID.upper())
+    standardizedEqualTo(oeisID.upper(), _validateOEISid, oeisID.swapcase())
 
 parameters_test_aOFn_invalid_n = [
     # (2, "ok"), # test the test template
@@ -48,10 +48,10 @@ badValues, badValuesIDs = zip(*parameters_test_aOFn_invalid_n)
 @pytest.mark.parametrize("badN", badValues, ids=badValuesIDs)
 def test_aOFn_invalid_n(oeisID_1random: str, badN):
     """Check that negative or non-integer n raises ValueError."""
-    standardComparison(ValueError, oeisIDfor_n, oeisID_1random, badN)
+    standardizedEqualTo(ValueError, oeisIDfor_n, oeisID_1random, badN)
 
 def test_aOFn_zeroDim_A001418():
-    standardComparison(ArithmeticError, oeisIDfor_n, 'A001418', 0)
+    standardizedEqualTo(ArithmeticError, oeisIDfor_n, 'A001418', 0)
 
 # ===== OEIS Cache Tests =====
 @pytest.mark.parametrize("cacheExists", [True, False])
@@ -82,11 +82,11 @@ def testCacheScenarios(pathCacheTesting: pathlib.Path, oeisID_1random: str, scen
         pathCache.write_text("Invalid content")
 
     if scenarioCache == "miss":
-        standardCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], None, oeisID_1random, pathCacheTesting)
+        prototypeCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], None, oeisID_1random, pathCacheTesting)
     elif scenarioCache == "expired":
-        standardCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], setupCacheExpired, oeisID_1random, pathCacheTesting)
+        prototypeCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], setupCacheExpired, oeisID_1random, pathCacheTesting)
     else:
-        standardCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], setupCacheInvalid, oeisID_1random, pathCacheTesting)
+        prototypeCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], setupCacheInvalid, oeisID_1random, pathCacheTesting)
 
 def testInvalidFileContent(pathCacheTesting: pathlib.Path, oeisID_1random: str):
     pathFilenameCache = pathCacheTesting / _getFilenameOEISbFile(oeisID=oeisID_1random)
@@ -107,7 +107,7 @@ def testInvalidFileContent(pathCacheTesting: pathlib.Path, oeisID_1random: str):
 
 def testParseContentErrors():
     """Test invalid content parsing."""
-    standardComparison(ValueError, _parseBFileOEIS, "Invalid content\n1 2\n", 'A001415')
+    standardizedEqualTo(ValueError, _parseBFileOEIS, "Invalid content\n1 2\n", 'A001415')
 
 def testExtraComments(pathCacheTesting: pathlib.Path, oeisID_1random: str):
     pathFilenameCache = pathCacheTesting / _getFilenameOEISbFile(oeisID=oeisID_1random)
@@ -126,17 +126,17 @@ def testExtraComments(pathCacheTesting: pathlib.Path, oeisID_1random: str):
 
     OEISsequence = _getOEISidValues(oeisID_1random)
     # Verify sequence values are correct despite extra comments
-    standardComparison(2, lambda d: d[1], OEISsequence)  # First value
-    standardComparison(8, lambda d: d[4], OEISsequence)  # Value after mid-sequence comment
-    standardComparison(10, lambda d: d[5], OEISsequence)  # Last value
+    standardizedEqualTo(2, lambda d: d[1], OEISsequence)  # First value
+    standardizedEqualTo(8, lambda d: d[4], OEISsequence)  # Value after mid-sequence comment
+    standardizedEqualTo(10, lambda d: d[5], OEISsequence)  # Last value
 
 def testNetworkError(monkeypatch: pytest.MonkeyPatch, pathCacheTesting: pathlib.Path):
     """Test network error handling."""
     def mockUrlopen(*args, **kwargs):
-        raise urllib.error.URLError("Network error")
+        raise URLError("Network error")
 
     monkeypatch.setattr(urllib.request, 'urlopen', mockUrlopen)
-    standardComparison(urllib.error.URLError, _getOEISidValues, next(iter(settingsOEIS)))
+    standardizedEqualTo(URLError, _getOEISidValues, next(iter(settingsOEIS)))
 
 # ===== Command Line Interface Tests =====
 def testHelpText():
@@ -172,7 +172,7 @@ def testHelpText():
         outputStream = io.StringIO()
         with redirect_stdout(outputStream):
             OEIS_for_n()
-        standardComparison(expectedValue, lambda: int(outputStream.getvalue().strip().split()[0]))
+        standardizedEqualTo(expectedValue, lambda: int(outputStream.getvalue().strip().split()[0]))
 
 def testCLI_InvalidInputs():
     """Test CLI error handling."""
@@ -185,14 +185,14 @@ def testCLI_InvalidInputs():
 
     for arguments, testID in testCases:
         with unittest.mock.patch('sys.argv', arguments):
-            expectSystemExit("error", OEIS_for_n)
+            standardizedSystemExit("error", OEIS_for_n)
 
 def testCLI_HelpFlag():
     """Verify --help output contains required information."""
     with unittest.mock.patch('sys.argv', ['OEIS_for_n', '--help']):
         outputStream = io.StringIO()
         with redirect_stdout(outputStream):
-            expectSystemExit("nonError", OEIS_for_n)
+            standardizedSystemExit("nonError", OEIS_for_n)
 
         helpOutput = outputStream.getvalue()
         assert "Available OEIS sequences:" in helpOutput

{mapfolding-0.3.3 → mapfolding-0.3.5}/tests/test_other.py

@@ -10,7 +10,6 @@ import pathlib
 import pytest
 import random
 import sys
-import unittest.mock
 
 @pytest.mark.parametrize("listDimensions,expected_intInnit,expected_parseListDimensions,expected_validateListDimensions,expected_getLeavesTotal", [
     (None, ValueError, ValueError, ValueError, ValueError),  # None instead of list
@@ -47,20 +46,20 @@ import unittest.mock
 ])
 def test_listDimensionsAsParameter(listDimensions: None | list[str] | list[int] | list[float] | list[None] | list[bool] | list[list[int]] | list[complex] | range | tuple[int, ...], expected_intInnit: type[ValueError] | list[int] | type[TypeError], expected_parseListDimensions: type[ValueError] | list[int] | type[TypeError], expected_validateListDimensions: type[ValueError] | type[NotImplementedError] | list[int] | type[TypeError], expected_getLeavesTotal: type[ValueError] | int | type[TypeError] | type[OverflowError]) -> None:
     """Test both validateListDimensions and getLeavesTotal with the same inputs."""
-    standardComparison(expected_intInnit, intInnit, listDimensions)
-    standardComparison(expected_parseListDimensions, parseDimensions, listDimensions)
-    standardComparison(expected_validateListDimensions, validateListDimensions, listDimensions)
-    standardComparison(expected_getLeavesTotal, getLeavesTotal, listDimensions)
+    standardizedEqualTo(expected_intInnit, intInnit, listDimensions)
+    standardizedEqualTo(expected_parseListDimensions, parseDimensions, listDimensions)
+    standardizedEqualTo(expected_validateListDimensions, validateListDimensions, listDimensions)
+    standardizedEqualTo(expected_getLeavesTotal, getLeavesTotal, listDimensions)
 
 def test_getLeavesTotal_edge_cases() -> None:
     """Test edge cases for getLeavesTotal."""
     # Order independence
-    standardComparison(getLeavesTotal([2, 3, 4]), getLeavesTotal, [4, 2, 3])
+    standardizedEqualTo(getLeavesTotal([2, 3, 4]), getLeavesTotal, [4, 2, 3])
 
     # Immutability
     listOriginal = [2, 3]
-    standardComparison(6, getLeavesTotal, listOriginal)
-    standardComparison([2, 3], lambda x: x, listOriginal)  # Check that the list wasn't modified
+    standardizedEqualTo(6, getLeavesTotal, listOriginal)
+    standardizedEqualTo([2, 3], lambda x: x, listOriginal)  # Check that the list wasn't modified
 
 @pytest.mark.parametrize("foldsValue,writeFoldsTarget", [
     (756839, "foldsTotalTest.txt"),  # Direct file
@@ -71,6 +70,7 @@ def test_countFolds_writeFoldsTotal(
     listDimensionsTestFunctionality: List[int],
     pathTempTesting: pathlib.Path,
     mockFoldingFunction,
+    mockDispatcher,
     foldsValue: int,
     writeFoldsTarget: Optional[str]
 ) -> None:
@@ -86,12 +86,10 @@ def test_countFolds_writeFoldsTotal(
     foldsTotalExpected = foldsValue * getLeavesTotal(listDimensionsTestFunctionality)
     mock_countFolds = mockFoldingFunction(foldsValue, listDimensionsTestFunctionality)
 
-    # TODO move this to conftest. I shouldn't have such a specific value buried in a test: SSOT
-    with unittest.mock.patch("mapFolding.dispatcher._countFolds", side_effect=mock_countFolds):
-        returned = countFolds(listDimensionsTestFunctionality, pathishWriteFoldsTotal=pathWriteTarget)
+    with mockDispatcher(mock_countFolds):
+        returned = countFolds(listDimensionsTestFunctionality, pathLikeWriteFoldsTotal=pathWriteTarget)
 
-    # standardComparison(foldsValue, lambda: returned)  # Check return value
-    standardComparison(str(foldsTotalExpected), lambda: (pathTempTesting / filenameFoldsTotalExpected).read_text())  # Check file content
+    standardizedEqualTo(str(foldsTotalExpected), lambda: (pathTempTesting / filenameFoldsTotalExpected).read_text())
 
 @pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_intInnit())
 def testIntInnit(nameOfTest, callablePytest):
@@ -113,7 +111,7 @@ def testOopsieKwargsie(nameOfTest, callablePytest):
     (1, 1),
 ])
 def test_setCPUlimit(CPUlimit, expectedLimit) -> None:
-    standardComparison(expectedLimit, setCPUlimit, CPUlimit)
+    standardizedEqualTo(expectedLimit, setCPUlimit, CPUlimit)
 
 def test_makeConnectionGraph_nonNegative(listDimensionsTestFunctionality: List[int]) -> None:
     connectionGraph = makeConnectionGraph(listDimensionsTestFunctionality)
@@ -124,7 +122,6 @@ def test_makeConnectionGraph_datatype(listDimensionsTestFunctionality: List[int]
     connectionGraph = makeConnectionGraph(listDimensionsTestFunctionality, datatype=datatype)
     assert connectionGraph.dtype == datatype, f"Expected datatype {datatype}, but got {connectionGraph.dtype}."
 
-
 """5 parameters
 listDimensionsTestFunctionality
 
@@ -271,7 +268,7 @@ def test_pathJobDEFAULT_colab():
 
 def test_saveFoldsTotal_fallback(pathTempTesting: pathlib.Path) -> None:
     foldsTotal = 123
-    pathFilename = pathTempTesting / "unwritable" / "foldsTotal.txt"
+    pathFilename = pathTempTesting / "foldsTotal.txt"
     with unittest.mock.patch("pathlib.Path.write_text", side_effect=OSError("Simulated write failure")):
         with unittest.mock.patch("os.getcwd", return_value=str(pathTempTesting)):
             capturedOutput = io.StringIO()
@@ -279,3 +276,10 @@ def test_saveFoldsTotal_fallback(pathTempTesting: pathlib.Path) -> None:
                 saveFoldsTotal(pathFilename, foldsTotal)
     fallbackFiles = list(pathTempTesting.glob("foldsTotalYO_*.txt"))
     assert len(fallbackFiles) == 1, "Fallback file was not created upon write failure."
+
+def test_makeDataContainer_default_datatype():
+    """Test that makeDataContainer uses dtypeLargeDEFAULT when no datatype is specified."""
+    testShape = (3, 4)
+    container = makeDataContainer(testShape)
+    assert container.dtype == dtypeLargeDEFAULT, f"Expected datatype {dtypeLargeDEFAULT}, but got {container.dtype}"
+    assert container.shape == testShape, f"Expected shape {testShape}, but got {container.shape}"

{mapfolding-0.3.3 → mapfolding-0.3.5}/tests/test_tasks.py

@@ -1,18 +1,18 @@
 from tests.conftest import *
 import pytest
-from typing import List, Dict, Tuple
+from typing import List, Dict, Tuple, Any
 
 # TODO add a test. `C` = number of logical cores available. `n = C + 1`. Ensure that `[2,n]` is computed correctly.
 # Or, probably smarter: limit the number of cores, then run a test with C+1.
 
 def test_algorithmSourceParallel(listDimensionsTestParallelization: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int], useAlgorithmDirectly) -> None:
-    standardComparison(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
+    standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
 
 def test_countFoldsComputationDivisionsInvalid(listDimensionsTestFunctionality: List[int]) -> None:
-    standardComparison(ValueError, countFolds, listDimensionsTestFunctionality, None, {"wrong": "value"})
+    standardizedEqualTo(ValueError, countFolds, listDimensionsTestFunctionality, None, {"wrong": "value"})
 
 def test_countFoldsComputationDivisionsMaximum(listDimensionsTestParallelization: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]) -> None:
-    standardComparison(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
+    standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
 
 @pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_defineConcurrencyLimit())
 def test_defineConcurrencyLimit(nameOfTest, callablePytest):
@@ -20,7 +20,7 @@ def test_defineConcurrencyLimit(nameOfTest, callablePytest):
 
 # @pytest.mark.parametrize("CPUlimitParameter", [{"invalid": True}, ["weird"]])
 # def test_countFolds_cpuLimitOopsie(listDimensionsTestFunctionality: List[int], CPUlimitParameter: Dict[str, bool] | List[str]) -> None:
-#     standardComparison((AttributeError or ValueError), countFolds, listDimensionsTestFunctionality, None, 'cpu', CPUlimitParameter)
+#     standardizedEqualTo((AttributeError or ValueError), countFolds, listDimensionsTestFunctionality, None, 'cpu', CPUlimitParameter)
 
 @pytest.mark.parametrize("computationDivisions, concurrencyLimit, listDimensions, expectedTaskDivisions", [
     (None, 4, [9, 11], 0),
@@ -30,4 +30,15 @@ def test_defineConcurrencyLimit(nameOfTest, callablePytest):
     (20, 4, [3,5], ValueError)
 ])
 def test_getTaskDivisions(computationDivisions, concurrencyLimit, listDimensions, expectedTaskDivisions) -> None:
-    standardComparison(expectedTaskDivisions, getTaskDivisions, computationDivisions, concurrencyLimit, None, listDimensions)
+    standardizedEqualTo(expectedTaskDivisions, getTaskDivisions, computationDivisions, concurrencyLimit, None, listDimensions)
+
+@pytest.mark.parametrize("expected,parameter", [
+    (2, "2"),  # string
+    (ValueError, [4]),  # list
+    (ValueError, (2,)), # tuple
+    (ValueError, {2}),  # set
+    (ValueError, {"cores": 2}),  # dict
+])
+def test_setCPUlimitMalformedParameter(expected, parameter) -> None:
+    """Test that invalid CPUlimit types are properly handled."""
+    standardizedEqualTo(expected, setCPUlimit, parameter)

mapfolding-0.3.3/mapFolding/someAssemblyRequired/__init__.py

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

mapfolding-0.3.3/mapFolding/someAssemblyRequired/synthesizeModules.py

@@ -1,78 +0,0 @@
-from mapFolding import indexMy, indexTrack, getAlgorithmSource
-from mapFolding import datatypeLargeDEFAULT, datatypeMediumDEFAULT, datatypeSmallDEFAULT
-from someAssemblyRequired import makeInlineFunction
-import pathlib
-import inspect
-
-algorithmSource = getAlgorithmSource()
-
-def getDictionaryEnumValues():
-    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, callableTarget: 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
-
-def inlineMapFoldingNumba(**keywordArguments):
-    datatypeLarge = keywordArguments.get('datatypeLarge', datatypeLargeDEFAULT)
-    datatypeMedium = keywordArguments.get('datatypeMedium', datatypeMediumDEFAULT)
-    datatypeSmall = keywordArguments.get('datatypeSmall', datatypeSmallDEFAULT)
-    dictionaryEnumValues = getDictionaryEnumValues()
-    codeSource = inspect.getsource(algorithmSource)
-    pathFilenameAlgorithm = pathlib.Path(inspect.getfile(algorithmSource))
-
-    listCallables = [ 'countInitialize', 'countParallel', 'countSequential', ]
-
-    listPathFilenamesDestination: list[pathlib.Path] = []
-    for callableTarget in listCallables:
-        skipEnum = (callableTarget == 'countInitialize')
-        skipEnum = (callableTarget == 'countSequential')
-        pathFilenameDestination = pathFilenameAlgorithm.parent / "syntheticModules" / pathFilenameAlgorithm.with_stem(callableTarget).name
-        codeInlined, callableInlinedDecorators, importsRequired = makeInlineFunction(codeSource, callableTarget, dictionaryEnumValues, skipEnum, datatypeLarge=datatypeLarge, datatypeMedium=datatypeMedium, datatypeSmall=datatypeSmall)
-        codeUnpacked = unpackArrays(codeInlined, callableTarget)
-        pathFilenameDestination.write_text(importsRequired + "\n" + codeUnpacked)
-        listPathFilenamesDestination.append(pathFilenameDestination)
-
-if __name__ == '__main__':
-    inlineMapFoldingNumba()

mapfolding-0.3.3/mapFolding/syntheticModules/countInitialize.py

@@ -1,44 +0,0 @@
-from mapFolding import indexMy, indexTrack
-import numba
-@numba.jit((numba.uint8[:,:,::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:,::1]), parallel=False, boundscheck=False, cache=True, error_model="numpy", fastmath=True, looplift=False, nogil=True, nopython=True)
-def countInitialize(connectionGraph, gapsWhere, my, track):
-    while my[7] > 0:
-        if my[7] <= 1 or track[1, 0] == 1:
-            my[1] = my[0]
-            my[3] = track[3, my[7] - 1]
-            my[4] = 0
-            while my[4] < my[0]:
-                if connectionGraph[my[4], my[7], my[7]] == my[7]:
-                    my[1] -= 1
-                else:
-                    my[8] = connectionGraph[my[4], my[7], my[7]]
-                    while my[8] != my[7]:
-                        gapsWhere[my[3]] = my[8]
-                        if track[2, my[8]] == 0:
-                            my[3] += 1
-                        track[2, my[8]] += 1
-                        my[8] = connectionGraph[my[4], my[7], track[1, my[8]]]
-                my[4] += 1
-            if not my[1]:
-                my[5] = 0
-                while my[5] < my[7]:
-                    gapsWhere[my[3]] = my[5]
-                    my[3] += 1
-                    my[5] += 1
-            my[6] = my[2]
-            while my[6] < my[3]:
-                gapsWhere[my[2]] = gapsWhere[my[6]]
-                if track[2, gapsWhere[my[6]]] == my[1]:
-                    my[2] += 1
-                track[2, gapsWhere[my[6]]] = 0
-                my[6] += 1
-        if my[7] > 0:
-            my[2] -= 1
-            track[0, my[7]] = gapsWhere[my[2]]
-            track[1, my[7]] = track[1, track[0, my[7]]]
-            track[1, track[0, my[7]]] = my[7]
-            track[0, track[1, my[7]]] = my[7]
-            track[3, my[7]] = my[2]
-            my[7] += 1
-        if my[2] > 0:
-            return

mapfolding-0.3.3/mapFolding/syntheticModules/countParallel.py

@@ -1,51 +0,0 @@
-from mapFolding import indexMy, indexTrack
-import numba
-@numba.jit((numba.uint8[:,:,::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:,::1]), parallel=True, boundscheck=False, cache=True, error_model="numpy", fastmath=True, looplift=False, nogil=True, nopython=True)
-def countParallel(connectionGraph, foldGroups, gapsWherePARALLEL, myPARALLEL, trackPARALLEL):
-    for indexSherpa in numba.prange(myPARALLEL[9]):
-        gapsWhere = gapsWherePARALLEL.copy()
-        my = myPARALLEL.copy()
-        my[10] = indexSherpa
-        track = trackPARALLEL.copy()
-        groupsOfFolds: int = 0
-        while my[7] > 0:
-            if my[7] <= 1 or track[1, 0] == 1:
-                if my[7] > foldGroups[-1]:
-                    groupsOfFolds = groupsOfFolds + 1
-                else:
-                    my[1] = my[0]
-                    my[3] = track[3, my[7] - 1]
-                    my[4] = 0
-                    while my[4] < my[0]:
-                        if connectionGraph[my[4], my[7], my[7]] == my[7]:
-                            my[1] -= 1
-                        else:
-                            my[8] = connectionGraph[my[4], my[7], my[7]]
-                            while my[8] != my[7]:
-                                if my[7] != my[9] or my[8] % my[9] == my[10]:
-                                    gapsWhere[my[3]] = my[8]
-                                    if track[2, my[8]] == 0:
-                                        my[3] += 1
-                                    track[2, my[8]] += 1
-                                my[8] = connectionGraph[my[4], my[7], track[1, my[8]]]
-                        my[4] += 1
-                    my[6] = my[2]
-                    while my[6] < my[3]:
-                        gapsWhere[my[2]] = gapsWhere[my[6]]
-                        if track[2, gapsWhere[my[6]]] == my[1]:
-                            my[2] += 1
-                        track[2, gapsWhere[my[6]]] = 0
-                        my[6] += 1
-            while my[7] > 0 and my[2] == track[3, my[7] - 1]:
-                my[7] -= 1
-                track[1, track[0, my[7]]] = track[1, my[7]]
-                track[0, track[1, my[7]]] = track[0, my[7]]
-            if my[7] > 0:
-                my[2] -= 1
-                track[0, my[7]] = gapsWhere[my[2]]
-                track[1, my[7]] = track[1, track[0, my[7]]]
-                track[1, track[0, my[7]]] = my[7]
-                track[0, track[1, my[7]]] = my[7]
-                track[3, my[7]] = my[2]
-                my[7] += 1
-        foldGroups[my[10]] = groupsOfFolds