mapFolding 0.3.11__tar.gz → 0.3.12__tar.gz

{mapfolding-0.3.11 → mapfolding-0.3.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.3.11
+Version: 0.3.12
 Summary: Count distinct ways to fold a map (or a strip of stamps)
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0

{mapfolding-0.3.11 → mapfolding-0.3.12}/mapFolding/__init__.py

@@ -26,6 +26,11 @@ from mapFolding.theSSOT import (
     getPathJobRootDEFAULT,
     getPathSyntheticModules,
     moduleOfSyntheticModules,
+    Z0Z_getDatatypeModuleScalar,
+    Z0Z_getDecoratorCallable,
+    Z0Z_setDatatypeModuleScalar,
+    Z0Z_setDecoratorCallable,
+    Z0Z_identifierCountFolds,
 )
 
 # Parameters for the prima donna
@@ -38,6 +43,11 @@ from mapFolding.theSSOT import (
     parametersNumbaSuperJitParallel,
 )
 
+# Coping
+from mapFolding.theSSOT import (
+    FREAKOUT,
+)
+
 from mapFolding.beDRY import (
     getFilenameFoldsTotal,
     getPathFilenameFoldsTotal,

{mapfolding-0.3.11 → mapfolding-0.3.12}/mapFolding/someAssemblyRequired/synthesizeNumba.py

@@ -1,6 +1,9 @@
+"""I think this module is free of hardcoded values.
+TODO: consolidate the logic in this module."""
 from mapFolding import (
     computationState,
     EnumIndices,
+    FREAKOUT,
     getAlgorithmSource,
     getFilenameFoldsTotal,
     getPathFilenameFoldsTotal,
@@ -20,15 +23,19 @@ from mapFolding import (
     setDatatypeFoldsTotal,
     setDatatypeLeavesTotal,
     setDatatypeModule,
+    Z0Z_getDatatypeModuleScalar,
+    Z0Z_getDecoratorCallable,
+    Z0Z_identifierCountFolds,
+    Z0Z_setDatatypeModuleScalar,
+    Z0Z_setDecoratorCallable,
 )
-from collections import namedtuple
 from mapFolding.someAssemblyRequired import makeStateJob
 from types import ModuleType
-from typing import Any, Callable, Dict, List, Optional, Sequence, Set, Tuple, Type, Union, cast
+from typing import Any, Callable, cast, Dict, List, Optional, Sequence, Set, Tuple, Type, Union
 import ast
+import autoflake
 import collections
 import inspect
-import autoflake
 import more_itertools
 import numba
 import numpy
@@ -36,7 +43,7 @@ import os
 import pathlib
 import python_minifier
 
-youOughtaKnow = namedtuple('youOughtaKnow', ['callableSynthesized', 'pathFilenameForMe', 'astForCompetentProgrammers'])
+youOughtaKnow = collections.namedtuple('youOughtaKnow', ['callableSynthesized', 'pathFilenameForMe', 'astForCompetentProgrammers'])
 
 class UniversalImportTracker:
     def __init__(self):
@@ -60,9 +67,10 @@ class UniversalImportTracker:
         listAstImportFrom = [ast.ImportFrom(module=module, names=[ast.alias(name=name, asname=None)], level=0) for module, names in self.dictionaryImportFrom.items() for name in names]
         listAstImport = [ast.Import(names=[ast.alias(name=name, asname=None)]) for name in self.setImport]
         return listAstImportFrom + listAstImport
+
 class NodeReplacer(ast.NodeTransformer):
-    """Base class for configurable node replacement"""
-    def __init__(self, findMe, nodeReplacementBuilder):
+    """Generic node replacement using configurable predicate and builder."""
+    def __init__(self, findMe: Callable[[ast.AST], bool], nodeReplacementBuilder: Callable[[ast.AST], ast.AST]):
         self.findMe = findMe
         self.nodeReplacementBuilder = nodeReplacementBuilder
 
@@ -71,26 +79,6 @@ class NodeReplacer(ast.NodeTransformer):
             return self.nodeReplacementBuilder(node)
         return super().visit(node)
 
-class ArgumentProcessor:
-    """Unified argument processing using transformation rules"""
-    def __init__(self, rules: List[Tuple[Callable[[ast.arg], bool], Callable]]):
-        self.rules = rules  # (predicate, transformation)
-
-    def process(self, FunctionDef: ast.FunctionDef) -> ast.FunctionDef:
-        for arg in FunctionDef.args.args.copy():
-            for predicate, transform in self.rules:
-                if predicate(arg):
-                    FunctionDef = transform(FunctionDef, arg)
-        return FunctionDef
-
-def Z0Z_UnhandledDecorators(astCallable: ast.FunctionDef) -> ast.FunctionDef:
-    # TODO: more explicit handling of decorators. I'm able to ignore this because I know `algorithmSource` doesn't have any decorators.
-    for decoratorItem in astCallable.decorator_list.copy():
-        import warnings
-        astCallable.decorator_list.remove(decoratorItem)
-        warnings.warn(f"Removed decorator {ast.unparse(decoratorItem)} from {astCallable.name}")
-    return astCallable
-
 class RecursiveInliner(ast.NodeTransformer):
     """
     Class RecursiveInliner:
@@ -152,7 +140,7 @@ class RecursiveInliner(ast.NodeTransformer):
                     return [self.visit(stmt) for stmt in inlineDefinition.body]
         return self.generic_visit(node)
 
-class UnpackArrayAccesses(ast.NodeTransformer):
+class UnpackArrays(ast.NodeTransformer):
     """
     A class that transforms array accesses using enum indices into local variables.
 
@@ -259,8 +247,42 @@ class UnpackArrayAccesses(ast.NodeTransformer):
         node.body = initializations + node.body
         return node
 
-def decorateCallableWithNumba(FunctionDefTarget: ast.FunctionDef, parametersNumba: Optional[ParametersNumba]=None) -> ast.FunctionDef:
-    def makeNumbaParameterSignatureElement(signatureElement: ast.arg):
+def Z0Z_UnhandledDecorators(astCallable: ast.FunctionDef) -> ast.FunctionDef:
+    # TODO: more explicit handling of decorators. I'm able to ignore this because I know `algorithmSource` doesn't have any decorators.
+    for decoratorItem in astCallable.decorator_list.copy():
+        import warnings
+        astCallable.decorator_list.remove(decoratorItem)
+        warnings.warn(f"Removed decorator {ast.unparse(decoratorItem)} from {astCallable.name}")
+    return astCallable
+def isThisNodeNumbaJitCall(node: ast.AST) -> bool:
+    return (isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute) and node.func.attr == Z0Z_getDecoratorCallable())
+def isThisNodeJitCall(node: ast.AST) -> bool:
+    return (isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and node.func.id == Z0Z_getDecoratorCallable())
+def isThisNodeNumbaJitDecorator(node: ast.AST) -> bool:
+    return isThisNodeNumbaJitCall(node) or isThisNodeJitCall(node)
+def Z0Z_generalizeThis(FunctionDefTarget: ast.FunctionDef, parametersNumba: Optional[ParametersNumba]=None) -> Tuple[ast.FunctionDef, ParametersNumba | None]:
+    def recycleParametersNumba(decorator: ast.Call) -> Dict[str, Any]:
+        parametersNumbaExtracted: Dict[str, Any] = {}
+        for keywordItem in decorator.keywords:
+            if isinstance(keywordItem.value, ast.Constant) and keywordItem.arg is not None:
+                parametersNumbaExtracted[keywordItem.arg] = keywordItem.value.value
+        return parametersNumbaExtracted
+
+    for decorator in FunctionDefTarget.decorator_list.copy():
+        if isThisNodeNumbaJitDecorator(decorator):
+            decorator = cast(ast.Call, decorator)
+            if parametersNumba is None:
+                parametersNumbaSherpa = recycleParametersNumba(decorator)
+                if (HunterIsSureThereAreBetterWaysToDoThis := True):
+                    if parametersNumbaSherpa:
+                        parametersNumba = cast(ParametersNumba, parametersNumbaSherpa)
+        FunctionDefTarget.decorator_list.remove(decorator)
+
+    return FunctionDefTarget, parametersNumba
+
+def decorateCallableWithNumba(FunctionDefTarget: ast.FunctionDef, allImports: UniversalImportTracker, parametersNumba: Optional[ParametersNumba]=None) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+    datatypeModuleDecorator = Z0Z_getDatatypeModuleScalar()
+    def make_arg4parameter(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):
@@ -284,45 +306,55 @@ def decorateCallableWithNumba(FunctionDefTarget: ast.FunctionDef, parametersNumb
 
             return ast.Subscript(value=datatypeNumba, slice=shapeAST, ctx=ast.Load())
 
-    FunctionDefTarget = Z0Z_UnhandledDecorators(FunctionDefTarget)
+    list_argsDecorator: Sequence[ast.expr] = []
 
-    listNumbaParameterSignature: Sequence[ast.expr] = []
+    list_arg4signature_or_function: Sequence[ast.expr] = []
     for parameter in FunctionDefTarget.args.args:
-        signatureElement = makeNumbaParameterSignatureElement(parameter)
-        if (signatureElement):
-            listNumbaParameterSignature.append(signatureElement)
-
-    astTupleSignatureParameters = ast.Tuple(elts=listNumbaParameterSignature, ctx=ast.Load())
-
-    # TODO if `astCallable` has a return, the return needs to be added to `astArgsNumbaSignature` in the appropriate place
-    # The return, when placed in the args, is treated as a `Call`. This is logical because numba is converting to machine code.
-    # , args=[Call(func=Name(id='int64', ctx=Load()))]
-    ast_argsSignature = astTupleSignatureParameters
-
-    ImaReturn = next((node for node in FunctionDefTarget.body if isinstance(node, ast.Return)), None)
-    # Return(value=Name(id='groupsOfFolds', ctx=Load()))]
-    if ImaReturn is not None and isinstance(ImaReturn.value, ast.Name):
-        my_idIf_I_wereA_astCall_func_astName_idParameter = ImaReturn.value.id
-        ast_argsSignature = ast.Call(
-                func=ast.Name(id=my_idIf_I_wereA_astCall_func_astName_idParameter, ctx=ast.Load()),
-                args=[astTupleSignatureParameters],
-                keywords=[]
-            )
-    else:
-        ast_argsSignature = astTupleSignatureParameters
-
+        signatureElement = make_arg4parameter(parameter)
+        if signatureElement:
+            list_arg4signature_or_function.append(signatureElement)
+
+    if FunctionDefTarget.returns and isinstance(FunctionDefTarget.returns, ast.Name):
+        theReturn: ast.Name = FunctionDefTarget.returns
+        list_argsDecorator = [cast(ast.expr, ast.Call(func=ast.Name(id=theReturn.id, ctx=ast.Load())
+                            , args=list_arg4signature_or_function if list_arg4signature_or_function else [] , keywords=[] ) )]
+    elif list_arg4signature_or_function:
+        list_argsDecorator = [cast(ast.expr, ast.Tuple(elts=list_arg4signature_or_function, ctx=ast.Load()))]
+
+    FunctionDefTarget, parametersNumba = Z0Z_generalizeThis(FunctionDefTarget, parametersNumba)
+    FunctionDefTarget = Z0Z_UnhandledDecorators(FunctionDefTarget)
     if parametersNumba is None:
         parametersNumba = parametersNumbaDEFAULT
+    listDecoratorKeywords = [ast.keyword(arg=parameterName, value=ast.Constant(value=parameterValue)) for parameterName, parameterValue in parametersNumba.items()]
 
-    listKeywordsNumbaSignature = [ast.keyword(arg=parameterName, value=ast.Constant(value=parameterValue)) for parameterName, parameterValue in parametersNumba.items()]
-    allImports.addImportFromStr(datatypeModuleDecorator, 'jit')
-    astDecoratorNumba = ast.Call(func=ast.Name(id='jit', ctx=ast.Load()), args=[ast_argsSignature], keywords=listKeywordsNumbaSignature)
+    decoratorModule = Z0Z_getDatatypeModuleScalar()
+    decoratorCallable = Z0Z_getDecoratorCallable()
+    allImports.addImportFromStr(decoratorModule, decoratorCallable)
+    astDecorator = ast.Call(
+        func=ast.Name(id=decoratorCallable, ctx=ast.Load())
+        , args=list_argsDecorator if list_argsDecorator else []
+        , keywords=listDecoratorKeywords)
 
-    FunctionDefTarget.decorator_list = [astDecoratorNumba]
-    return FunctionDefTarget
+    FunctionDefTarget.decorator_list = [astDecorator]
+    return FunctionDefTarget, allImports
+
+def makeDecoratorJobNumba(FunctionDefTarget: ast.FunctionDef, allImports: UniversalImportTracker, parametersNumba: Optional[ParametersNumba]=None) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+    decoratorCallable = Z0Z_getDecoratorCallable()
+    def convertToPlainJit(node: ast.Call) -> ast.Call:
+        node.func = ast.Name(id=decoratorCallable, ctx=ast.Load())
+        return node
+
+    FunctionDefTarget, parametersNumba = Z0Z_generalizeThis(FunctionDefTarget, parametersNumba)
+
+    FunctionDefTarget, allImports = decorateCallableWithNumba(FunctionDefTarget, allImports, parametersNumba)
+    if isThisNodeNumbaJitCall(FunctionDefTarget.decorator_list[0]):
+        FunctionDefTarget.decorator_list[0] = convertToPlainJit(cast(ast.Call, FunctionDefTarget.decorator_list[0]))
+
+    return FunctionDefTarget, allImports
 
-def inlineOneCallable(pythonSource: str, callableTarget: str) -> str | None:
+def inlineOneCallable(pythonSource: str, callableTarget: str, parametersNumba: Optional[ParametersNumba]=None, unpackArrays: Optional[bool]=False) -> str:
     astModule: ast.Module = ast.parse(pythonSource, type_comments=True)
+    allImports = UniversalImportTracker()
 
     for statement in astModule.body:
         if isinstance(statement, (ast.Import, ast.ImportFrom)):
@@ -332,35 +364,27 @@ def inlineOneCallable(pythonSource: str, callableTarget: str) -> str | None:
     callableInlinerWorkhorse = RecursiveInliner(dictionaryFunctionDef)
     FunctionDefTarget = callableInlinerWorkhorse.inlineFunctionBody(callableTarget)
 
-    if FunctionDefTarget:
-        ast.fix_missing_locations(FunctionDefTarget)
-        parametersNumba = None
-        match callableTarget:
-            case 'countParallel':
-                parametersNumba = parametersNumbaSuperJitParallel
-            case 'countSequential':
-                parametersNumba = parametersNumbaSuperJit
-            case 'countInitialize':
-                parametersNumba = parametersNumbaDEFAULT
-
-        FunctionDefTarget = decorateCallableWithNumba(FunctionDefTarget, parametersNumba)
-
-        if callableTarget == 'countSequential':
-            unpackerMy = UnpackArrayAccesses(indexMy, 'my')
-            FunctionDefTarget = cast(ast.FunctionDef, unpackerMy.visit(FunctionDefTarget))
-            ast.fix_missing_locations(FunctionDefTarget)
+    if not FunctionDefTarget:
+        raise FREAKOUT
+
+    ast.fix_missing_locations(FunctionDefTarget)
+
+    FunctionDefTarget, allImports = decorateCallableWithNumba(FunctionDefTarget, allImports, parametersNumba)
 
-            unpackerTrack = UnpackArrayAccesses(indexTrack, 'track')
-            FunctionDefTarget = cast(ast.FunctionDef, unpackerTrack.visit(FunctionDefTarget))
+    if unpackArrays:
+        for tupleUnpack in [(indexMy, 'my'), (indexTrack, 'track')]:
+            unpacker = UnpackArrays(*tupleUnpack)
+            FunctionDefTarget = cast(ast.FunctionDef, unpacker.visit(FunctionDefTarget))
             ast.fix_missing_locations(FunctionDefTarget)
 
-        moduleAST = ast.Module(body=cast(List[ast.stmt], allImports.makeListAst() + [FunctionDefTarget]), type_ignores=[])
-        ast.fix_missing_locations(moduleAST)
-        moduleSource = ast.unparse(moduleAST)
-        return moduleSource
+    moduleAST = ast.Module(body=cast(List[ast.stmt], allImports.makeListAst() + [FunctionDefTarget]), type_ignores=[])
+    ast.fix_missing_locations(moduleAST)
+    moduleSource = ast.unparse(moduleAST)
+    return moduleSource
 
 def makeDispatcherNumba(pythonSource: str, callableTarget: str, listStuffYouOughtaKnow: List[youOughtaKnow]) -> str:
     astSource = ast.parse(pythonSource)
+    allImports = UniversalImportTracker()
 
     for statement in astSource.body:
         if isinstance(statement, (ast.Import, ast.ImportFrom)):
@@ -376,98 +400,13 @@ def makeDispatcherNumba(pythonSource: str, callableTarget: str, listStuffYouOugh
     if not FunctionDefTarget:
         raise ValueError(f"Could not find function {callableTarget} in source code")
 
-    # Zero-out the decorator list
-    FunctionDefTarget = Z0Z_UnhandledDecorators(FunctionDefTarget)
-
-    FunctionDefTarget = decorateCallableWithNumba(FunctionDefTarget, parametersNumbaFailEarly)
+    FunctionDefTarget, allImports = decorateCallableWithNumba(FunctionDefTarget, allImports, parametersNumbaFailEarly)
 
-    astModule = ast.Module( body=cast(List[ast.stmt], allImports.makeListAst()
-                + [FunctionDefTarget]), type_ignores=[])
+    astModule = ast.Module(body=cast(List[ast.stmt], allImports.makeListAst() + [FunctionDefTarget]), type_ignores=[])
 
     ast.fix_missing_locations(astModule)
     return ast.unparse(astModule)
 
-def makeNumbaOptimizedFlow(listCallablesInline: List[str], callableDispatcher: Optional[str] = None, algorithmSource: Optional[ModuleType] = None) -> None:
-    if not algorithmSource:
-        algorithmSource = getAlgorithmSource()
-
-    formatModuleNameDEFAULT = "numba_{callableTarget}"
-
-    # When I am a more competent programmer, I will make getPathFilenameWrite dependent on makeAstImport or vice versa,
-    # so the name of the physical file doesn't get out of whack with the name of the logical module.
-    def getPathFilenameWrite(callableTarget: str
-                            , pathWrite: Optional[pathlib.Path] = None
-                            , formatFilenameWrite: Optional[str] = None
-                            ) -> pathlib.Path:
-        if not pathWrite:
-            pathWrite = getPathSyntheticModules()
-        if not formatFilenameWrite:
-            formatFilenameWrite = formatModuleNameDEFAULT + '.py'
-
-        pathFilename = pathWrite  / formatFilenameWrite.format(callableTarget=callableTarget)
-        return pathFilename
-
-    def makeAstImport(callableTarget: str
-                        , packageName: Optional[str] = None
-                        , subPackageName: Optional[str] = None
-                        , moduleName: Optional[str] = None
-                        , astNodeLogicalPathThingy: Optional[ast.AST] = None
-                        ) -> ast.ImportFrom:
-        """Creates import AST node for synthetic modules."""
-        if astNodeLogicalPathThingy is None:
-            if packageName is None:
-                packageName = myPackageNameIs
-            if subPackageName is None:
-                subPackageName = moduleOfSyntheticModules
-            if moduleName is None:
-                moduleName = formatModuleNameDEFAULT.format(callableTarget=callableTarget)
-            module=f'{packageName}.{subPackageName}.{moduleName}'
-        else:
-            module = str(astNodeLogicalPathThingy)
-        return ast.ImportFrom(
-            module=module,
-            names=[ast.alias(name=callableTarget, asname=None)],
-            level=0
-        )
-
-    listStuffYouOughtaKnow: List[youOughtaKnow] = []
-
-    global allImports
-    for callableTarget in listCallablesInline:
-        allImports = UniversalImportTracker()
-        pythonSource = inspect.getsource(algorithmSource)
-        pythonSource = inlineOneCallable(pythonSource, callableTarget)
-        if not pythonSource:
-            raise Exception("Pylance, OMG! The sky is falling!")
-
-        pathFilename = getPathFilenameWrite(callableTarget)
-
-        listStuffYouOughtaKnow.append(youOughtaKnow(
-            callableSynthesized=callableTarget,
-            pathFilenameForMe=pathFilename,
-            astForCompetentProgrammers=makeAstImport(callableTarget)
-        ))
-        pythonSource = autoflake.fix_code(pythonSource, ['mapFolding', 'numba', 'numpy'])
-        pathFilename.write_text(pythonSource)
-
-    # Generate dispatcher if requested
-    if callableDispatcher:
-        allImports = UniversalImportTracker()
-        pythonSource = inspect.getsource(algorithmSource)
-        pythonSource = makeDispatcherNumba(pythonSource, callableDispatcher, listStuffYouOughtaKnow)
-        if not pythonSource:
-            raise Exception("Pylance, OMG! The sky is falling!")
-
-        pathFilename = getPathFilenameWrite(callableDispatcher)
-
-        listStuffYouOughtaKnow.append(youOughtaKnow(
-            callableSynthesized=callableDispatcher,
-            pathFilenameForMe=pathFilename,
-            astForCompetentProgrammers=makeAstImport(callableDispatcher)
-        ))
-        pythonSource = autoflake.fix_code(pythonSource, ['mapFolding', 'numba', 'numpy'])
-        pathFilename.write_text(pythonSource)
-
 def makeStrRLEcompacted(arrayTarget: numpy.ndarray, identifierName: Optional[str]=None) -> str:
     """Converts a NumPy array into a compressed string representation using run-length encoding (RLE).
 
@@ -514,7 +453,7 @@ def makeStrRLEcompacted(arrayTarget: numpy.ndarray, identifierName: Optional[str
         return f"{identifierName} = array({stringMinimized}, dtype={arrayTarget.dtype})"
     return stringMinimized
 
-def moveArrayTo_body(FunctionDefTarget: ast.FunctionDef, astArg: ast.arg, argData: numpy.ndarray) -> ast.FunctionDef:
+def moveArrayTo_body(FunctionDefTarget: ast.FunctionDef, astArg: ast.arg, argData: numpy.ndarray, allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
     arrayType = type(argData)
     moduleConstructor = arrayType.__module__
     constructorName = arrayType.__name__
@@ -539,9 +478,9 @@ def moveArrayTo_body(FunctionDefTarget: ast.FunctionDef, astArg: ast.arg, argDat
     FunctionDefTarget.body.insert(0, assignment)
     FunctionDefTarget.args.args.remove(astArg)
 
-    return FunctionDefTarget
+    return FunctionDefTarget, allImports
 
-def evaluateArrayIn_body(FunctionDefTarget: ast.FunctionDef, astArg: ast.arg, argData: numpy.ndarray) -> ast.FunctionDef:
+def evaluateArrayIn_body(FunctionDefTarget: ast.FunctionDef, astArg: ast.arg, argData: numpy.ndarray, allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
     arrayType = type(argData)
     moduleConstructor = arrayType.__module__
     constructorName = arrayType.__name__
@@ -574,10 +513,10 @@ def evaluateArrayIn_body(FunctionDefTarget: ast.FunctionDef, astArg: ast.arg, ar
                     FunctionDefTarget.body.remove(stmt)
 
     FunctionDefTarget.args.args.remove(astArg)
-    return FunctionDefTarget
+    return FunctionDefTarget, allImports
 
-def evaluate_argIn_body(FunctionDefTarget: ast.FunctionDef, astArg: ast.arg, argData: numpy.ndarray, Z0Z_listChaff: List[str]) -> ast.FunctionDef:
-    moduleConstructor = datatypeModuleScalar
+def evaluate_argIn_body(FunctionDefTarget: ast.FunctionDef, astArg: ast.arg, argData: numpy.ndarray, Z0Z_listChaff: List[str], allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+    moduleConstructor = Z0Z_getDatatypeModuleScalar()
     for stmt in FunctionDefTarget.body.copy():
         if isinstance(stmt, ast.Assign):
             if isinstance(stmt.targets[0], ast.Name) and isinstance(stmt.value, ast.Subscript):
@@ -595,10 +534,10 @@ def evaluate_argIn_body(FunctionDefTarget: ast.FunctionDef, astArg: ast.arg, arg
                         FunctionDefTarget.body.insert(0, assignment)
                     FunctionDefTarget.body.remove(stmt)
     FunctionDefTarget.args.args.remove(astArg)
-    return FunctionDefTarget
+    return FunctionDefTarget, allImports
 
-def evaluateAnnAssignIn_body(FunctionDefTarget: ast.FunctionDef) -> ast.FunctionDef:
-    moduleConstructor = datatypeModuleScalar
+def evaluateAnnAssignIn_body(FunctionDefTarget: ast.FunctionDef, allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+    moduleConstructor = Z0Z_getDatatypeModuleScalar()
     for stmt in FunctionDefTarget.body.copy():
         if isinstance(stmt, ast.AnnAssign):
             if isinstance(stmt.target, ast.Name) and isinstance(stmt.value, ast.Constant):
@@ -609,7 +548,7 @@ def evaluateAnnAssignIn_body(FunctionDefTarget: ast.FunctionDef) -> ast.Function
                 assignment = ast.Assign(targets=[astAssignee], value=astCall)
                 FunctionDefTarget.body.insert(0, assignment)
                 FunctionDefTarget.body.remove(stmt)
-    return FunctionDefTarget
+    return FunctionDefTarget, allImports
 
 def removeIdentifierFrom_body(FunctionDefTarget: ast.FunctionDef, astArg: ast.arg) -> ast.FunctionDef:
     for stmt in FunctionDefTarget.body.copy():
@@ -648,158 +587,51 @@ def astNameToAstConstant(FunctionDefTarget: ast.FunctionDef, name: str, value: i
 
     return cast(ast.FunctionDef, NodeReplacer(findName, replaceWithConstant).visit(FunctionDefTarget))
 
-def makeDecorator(FunctionDefTarget: ast.FunctionDef, parametersNumba: Optional[ParametersNumba]=None) -> ast.FunctionDef:
-    # Use NodeReplacer to handle decorator cleanup
-    def isNumbaJitDecorator(node: ast.AST) -> bool:
-        return ((isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute)
-                and getattr(node.func.value, "id", None) == "numba" and node.func.attr == "jit")
-                or
-                (isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and node.func.id == "jit"))
-
-    def extractNumbaParams(node: ast.Call) -> None:
-        nonlocal parametersNumba
-        if parametersNumba is None:
-            parametersNumbaExtracted: Dict[str, Any] = {}
-            for keywordItem in node.keywords:
-                if isinstance(keywordItem.value, ast.Constant) and keywordItem.arg is not None:
-                    parametersNumbaExtracted[keywordItem.arg] = keywordItem.value.value
-            if parametersNumbaExtracted:
-                parametersNumba = ParametersNumba(parametersNumbaExtracted)  # type: ignore
-        return None
-
-    # Remove existing numba decorators
-    decoratorCleaner = NodeReplacer(isNumbaJitDecorator, extractNumbaParams)
-    FunctionDefTarget = cast(ast.FunctionDef, decoratorCleaner.visit(FunctionDefTarget))
-
-    FunctionDefTarget = Z0Z_UnhandledDecorators(FunctionDefTarget)
-    allImports.addImportFromStr('numba', 'jit')
-    FunctionDefTarget = decorateCallableWithNumba(FunctionDefTarget, parametersNumba)
-
-    # Convert @numba.jit to @jit
-    def isNumbaJitCall(node: ast.AST) -> bool:
-        return (isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute) and node.func.attr == "jit")
-
-    def convertToPlainJit(node: ast.Call) -> ast.Call:
-        node.func = ast.Name(id="jit", ctx=ast.Load())
-        return node
-
-    jitSimplifier = NodeReplacer(isNumbaJitCall, convertToPlainJit)
-    return cast(ast.FunctionDef, jitSimplifier.visit(FunctionDefTarget))
-
-def makeLauncher(callableTarget: str) -> ast.Module:
+def makeLauncherJobNumba(callableTarget: str, pathFilenameFoldsTotal: pathlib.Path) -> ast.Module:
     linesLaunch = f"""
 if __name__ == '__main__':
     import time
     timeStart = time.perf_counter()
-    {callableTarget}()
-    print(time.perf_counter() - timeStart)
+    foldsTotal = {callableTarget}()
+    print(foldsTotal, time.perf_counter() - timeStart)
+    writeStream = open('{pathFilenameFoldsTotal.as_posix()}', 'w')
+    writeStream.write(str(foldsTotal))
+    writeStream.close()
 """
-    astLaunch = ast.parse(linesLaunch)
-    return astLaunch
-
-def make_writeFoldsTotal(stateJob: computationState, pathFilenameFoldsTotal: pathlib.Path) -> ast.Module:
-    allImports.addImportFromStr('numba', 'objmode')
-    linesWriteFoldsTotal = f"""
-groupsOfFolds *= {str(stateJob['foldGroups'][-1])}
-print(groupsOfFolds)
-with objmode():
-    open('{pathFilenameFoldsTotal.as_posix()}', 'w').write(str(groupsOfFolds))
-return groupsOfFolds
-    """
-    return ast.parse(linesWriteFoldsTotal)
-
-def writeJobNumba(listDimensions: Sequence[int], callableTarget: str, algorithmSource: ModuleType, parametersNumba: Optional[ParametersNumba]=None, pathFilenameWriteJob: Optional[Union[str, os.PathLike[str]]] = None, **keywordArguments: Optional[Any]) -> pathlib.Path:
-    """
-    Parameters:
-        **keywordArguments: most especially for `computationDivisions` if you want to make a parallel job. Also `CPUlimit`.
-    """
-    stateJob = makeStateJob(listDimensions, writeJob=False, **keywordArguments)
-    pythonSource = inspect.getsource(algorithmSource)
-    astModule = ast.parse(pythonSource)
-
-    for statement in astModule.body:
-        if isinstance(statement, (ast.Import, ast.ImportFrom)):
-            allImports.addAst(statement)
-
-    FunctionDefTarget = next((node for node in astModule.body if isinstance(node, ast.FunctionDef) and node.name == callableTarget), None)
-
-    if not FunctionDefTarget:
-        raise ValueError(f"Could not find function {callableTarget} in source code.")
-
-    # Define argument processing rules
-    argumentRules = [
-        (lambda arg: arg.arg in ['connectionGraph', 'gapsWhere'],
-        lambda node, arg: moveArrayTo_body(node, arg, stateJob[arg.arg])),
-
-        (lambda arg: arg.arg in ['track'],
-        lambda node, arg: evaluateArrayIn_body(node, arg, stateJob[arg.arg])),
-
-        (lambda arg: arg.arg in ['my'],
-        lambda node, arg: evaluate_argIn_body(node, arg, stateJob[arg.arg], ['taskIndex', 'dimensionsTotal'])),
-
-        (lambda arg: arg.arg in ['foldGroups'],
-        lambda node, arg: removeIdentifierFrom_body(node, arg))
-    ]
-
-    # Process arguments using ArgumentProcessor
-    argumentProcessor = ArgumentProcessor(argumentRules)
-    FunctionDefTarget = argumentProcessor.process(FunctionDefTarget)
+    return ast.parse(linesLaunch)
 
-    FunctionDefTarget = evaluateAnnAssignIn_body(FunctionDefTarget)
-    FunctionDefTarget = astNameToAstConstant(FunctionDefTarget, 'dimensionsTotal', int(stateJob['my'][indexMy.dimensionsTotal]))
-    FunctionDefTarget = astObjectToAstConstant(FunctionDefTarget, 'foldGroups[-1]', int(stateJob['foldGroups'][-1]))
+def addReturnJobNumba(FunctionDefTarget: ast.FunctionDef, stateJob: computationState, allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+    """Add multiplication and return statement to function, properly constructing AST nodes."""
+    # Create AST for multiplication operation
+    multiplicand = Z0Z_identifierCountFolds
+    datatype = hackSSOTdatatype(multiplicand)
+    multiplyOperation = ast.BinOp(
+        left=ast.Name(id=multiplicand, ctx=ast.Load()),
+        op=ast.Mult(), right=ast.Constant(value=int(stateJob['foldGroups'][-1])))
 
-    FunctionDefTarget = makeDecorator(FunctionDefTarget, parametersNumba)
+    returnStatement = ast.Return(value=multiplyOperation)
 
-    pathFilenameFoldsTotal = getPathFilenameFoldsTotal(stateJob['mapShape'])
-    astWriteFoldsTotal = make_writeFoldsTotal(stateJob, pathFilenameFoldsTotal)
-    FunctionDefTarget.body += astWriteFoldsTotal.body
+    datatypeModuleScalar = Z0Z_getDatatypeModuleScalar()
+    allImports.addImportFromStr(datatypeModuleScalar, datatype)
+    FunctionDefTarget.returns = ast.Name(id=datatype, ctx=ast.Load())
 
-    astLauncher = makeLauncher(FunctionDefTarget.name)
+    FunctionDefTarget.body.append(returnStatement)
 
-    astImports = allImports.makeListAst()
+    return FunctionDefTarget, allImports
 
-    astModule = ast.Module(
-        body=cast(List[ast.stmt]
-                , astImports
-                + [FunctionDefTarget]
-                + [astLauncher])
-        , type_ignores=[]
-    )
-    ast.fix_missing_locations(astModule)
-
-    pythonSource = ast.unparse(astModule)
-    pythonSource = autoflake.fix_code(pythonSource, ['mapFolding', 'numba', 'numpy'])
-
-    if pathFilenameWriteJob is None:
-        filename = getFilenameFoldsTotal(stateJob['mapShape'])
-        pathRoot = getPathJobRootDEFAULT()
-        pathFilenameWriteJob = pathlib.Path(pathRoot, pathlib.Path(filename).stem, pathlib.Path(filename).with_suffix('.py'))
-    else:
-        pathFilenameWriteJob = pathlib.Path(pathFilenameWriteJob)
-    pathFilenameWriteJob.parent.mkdir(parents=True, exist_ok=True)
-
-    pathFilenameWriteJob.write_text(pythonSource)
-    return pathFilenameWriteJob
-
-if __name__ == '__main__':
-    setDatatypeModule('numpy', sourGrapes=True)
-    setDatatypeFoldsTotal('int64', sourGrapes=True)
-    setDatatypeElephino('uint8', sourGrapes=True)
-    setDatatypeLeavesTotal('uint8', sourGrapes=True)
-    listCallablesInline: List[str] = ['countInitialize', 'countParallel', 'countSequential']
-    datatypeModuleScalar = 'numba'
-    datatypeModuleDecorator = 'numba'
-    callableDispatcher = 'doTheNeedful'
-    makeNumbaOptimizedFlow(listCallablesInline, callableDispatcher)
-
-    listDimensions = [5,5]
-    setDatatypeFoldsTotal('int64', sourGrapes=True)
-    setDatatypeElephino('uint8', sourGrapes=True)
-    setDatatypeLeavesTotal('uint8', sourGrapes=True)
-    from mapFolding.syntheticModules import numba_countSequential
-    algorithmSource: ModuleType = numba_countSequential
-    datatypeModuleScalar = 'numba'
-    datatypeModuleDecorator = 'numba'
-    allImports = UniversalImportTracker()
-    pathFilenameModule = writeJobNumba(listDimensions, 'countSequential', algorithmSource, parametersNumbaDEFAULT)
+def unrollWhileLoop(FunctionDefTarget: ast.FunctionDef, iteratorName: str, iterationsTotal: int, connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[numpy.integer[Any]]]) -> ast.FunctionDef:
+    """
+    Unroll the countGaps loop: in theDao, it is a while loop, of course.
+    However, it could be written as `for indexDimension in range(dimensionsTotal):`.
+    It is useful to note that it could also be written as `for indexDimension in range(connectionGraph.shape[0]):`.
+    We will unroll the loop into a series of stateJob['my'][indexMy.dimensionsTotal]-many code blocks that are similar but not identical.
+    In each code block, we know the value of the identifier `indexDimension`, so we replace the identifier with its value.
+    Furthermore, we will split connectionGraph into arrays along the first axis.
+    `connectionGraph[indexDimension, leaf1ndex, leafBelow[leafConnectee]]`
+    `connectionGraph0[leaf1ndex, leafBelow[leafConnectee]]`
+    `connectionGraph1[leaf1ndex, leafBelow[leafConnectee]]`
+    `connectionGraphN[leaf1ndex, leafBelow[leafConnectee]]`
+
+    After unrolling, we can remove three `indexDimension` statements: 1) the first initialization, which is really a memory allocation, 2) the loop initialization, and 3) the loop increment.
+    """
+    return FunctionDefTarget

mapfolding-0.3.12/mapFolding/someAssemblyRequired/synthesizeNumbaHardcoding.py

@@ -0,0 +1,188 @@
+from synthesizeNumba import *
+
+def makeNumbaOptimizedFlow(listCallablesInline: List[str], callableDispatcher: Optional[str] = None, algorithmSource: Optional[ModuleType] = None) -> None:
+    if not algorithmSource:
+        algorithmSource = getAlgorithmSource()
+
+    formatModuleNameDEFAULT = "numba_{callableTarget}"
+
+    # When I am a more competent programmer, I will make getPathFilenameWrite dependent on makeAstImport or vice versa,
+    # so the name of the physical file doesn't get out of whack with the name of the logical module.
+    def getPathFilenameWrite(callableTarget: str
+                            , pathWrite: Optional[pathlib.Path] = None
+                            , formatFilenameWrite: Optional[str] = None
+                            ) -> pathlib.Path:
+        if not pathWrite:
+            pathWrite = getPathSyntheticModules()
+        if not formatFilenameWrite:
+            formatFilenameWrite = formatModuleNameDEFAULT + '.py'
+
+        pathFilename = pathWrite  / formatFilenameWrite.format(callableTarget=callableTarget)
+        return pathFilename
+
+    def makeAstImport(callableTarget: str
+                        , packageName: Optional[str] = None
+                        , subPackageName: Optional[str] = None
+                        , moduleName: Optional[str] = None
+                        , astNodeLogicalPathThingy: Optional[ast.AST] = None
+                        ) -> ast.ImportFrom:
+        """Creates import AST node for synthetic modules."""
+        if astNodeLogicalPathThingy is None:
+            if packageName is None:
+                packageName = myPackageNameIs
+            if subPackageName is None:
+                subPackageName = moduleOfSyntheticModules
+            if moduleName is None:
+                moduleName = formatModuleNameDEFAULT.format(callableTarget=callableTarget)
+            module=f'{packageName}.{subPackageName}.{moduleName}'
+        else:
+            module = str(astNodeLogicalPathThingy)
+        return ast.ImportFrom(
+            module=module,
+            names=[ast.alias(name=callableTarget, asname=None)],
+            level=0
+        )
+
+    listStuffYouOughtaKnow: List[youOughtaKnow] = []
+
+    for callableTarget in listCallablesInline:
+        pythonSource = inspect.getsource(algorithmSource)
+        parametersNumba = None
+        unpackArrays = False
+        match callableTarget:
+            case 'countParallel':
+                parametersNumba = parametersNumbaSuperJitParallel
+            case 'countSequential':
+                parametersNumba = parametersNumbaSuperJit
+                unpackArrays = True
+            case 'countInitialize':
+                parametersNumba = parametersNumbaDEFAULT
+        pythonSource = inlineOneCallable(pythonSource, callableTarget, parametersNumba, unpackArrays)
+        if not pythonSource:
+            raise Exception("Pylance, OMG! The sky is falling!")
+
+        pathFilename = getPathFilenameWrite(callableTarget)
+
+        listStuffYouOughtaKnow.append(youOughtaKnow(
+            callableSynthesized=callableTarget,
+            pathFilenameForMe=pathFilename,
+            astForCompetentProgrammers=makeAstImport(callableTarget)
+        ))
+        pythonSource = autoflake.fix_code(pythonSource, ['mapFolding', 'numba', 'numpy'])
+        pathFilename.write_text(pythonSource)
+
+    # Generate dispatcher if requested
+    if callableDispatcher:
+        pythonSource = inspect.getsource(algorithmSource)
+        pythonSource = makeDispatcherNumba(pythonSource, callableDispatcher, listStuffYouOughtaKnow)
+        if not pythonSource:
+            raise FREAKOUT
+
+        pathFilename = getPathFilenameWrite(callableDispatcher)
+
+        listStuffYouOughtaKnow.append(youOughtaKnow(
+            callableSynthesized=callableDispatcher,
+            pathFilenameForMe=pathFilename,
+            astForCompetentProgrammers=makeAstImport(callableDispatcher)
+        ))
+        pythonSource = autoflake.fix_code(pythonSource, ['mapFolding', 'numba', 'numpy'])
+        pathFilename.write_text(pythonSource)
+
+def writeJobNumba(listDimensions: Sequence[int], callableTarget: str, algorithmSource: ModuleType, parametersNumba: Optional[ParametersNumba]=None, pathFilenameWriteJob: Optional[Union[str, os.PathLike[str]]] = None, **keywordArguments: Optional[Any]) -> pathlib.Path:
+    """ Parameters: **keywordArguments: most especially for `computationDivisions` if you want to make a parallel job. Also `CPUlimit`. """
+    """Notes about the existing logic:
+    - the synthesized module must run well as a standalone interpreted Python script
+    - `writeJobNumba` synthesizes a parameter-specific module by starting with code synthesized by `makeNumbaOptimizedFlow`, which improves the optimization
+    - similarly, `writeJobNumba` should be a solid foundation for more optimizations, most especially compiling to a standalone executable, but the details of the next optimization step are unknown
+    - the minimum runtime (on my computer) to compute a value unknown to mathematicians is 26 hours, therefore, we ant to ensure the value is seen by the user, but we must have ultra-light overhead.
+    - perf_counter is for testing. When I run a real job, I delete those lines
+    - avoid `with` statement
+    """
+    stateJob = makeStateJob(listDimensions, writeJob=False, **keywordArguments)
+    pythonSource = inspect.getsource(algorithmSource)
+    astModule = ast.parse(pythonSource)
+
+    allImports = UniversalImportTracker()
+
+    for statement in astModule.body:
+        if isinstance(statement, (ast.Import, ast.ImportFrom)):
+            allImports.addAst(statement)
+
+    FunctionDefTarget = next((node for node in astModule.body if isinstance(node, ast.FunctionDef) and node.name == callableTarget), None)
+    if not FunctionDefTarget: raise ValueError(f"I received `{callableTarget=}` and {algorithmSource.__name__=}, but I could not find that function in that source.")
+
+    for pirateScowl in FunctionDefTarget.args.args.copy():
+        match pirateScowl.arg:
+            case 'my':
+                FunctionDefTarget, allImports = evaluate_argIn_body(FunctionDefTarget, pirateScowl, stateJob[pirateScowl.arg], ['taskIndex', 'dimensionsTotal'], allImports)
+            case 'track':
+                FunctionDefTarget, allImports = evaluateArrayIn_body(FunctionDefTarget, pirateScowl, stateJob[pirateScowl.arg], allImports)
+            # TODO remove this after implementing `unrollWhileLoop`
+            case 'connectionGraph':
+                FunctionDefTarget, allImports = moveArrayTo_body(FunctionDefTarget, pirateScowl, stateJob[pirateScowl.arg], allImports)
+            case 'gapsWhere':
+                FunctionDefTarget, allImports = moveArrayTo_body(FunctionDefTarget, pirateScowl, stateJob[pirateScowl.arg], allImports)
+            case 'foldGroups':
+                FunctionDefTarget = removeIdentifierFrom_body(FunctionDefTarget, pirateScowl)
+
+    # Move function parameters to the function body,
+    # initialize identifiers with their state types and values,
+    # and replace static-valued identifiers with their values.
+    FunctionDefTarget, allImports = evaluateAnnAssignIn_body(FunctionDefTarget, allImports)
+    FunctionDefTarget = astNameToAstConstant(FunctionDefTarget, 'dimensionsTotal', int(stateJob['my'][indexMy.dimensionsTotal]))
+    FunctionDefTarget = astObjectToAstConstant(FunctionDefTarget, 'foldGroups[-1]', int(stateJob['foldGroups'][-1]))
+
+    FunctionDefTarget = unrollWhileLoop(FunctionDefTarget, 'indexDimension', stateJob['my'][indexMy.dimensionsTotal], stateJob['connectionGraph'])
+
+    FunctionDefTarget, allImports = addReturnJobNumba(FunctionDefTarget, stateJob, allImports)
+    FunctionDefTarget, allImports = makeDecoratorJobNumba(FunctionDefTarget, allImports, parametersNumba)
+
+    pathFilenameFoldsTotal = getPathFilenameFoldsTotal(stateJob['mapShape'])
+    # TODO consider: 1) launcher is a function, 2) if __name__ calls the launcher function, and 3) the launcher is "jitted", even just a light jit, then 4) `FunctionDefTarget` could be superJit.
+    astLauncher = makeLauncherJobNumba(FunctionDefTarget.name, pathFilenameFoldsTotal)
+
+    astImports = allImports.makeListAst()
+
+    astModule = ast.Module(body=cast(List[ast.stmt], astImports + [FunctionDefTarget] + [astLauncher]), type_ignores=[])
+    ast.fix_missing_locations(astModule)
+
+    pythonSource = ast.unparse(astModule)
+    pythonSource = autoflake.fix_code(pythonSource, ['mapFolding', 'numba', 'numpy'])
+
+    if pathFilenameWriteJob is None:
+        filename = getFilenameFoldsTotal(stateJob['mapShape'])
+        pathRoot = getPathJobRootDEFAULT()
+        pathFilenameWriteJob = pathlib.Path(pathRoot, pathlib.Path(filename).stem, pathlib.Path(filename).with_suffix('.py'))
+    else:
+        pathFilenameWriteJob = pathlib.Path(pathFilenameWriteJob)
+    pathFilenameWriteJob.parent.mkdir(parents=True, exist_ok=True)
+
+    pathFilenameWriteJob.write_text(pythonSource)
+    return pathFilenameWriteJob
+
+def mainBig():
+    setDatatypeModule('numpy', sourGrapes=True)
+    setDatatypeFoldsTotal('int64', sourGrapes=True)
+    setDatatypeElephino('uint8', sourGrapes=True)
+    setDatatypeLeavesTotal('uint8', sourGrapes=True)
+    listCallablesInline: List[str] = ['countInitialize', 'countParallel', 'countSequential']
+    Z0Z_setDatatypeModuleScalar('numba')
+    Z0Z_setDecoratorCallable('jit')
+    callableDispatcher = 'doTheNeedful'
+    makeNumbaOptimizedFlow(listCallablesInline, callableDispatcher)
+
+def mainSmall():
+    listDimensions = [6,6]
+    setDatatypeFoldsTotal('int64', sourGrapes=True)
+    setDatatypeElephino('uint8', sourGrapes=True)
+    setDatatypeLeavesTotal('uint8', sourGrapes=True)
+    from mapFolding.syntheticModules import numba_countSequential
+    algorithmSource: ModuleType = numba_countSequential
+    Z0Z_setDatatypeModuleScalar('numba')
+    Z0Z_setDecoratorCallable('jit')
+    writeJobNumba(listDimensions, 'countSequential', algorithmSource, parametersNumbaDEFAULT)
+
+if __name__ == '__main__':
+    mainBig()
+
+    mainSmall()

{mapfolding-0.3.11 → mapfolding-0.3.12}/mapFolding/syntheticModules/numba_countInitialize.py

@@ -1,5 +1,5 @@
-from mapFolding import indexMy
 from mapFolding import indexTrack
+from mapFolding import indexMy
 from numba import uint8
 from numba import jit
 from numpy import ndarray

{mapfolding-0.3.11 → mapfolding-0.3.12}/mapFolding/syntheticModules/numba_countParallel.py

@@ -1,9 +1,9 @@
-from mapFolding import indexMy
 from mapFolding import indexTrack
+from mapFolding import indexMy
 from numba import uint8
-from numba import prange
 from numba import jit
 from numba import int64
+from numba import prange
 from numpy import ndarray
 from numpy import dtype
 from numpy import integer

{mapfolding-0.3.11 → mapfolding-0.3.12}/mapFolding/syntheticModules/numba_countSequential.py

@@ -1,5 +1,5 @@
-from mapFolding import indexMy
 from mapFolding import indexTrack
+from mapFolding import indexMy
 from numba import uint8
 from numba import jit
 from numba import int64
@@ -25,33 +25,33 @@ def countSequential(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer
     gap1ndex = my[indexMy.gap1ndex.value]
     taskIndex = my[indexMy.taskIndex.value]
     groupsOfFolds: int = 0
-    doFindGaps = True
     while leaf1ndex:
-        if (doFindGaps := (leaf1ndex <= 1 or leafBelow[0] == 1)) and leaf1ndex > foldGroups[-1]:
-            groupsOfFolds += 1
-        elif doFindGaps:
-            dimensionsUnconstrained = dimensionsTotal
-            gap1ndexCeiling = gapRangeStart[leaf1ndex - 1]
-            indexDimension = 0
-            while indexDimension < dimensionsTotal:
-                if connectionGraph[indexDimension, leaf1ndex, leaf1ndex] == leaf1ndex:
-                    dimensionsUnconstrained -= 1
-                else:
-                    leafConnectee = connectionGraph[indexDimension, leaf1ndex, leaf1ndex]
-                    while leafConnectee != leaf1ndex:
-                        gapsWhere[gap1ndexCeiling] = leafConnectee
-                        if countDimensionsGapped[leafConnectee] == 0:
-                            gap1ndexCeiling += 1
-                        countDimensionsGapped[leafConnectee] += 1
-                        leafConnectee = connectionGraph[indexDimension, leaf1ndex, leafBelow[leafConnectee]]
-                indexDimension += 1
-            indexMiniGap = gap1ndex
-            while indexMiniGap < gap1ndexCeiling:
-                gapsWhere[gap1ndex] = gapsWhere[indexMiniGap]
-                if countDimensionsGapped[gapsWhere[indexMiniGap]] == dimensionsUnconstrained:
-                    gap1ndex += 1
-                countDimensionsGapped[gapsWhere[indexMiniGap]] = 0
-                indexMiniGap += 1
+        if leaf1ndex <= 1 or leafBelow[0] == 1:
+            if leaf1ndex > foldGroups[-1]:
+                groupsOfFolds += 1
+            else:
+                dimensionsUnconstrained = dimensionsTotal
+                gap1ndexCeiling = gapRangeStart[leaf1ndex - 1]
+                indexDimension = 0
+                while indexDimension < dimensionsTotal:
+                    if connectionGraph[indexDimension, leaf1ndex, leaf1ndex] == leaf1ndex:
+                        dimensionsUnconstrained -= 1
+                    else:
+                        leafConnectee = connectionGraph[indexDimension, leaf1ndex, leaf1ndex]
+                        while leafConnectee != leaf1ndex:
+                            gapsWhere[gap1ndexCeiling] = leafConnectee
+                            if countDimensionsGapped[leafConnectee] == 0:
+                                gap1ndexCeiling += 1
+                            countDimensionsGapped[leafConnectee] += 1
+                            leafConnectee = connectionGraph[indexDimension, leaf1ndex, leafBelow[leafConnectee]]
+                    indexDimension += 1
+                indexMiniGap = gap1ndex
+                while indexMiniGap < gap1ndexCeiling:
+                    gapsWhere[gap1ndex] = gapsWhere[indexMiniGap]
+                    if countDimensionsGapped[gapsWhere[indexMiniGap]] == dimensionsUnconstrained:
+                        gap1ndex += 1
+                    countDimensionsGapped[gapsWhere[indexMiniGap]] = 0
+                    indexMiniGap += 1
         while leaf1ndex and gap1ndex == gapRangeStart[leaf1ndex - 1]:
             leaf1ndex -= 1
             leafBelow[leafAbove[leaf1ndex]] = leafBelow[leaf1ndex]

{mapfolding-0.3.11 → mapfolding-0.3.12}/mapFolding/theDao.py

@@ -36,9 +36,6 @@ def countGaps(gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[T
         gap1ndexCeilingIncrement(my=my)
     track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
 
-def dimension1ndexIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
-    my[indexMy.indexDimension.value] += 1
-
 def dimensionsUnconstrainedCondition(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
     return connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]
 
@@ -56,6 +53,9 @@ def findGapsInitializeVariables(my: ndarray[Tuple[int], dtype[integer[Any]]], tr
     my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
     my[indexMy.indexDimension.value] = 0
 
+def indexDimensionIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+    my[indexMy.indexDimension.value] += 1
+
 def indexMiniGapIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
     my[indexMy.indexMiniGap.value] += 1
 
@@ -81,7 +81,7 @@ def leafConnecteeUpdate(connectionGraph: ndarray[Tuple[int, int, int], dtype[int
 def loopingLeavesConnectedToActiveLeaf(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
     return my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]
 
-def loopingTheDimensions(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def loopUpToDimensionsTotal(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
     return my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]
 
 def loopingToActiveGapCeiling(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
@@ -111,7 +111,7 @@ def countInitialize(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer
     while activeLeafGreaterThan0Condition(my=my):
         if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
             findGapsInitializeVariables(my=my, track=track)
-            while loopingTheDimensions(my=my):
+            while loopUpToDimensionsTotal(my=my):
                 if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
                     dimensionsUnconstrainedDecrement(my=my)
                 else:
@@ -119,7 +119,7 @@ def countInitialize(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer
                     while loopingLeavesConnectedToActiveLeaf(my=my):
                         countGaps(gapsWhere=gapsWhere, my=my, track=track)
                         leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
-                dimension1ndexIncrement(my=my)
+                indexDimensionIncrement(my=my)
             if allDimensionsAreUnconstrained(my=my):
                 insertUnconstrainedLeaf(gapsWhere=gapsWhere, my=my)
             indexMiniGapInitialization(my=my)
@@ -159,7 +159,7 @@ def countParallel(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[A
                     groupsOfFolds += 1
                 else:
                     findGapsInitializeVariables(my=my, track=track)
-                    while loopingTheDimensions(my=my):
+                    while loopUpToDimensionsTotal(my=my):
                         if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
                             dimensionsUnconstrainedDecrement(my=my)
                         else:
@@ -168,7 +168,7 @@ def countParallel(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[A
                                 if thereAreComputationDivisionsYouMightSkip(my=my):
                                     countGaps(gapsWhere=gapsWhere, my=my, track=track)
                                 leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
-                        dimension1ndexIncrement(my=my)
+                        indexDimensionIncrement(my=my)
                     indexMiniGapInitialization(my=my)
                     while loopingToActiveGapCeiling(my=my):
                         filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
@@ -187,27 +187,26 @@ def countSequential( connectionGraph: ndarray[Tuple[int, int, int], dtype[intege
                     ) -> None:
 
     groupsOfFolds: int = 0
-    doFindGaps = True # Frankly, I can't figure out if `doFindGaps` is or is not faster. Furthermore, I have a strong feeling there is an even better way.
 
     while activeLeafGreaterThan0Condition(my=my):
-        if ((doFindGaps := activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track))
-                and activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my)):
-            groupsOfFolds += 1
-        elif doFindGaps:
-            findGapsInitializeVariables(my=my, track=track)
-            while loopingTheDimensions(my=my):
-                if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
-                    dimensionsUnconstrainedDecrement(my=my)
-                else:
-                    leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
-                    while loopingLeavesConnectedToActiveLeaf(my=my):
-                        countGaps(gapsWhere=gapsWhere, my=my, track=track)
-                        leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
-                dimension1ndexIncrement(my=my)
-            indexMiniGapInitialization(my=my)
-            while loopingToActiveGapCeiling(my=my):
-                filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
-                indexMiniGapIncrement(my=my)
+        if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
+            if activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my):
+                groupsOfFolds += 1
+            else:
+                findGapsInitializeVariables(my=my, track=track)
+                while loopUpToDimensionsTotal(my=my):
+                    if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
+                        dimensionsUnconstrainedDecrement(my=my)
+                    else:
+                        leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
+                        while loopingLeavesConnectedToActiveLeaf(my=my):
+                            countGaps(gapsWhere=gapsWhere, my=my, track=track)
+                            leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
+                    indexDimensionIncrement(my=my)
+                indexMiniGapInitialization(my=my)
+                while loopingToActiveGapCeiling(my=my):
+                    filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
+                    indexMiniGapIncrement(my=my)
         while backtrackCondition(my=my, track=track):
             backtrack(my=my, track=track)
         if placeLeafCondition(my=my):

{mapfolding-0.3.11 → mapfolding-0.3.12}/mapFolding/theSSOT.py

@@ -249,3 +249,27 @@ def hackSSOTdatatype(identifier: str) -> str:
     elif RubeGoldBerg == 'datatypeLeavesTotal':
         return _get_datatype('leavesTotal')
     raise Exception("Dude, you forgot to set a value in `hackSSOTdatatype`.")
+
+_datatypeModuleScalar = 'numba'
+_decoratorCallable = 'jit'
+def Z0Z_getDatatypeModuleScalar() -> str:
+    return _datatypeModuleScalar
+
+def Z0Z_setDatatypeModuleScalar(moduleName: str) -> str:
+    global _datatypeModuleScalar
+    _datatypeModuleScalar = moduleName
+    return _datatypeModuleScalar
+
+def Z0Z_getDecoratorCallable() -> str:
+    return _decoratorCallable
+
+def Z0Z_setDecoratorCallable(decoratorName: str) -> str:
+    global _decoratorCallable
+    _decoratorCallable = decoratorName
+    return _decoratorCallable
+
+class FREAKOUT(Exception):
+    pass
+
+# This identifier is declared in theDao.py. Two sources of truth is better than 900.
+Z0Z_identifierCountFolds = 'groupsOfFolds'

{mapfolding-0.3.11 → mapfolding-0.3.12}/mapFolding/theSSOTnumba.py

@@ -34,7 +34,7 @@ Old notes that are not entirely accurate.
 | `no_cpython_wrapper`    | Disable Python C-API wrapper generation             | Size                  | Smallest        | Exclusionary             |
 
 """
-
+# NOTE Deepseek removed forceinline=True, inline='always'
 # TODO try to implement all possible parameters, but use `NotRequired` for the more esoteric ones
 class ParametersNumba(TypedDict):
     _dbg_extend_lifetimes: NotRequired[bool]

{mapfolding-0.3.11 → mapfolding-0.3.12}/mapFolding.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.3.11
+Version: 0.3.12
 Summary: Count distinct ways to fold a map (or a strip of stamps)
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0

{mapfolding-0.3.11 → mapfolding-0.3.12}/mapFolding.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ mapFolding/someAssemblyRequired/getLLVMforNoReason.py
 mapFolding/someAssemblyRequired/makeJob.py
 mapFolding/someAssemblyRequired/synthesizeModuleJAX.py
 mapFolding/someAssemblyRequired/synthesizeNumba.py
+mapFolding/someAssemblyRequired/synthesizeNumbaHardcoding.py
 mapFolding/syntheticModules/numba_countInitialize.py
 mapFolding/syntheticModules/numba_countParallel.py
 mapFolding/syntheticModules/numba_countSequential.py

{mapfolding-0.3.11 → mapfolding-0.3.12}/pyproject.toml

@@ -47,7 +47,7 @@ readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"
 scripts = { getOEISids = "mapFolding.oeis:getOEISids", clearOEIScache = "mapFolding.oeis:clearOEIScache", OEIS_for_n = "mapFolding.oeis:OEIS_for_n" }
 urls = { Donate = "https://www.patreon.com/integrated", Homepage = "https://github.com/hunterhogan/mapFolding", Repository = "https://github.com/hunterhogan/mapFolding.git" }
-version = "0.3.11"
+version = "0.3.12"
 
 [tool.coverage]
 report = { exclude_lines = [