mapFolding 0.8.5__py3-none-any.whl → 0.8.6__py3-none-any.whl

mapFolding/__init__.py

@@ -1,10 +1,10 @@
 """
-Map folding enumeration and counting algorithms with optimization capabilities.
+Map folding enumeration and counting algorithms with advanced optimization capabilities.
 
-This package implements algorithms to count and enumerate the various ways
+This package implements algorithms to count and enumerate the distinct ways
 a rectangular map can be folded, based on the mathematical problem described
 in Lunnon's 1971 paper. It provides multiple layers of functionality, from
-high-level user interfaces to low-level algorithmic optimizations and code
+high-level user interfaces to sophisticated algorithmic optimizations and code
 transformation tools.
 
 Core modules:
@@ -29,9 +29,10 @@ Special directories:
   - reference/jobsCompleted/: Contains successful computations for previously unknown values,
     including first-ever calculations for 2x19 and 2x20 maps (OEIS A001415)
 
-This package strives to balance algorithm readability and understandability with
+This package balances algorithm readability and understandability with
 high-performance computation capabilities, allowing users to compute map folding
-totals for larger dimensions than previously feasible.
+totals for larger dimensions than previously feasible while also providing
+a foundation for exploring advanced code transformation techniques.
 """
 from mapFolding.basecamp import countFolds
 from mapFolding.oeis import clearOEIScache, getOEISids, OEIS_for_n, oeisIDfor_n

mapFolding/oeis.py

@@ -2,26 +2,31 @@
 Interface to The Online Encyclopedia of Integer Sequences (OEIS) for map folding sequences.
 
 This module provides a comprehensive interface for accessing and utilizing integer sequences
-from the OEIS that relate to map folding problems. It implements functionality to:
+from the OEIS that relate to map folding problems. It serves as the bridge between
+mathematical sequence definitions and the computational algorithm, implementing:
 
-1. Retrieve sequence data from OEIS with local caching for performance
-2. Map sequence indices to corresponding map shapes based on sequence definitions
-3. Provide a command-line interface for sequence lookups
-4. Execute map folding computations for sequence terms not available in OEIS
+1. Retrieval of sequence data from OEIS with local caching for performance optimization.
+2. Mapping of sequence indices to corresponding map shapes based on sequence definitions.
+3. Command-line and programmatic interfaces for sequence lookups and validation.
+4. Computation of sequence terms not available in the OEIS database.
 
 The module maintains a registry of implemented OEIS sequences (A001415-A001418, A195646)
-with their metadata, known values, and functions to convert between sequence indices and
+with their metadata, known values, and conversion functions between sequence indices and
 map dimensions. This allows the package to validate results against established mathematical
-literature and extend sequences beyond their currently known terms.
+literature while also extending sequences beyond their currently known terms.
+
+Each sequence is carefully mapped to its corresponding map folding problem, enabling
+seamless integration between the mathematical definition in OEIS and the computational
+implementation in the package.
 """
 from collections.abc import Callable
 from datetime import datetime, timedelta
+from functools import cache
 from mapFolding.theSSOT import The
 from mapFolding.toolboxFilesystem import writeStringToHere
 from pathlib import Path
 from typing import Any, Final, TYPE_CHECKING
 import argparse
-import pathlib
 import random
 import sys
 import time
@@ -36,9 +41,6 @@ else:
 
 cacheDays = 30
 
-"""
-Section: make `settingsOEIS`"""
-
 pathCache: Path = The.pathPackage / ".cache"
 
 class SettingsOEIS(TypedDict):
@@ -159,7 +161,7 @@ def _parseBFileOEIS(OEISbFile: str, oeisID: str) -> dict[int, int]:
 		OEISsequence[n] = aOFn
 	return OEISsequence
 
-def getOEISofficial(pathFilenameCache: pathlib.Path, url: str) -> None | str:
+def getOEISofficial(pathFilenameCache: Path, url: str) -> None | str:
 	tryCache: bool = False
 	if pathFilenameCache.exists():
 		fileAge: timedelta = datetime.now() - datetime.fromtimestamp(pathFilenameCache.stat().st_mtime)
@@ -186,6 +188,7 @@ def getOEISidValues(oeisID: str) -> dict[int, int]:
 	"""
 	Retrieves the specified OEIS sequence as a dictionary mapping integer indices
 	to their corresponding values.
+
 	This function checks for a cached local copy of the sequence data, using it if
 	it has not expired. Otherwise, it fetches the sequence data from the OEIS
 	website and writes it to the cache. The parsed data is returned as a dictionary
@@ -195,7 +198,7 @@ def getOEISidValues(oeisID: str) -> dict[int, int]:
 		oeisID: The identifier of the OEIS sequence to retrieve.
 	Returns:
 		OEISsequence: A dictionary where each key is an integer index, `n`, and each
-		value is the corresponding "a(n)" from the OEIS entry.
+		value is the corresponding `a(n)` from the OEIS entry.
 	Raises:
 		ValueError: If the cached or downloaded file format is invalid.
 		IOError: If there is an error reading from or writing to the local cache.
@@ -259,8 +262,23 @@ def makeSettingsOEIS() -> dict[str, SettingsOEIS]:
 settingsOEIS: dict[str, SettingsOEIS] = makeSettingsOEIS()
 """All values and settings for `oeisIDsImplemented`."""
 
-"""
-Section: private functions"""
+@cache
+def makeDictionaryFoldsTotalKnown() -> dict[tuple[int, ...], int]:
+	"""Returns a dictionary mapping dimension tuples to their known folding totals."""
+	dictionaryMapDimensionsToFoldsTotalKnown: dict[tuple[int, ...], int] = {}
+
+	for settings in settingsOEIS.values():
+		sequence = settings['valuesKnown']
+
+		for n, foldingsTotal in sequence.items():
+			mapShape = settings['getMapShape'](n)
+			mapShape = tuple(sorted(mapShape))
+			dictionaryMapDimensionsToFoldsTotalKnown[mapShape] = foldingsTotal
+	return dictionaryMapDimensionsToFoldsTotalKnown
+
+def getFoldsTotalKnown(mapShape: tuple[int, ...]) -> int:
+	lookupFoldsTotal = makeDictionaryFoldsTotalKnown()
+	return lookupFoldsTotal.get(tuple(mapShape), -1)
 
 def _formatHelpText() -> str:
 	"""Format standardized help text for both CLI and interactive use."""
@@ -285,35 +303,32 @@ def _formatOEISsequenceInfo() -> str:
 		for oeisID in oeisIDsImplemented
 	)
 
-"""
-Section: public functions"""
-
 def oeisIDfor_n(oeisID: str, n: int | Any) -> int:
 	"""
-	Calculate a(n) of a sequence from "The On-Line Encyclopedia of Integer Sequences" (OEIS).
+	Calculate `a(n)` of a sequence from "The On-Line Encyclopedia of Integer Sequences" (OEIS).
 
 	Parameters:
 		oeisID: The ID of the OEIS sequence.
 		n: A non-negative integer for which to calculate the sequence value.
 
 	Returns:
-		sequenceValue: a(n) of the OEIS sequence.
+		sequenceValue: `a(n)` of the OEIS sequence.
 
 	Raises:
-		ValueError: If n is negative.
+		ValueError: If `n` is negative.
 		KeyError: If the OEIS sequence ID is not directly implemented.
 	"""
 	oeisID = validateOEISid(oeisID)
 
 	if not isinstance(n, int) or n < 0:
-		raise ValueError("`n` must be non-negative integer.")
+		raise ValueError(f"I received `{n = }` in the form of `{type(n) = }`, but it must be non-negative integer in the form of `{int}`.")
 
 	mapShape: tuple[int, ...] = settingsOEIS[oeisID]['getMapShape'](n)
 
 	if n <= 1 or len(mapShape) < 2:
 		offset: int = settingsOEIS[oeisID]['offset']
 		if n < offset:
-			raise ArithmeticError(f"OEIS sequence {oeisID} is not defined at n={n}.")
+			raise ArithmeticError(f"OEIS sequence {oeisID} is not defined at {n = }.")
 		foldsTotal: int = settingsOEIS[oeisID]['valuesKnown'][n]
 		return foldsTotal
 	from mapFolding.basecamp import countFolds

mapFolding/someAssemblyRequired/_tool_Make.py

@@ -6,6 +6,7 @@ from mapFolding.someAssemblyRequired import (
 	intORlist_ast_type_paramORstr_orNone,
 	intORstr_orNone,
 	list_ast_type_paramORstr_orNone,
+	str_nameDOTname,
 )
 from typing import Any
 import ast
@@ -74,11 +75,11 @@ class Make:
 	def FunctionDef(name: ast_Identifier, argumentsSpecification:ast.arguments=ast.arguments(), body:list[ast.stmt]=[], decorator_list:list[ast.expr]=[], returns:ast.expr|None=None, **keywordArguments: intORlist_ast_type_paramORstr_orNone) -> ast.FunctionDef:
 		return ast.FunctionDef(name, argumentsSpecification, body, decorator_list, returns, **keywordArguments)
 	@staticmethod
-	def Import(moduleIdentifier: ast_Identifier, asname: ast_Identifier | None = None, **keywordArguments: int) -> ast.Import:
-		return ast.Import(names=[Make.alias(moduleIdentifier, asname)], **keywordArguments)
+	def Import(moduleWithLogicalPath: str_nameDOTname, asname: ast_Identifier | None = None, **keywordArguments: int) -> ast.Import:
+		return ast.Import(names=[Make.alias(moduleWithLogicalPath, asname)], **keywordArguments)
 	@staticmethod
-	def ImportFrom(moduleIdentifier: ast_Identifier, list_astAlias: list[ast.alias], **keywordArguments: int) -> ast.ImportFrom:
-		return ast.ImportFrom(moduleIdentifier, list_astAlias, **keywordArguments)
+	def ImportFrom(moduleWithLogicalPath: str_nameDOTname, list_astAlias: list[ast.alias], **keywordArguments: int) -> ast.ImportFrom:
+		return ast.ImportFrom(moduleWithLogicalPath, list_astAlias, **keywordArguments)
 	@staticmethod
 	def keyword(keywordArgument: ast_Identifier, value: ast.expr, **keywordArguments: int) -> ast.keyword:
 		return ast.keyword(arg=keywordArgument, value=value, **keywordArguments)

mapFolding/someAssemblyRequired/_toolboxContainers.py

@@ -10,6 +10,7 @@ from collections.abc import Sequence
 from mapFolding.someAssemblyRequired import ImaAnnotationType, ast_Identifier, be, Make, parseLogicalPath2astModule, str_nameDOTname
 from mapFolding.theSSOT import callableDispatcherHARDCODED, The
 from pathlib import Path, PurePosixPath
+from typing import Literal
 from Z0Z_tools import updateExtendPolishDictionaryLists
 import ast
 import dataclasses
@@ -36,11 +37,45 @@ class LedgerOfImports:
 			for alias in astImport____.names:
 				self.dictionaryImportFrom[astImport____.module].append((alias.name, alias.asname))
 
-	def addImport_asStr(self, moduleIdentifier: str_nameDOTname) -> None:
-		self.listImport.append(moduleIdentifier)
-
-	def addImportFrom_asStr(self, moduleIdentifier: ast_Identifier, name: ast_Identifier, asname: ast_Identifier | None = None) -> None:
-		self.dictionaryImportFrom[moduleIdentifier].append((name, asname))
+	def addImport_asStr(self, moduleWithLogicalPath: str_nameDOTname) -> None:
+		self.listImport.append(moduleWithLogicalPath)
+
+	# def addImportFrom_asStr(self, moduleWithLogicalPath: str_nameDOTname, name: ast_Identifier, asname: ast_Identifier | None = None) -> None:
+	# 	self.dictionaryImportFrom[moduleWithLogicalPath].append((name, asname))
+
+	def addImportFrom_asStr(self, moduleWithLogicalPath: str_nameDOTname, name: ast_Identifier, asname: ast_Identifier | None = None) -> None:
+		if moduleWithLogicalPath not in self.dictionaryImportFrom:
+			self.dictionaryImportFrom[moduleWithLogicalPath] = []
+		self.dictionaryImportFrom[moduleWithLogicalPath].append((name, asname))
+
+	def removeImportFromModule(self, moduleWithLogicalPath: str_nameDOTname) -> None:
+		self.removeImportFrom(moduleWithLogicalPath, None, None)
+		"""Remove all imports from a specific module."""
+
+	def removeImportFrom(self, moduleWithLogicalPath: str_nameDOTname, name: ast_Identifier | None, asname: ast_Identifier | None = None) -> None:
+		if moduleWithLogicalPath is None:
+			raise SyntaxError(f"I received `{moduleWithLogicalPath = }`, but it must be the name of a module.")
+		if moduleWithLogicalPath in self.dictionaryImportFrom:
+			"""
+			name, 			asname				  	Meaning
+			ast_Identifier, ast_Identifier			: remove exact matches
+			ast_Identifier, None					: remove exact matches
+			None, 			ast_Identifier			: remove all matches for asname and if entry_asname is None remove name == ast_Identifier
+			None, 			None					: remove all matches for the module
+			"""
+			if name is None and asname is None:
+				# Remove all entries for the module
+				self.dictionaryImportFrom.pop(moduleWithLogicalPath)
+			else:
+				if name is None:
+					self.dictionaryImportFrom[moduleWithLogicalPath] = [(entry_name, entry_asname) for entry_name, entry_asname in self.dictionaryImportFrom[moduleWithLogicalPath]
+													if not (entry_asname == asname) and not (entry_asname is None and entry_name == asname)]
+				else:
+					# Remove exact matches for the module
+					self.dictionaryImportFrom[moduleWithLogicalPath] = [(entry_name, entry_asname) for entry_name, entry_asname in self.dictionaryImportFrom[moduleWithLogicalPath]
+														if not (entry_name == name and entry_asname == asname)]
+				if not self.dictionaryImportFrom[moduleWithLogicalPath]:
+					self.dictionaryImportFrom.pop(moduleWithLogicalPath)
 
 	def exportListModuleIdentifiers(self) -> list[ast_Identifier]:
 		listModuleIdentifiers: list[ast_Identifier] = list(self.dictionaryImportFrom.keys())
@@ -49,13 +84,14 @@ class LedgerOfImports:
 
 	def makeList_ast(self) -> list[ast.ImportFrom | ast.Import]:
 		listImportFrom: list[ast.ImportFrom] = []
-		for moduleIdentifier, listOfNameTuples in sorted(self.dictionaryImportFrom.items()):
+		for moduleWithLogicalPath, listOfNameTuples in sorted(self.dictionaryImportFrom.items()):
 			listOfNameTuples = sorted(list(set(listOfNameTuples)), key=lambda nameTuple: nameTuple[0])
 			list_alias: list[ast.alias] = []
 			for name, asname in listOfNameTuples:
 				list_alias.append(Make.alias(name, asname))
-			listImportFrom.append(Make.ImportFrom(moduleIdentifier, list_alias))
-		list_astImport: list[ast.Import] = [Make.Import(moduleIdentifier) for moduleIdentifier in sorted(set(self.listImport))]
+			if list_alias:
+				listImportFrom.append(Make.ImportFrom(moduleWithLogicalPath, list_alias))
+		list_astImport: list[ast.Import] = [Make.Import(moduleWithLogicalPath) for moduleWithLogicalPath in sorted(set(self.listImport))]
 		return listImportFrom + list_astImport
 
 	def update(self, *fromLedger: 'LedgerOfImports') -> None:
@@ -158,6 +194,19 @@ class IngredientsModule:
 			else:
 				raise ValueError(f"I received `{type(allegedIngredientsFunction) = }`, but I can only accept `{IngredientsFunction}`.")
 
+	def removeImportFromModule(self, moduleWithLogicalPath: str_nameDOTname) -> None:
+		self.removeImportFrom(moduleWithLogicalPath, None, None)
+		"""Remove all imports from a specific module."""
+
+	def removeImportFrom(self, moduleWithLogicalPath: str_nameDOTname, name: ast_Identifier | None, asname: ast_Identifier | None = None) -> None:
+		"""
+		This method modifies all `LedgerOfImports` in this `IngredientsModule` and all `IngredientsFunction` in `listIngredientsFunctions`.
+		It is not a "blacklist", so the import from could be added after this modification.
+		"""
+		self.imports.removeImportFrom(moduleWithLogicalPath, name, asname)
+		for ingredientsFunction in self.listIngredientsFunctions:
+			ingredientsFunction.imports.removeImportFrom(moduleWithLogicalPath, name, asname)
+
 	@property
 	def list_astImportImportFrom(self) -> list[ast.Import | ast.ImportFrom]:
 		"""List of `ast.Import` and `ast.ImportFrom` statements."""

mapFolding/someAssemblyRequired/synthesizeNumbaJob.py

@@ -1,10 +1,11 @@
 """Synthesize one file to compute `foldsTotal` of `mapShape`."""
 from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal
-from mapFolding.someAssemblyRequired import ast_Identifier, be, ifThis, Make, NodeChanger, Then, IngredientsFunction, IngredientsModule
+from mapFolding.someAssemblyRequired import ast_Identifier, be, ifThis, Make, NodeChanger, Then, IngredientsFunction, IngredientsModule, LedgerOfImports
 from mapFolding.someAssemblyRequired.toolboxNumba import RecipeJob, SpicesJobNumba, decorateCallableWithNumba
-from mapFolding.someAssemblyRequired.transformationTools import astModuleToIngredientsFunction, write_astModule
+from mapFolding.someAssemblyRequired.transformationTools import astModuleToIngredientsFunction, extractFunctionDef, write_astModule
 from mapFolding.someAssemblyRequired.transformationTools import makeInitializedComputationState
-from mapFolding.theSSOT import The
+from mapFolding.theSSOT import The, raiseIfNoneGitHubIssueNumber3
+from mapFolding.oeis import getFoldsTotalKnown
 from typing import cast
 from Z0Z_tools import autoDecodingRLE
 from pathlib import PurePosixPath
@@ -27,7 +28,7 @@ if __name__ == '__main__':
 	with ProgressBar(total={job.foldsTotalEstimated}, update_interval=2) as statusUpdate:
 		{job.countCallable}(statusUpdate)
 		foldsTotal = statusUpdate.n * {job.state.leavesTotal}
-		print('map {job.state.mapShape} =', foldsTotal)
+		print('\\nmap {job.state.mapShape} =', foldsTotal)
 		writeStream = open('{job.pathFilenameFoldsTotal.as_posix()}', 'w')
 		writeStream.write(str(foldsTotal))
 		writeStream.close()
@@ -42,7 +43,7 @@ if __name__ == '__main__':
 
 	findThis = ifThis.isAugAssign_targetIs(ifThis.isName_Identifier(job.shatteredDataclass.countingVariableName.id))
 	doThat = Then.replaceWith(Make.Expr(Make.Call(Make.Attribute(Make.Name(spices.numbaProgressBarIdentifier),'update'),[Make.Constant(1)])))
-	countWithProgressBar = NodeChanger(findThis, doThat)
+	countWithProgressBar = NodeChanger(findThis, doThat) # type: ignore
 	countWithProgressBar.visit(ingredientsFunction.astFunctionDef)
 
 	ingredientsModule.appendLauncher(ast.parse(linesLaunch))
@@ -65,7 +66,6 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 					case 'scalar':
 						ImaAnnAssign.value.args[0].value = int(job.state.__dict__[ast_arg.arg])  # type: ignore
 					case 'array':
-						# print(ast.dump(ImaAnnAssign))
 						dataAsStrRLE: str = autoDecodingRLE(job.state.__dict__[ast_arg.arg], addSpaces=True)
 						dataAs_astExpr: ast.expr = cast(ast.Expr, ast.parse(dataAsStrRLE).body[0]).value
 						ImaAnnAssign.value.args = [dataAs_astExpr]  # type: ignore
@@ -89,7 +89,9 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 
 def makeJobNumba(job: RecipeJob, spices: SpicesJobNumba):
 		# get the raw ingredients: data and the algorithm
-	ingredientsCount: IngredientsFunction = astModuleToIngredientsFunction(job.source_astModule, job.countCallable)
+	astFunctionDef = extractFunctionDef(job.source_astModule, job.countCallable)
+	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
+	ingredientsCount: IngredientsFunction = IngredientsFunction(astFunctionDef, LedgerOfImports())
 
 	# Change the return so you can dynamically determine which variables are not used
 	removeReturnStatement = NodeChanger(be.Return, Then.removeIt)
@@ -107,16 +109,51 @@ def makeJobNumba(job: RecipeJob, spices: SpicesJobNumba):
 	for identifier in list_IdentifiersStaticValues:
 		findThis = ifThis.isName_Identifier(identifier)
 		doThat = Then.replaceWith(Make.Constant(int(job.state.__dict__[identifier])))
-		NodeChanger(findThis, doThat).visit(ingredientsCount.astFunctionDef)
+		NodeChanger(findThis, doThat).visit(ingredientsCount.astFunctionDef) # type: ignore
 
 	# This launcher eliminates the use of one identifier, so run it now and you can dynamically determine which variables are not used
+	ingredientsModule = IngredientsModule()
 	if spices.useNumbaProgressBar:
-		ingredientsModule = IngredientsModule()
 		ingredientsModule, ingredientsCount = addLauncherNumbaProgress(ingredientsModule, ingredientsCount, job, spices)
 		spices.parametersNumba['nogil'] = True
 
 	ingredientsCount = move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsCount, job)
 
+	Z0Z_Identifier = 'DatatypeLeavesTotal'
+	Z0Z_type = 'uint8'
+	ingredientsModule.imports.addImportFrom_asStr('numba', Z0Z_type)
+	Z0Z_module = 'typing'
+	Z0Z_annotation = 'TypeAlias'
+	ingredientsModule.imports.addImportFrom_asStr(Z0Z_module, Z0Z_annotation)
+	Z0Z_statement = Make.AnnAssign(Make.Name(Z0Z_Identifier, ast.Store()), Make.Name(Z0Z_annotation), Make.Name(Z0Z_type))
+	ingredientsModule.appendPrologue(statement=Z0Z_statement)
+
+	Z0Z_Identifier = 'DatatypeElephino'
+	Z0Z_type = 'int16'
+	ingredientsModule.imports.addImportFrom_asStr('numba', Z0Z_type)
+	Z0Z_module = 'typing'
+	Z0Z_annotation = 'TypeAlias'
+	ingredientsModule.imports.addImportFrom_asStr(Z0Z_module, Z0Z_annotation)
+	Z0Z_statement = Make.AnnAssign(Make.Name(Z0Z_Identifier, ast.Store()), Make.Name(Z0Z_annotation), Make.Name(Z0Z_type))
+	ingredientsModule.appendPrologue(statement=Z0Z_statement)
+
+	ingredientsCount.imports.removeImportFromModule('mapFolding.theSSOT')
+	Z0Z_module = 'numpy'
+	Z0Z_asname = 'Array1DLeavesTotal'
+	ingredientsCount.imports.removeImportFrom(Z0Z_module, None, Z0Z_asname)
+	Z0Z_type_name = 'uint8'
+	ingredientsCount.imports.addImportFrom_asStr(Z0Z_module, Z0Z_type_name, Z0Z_asname)
+	Z0Z_asname = 'Array1DElephino'
+	ingredientsCount.imports.removeImportFrom(Z0Z_module, None, Z0Z_asname)
+	Z0Z_type_name = 'int16'
+	ingredientsCount.imports.addImportFrom_asStr(Z0Z_module, Z0Z_type_name, Z0Z_asname)
+	Z0Z_asname = 'Array3D'
+	ingredientsCount.imports.removeImportFrom(Z0Z_module, None, Z0Z_asname)
+	Z0Z_type_name = 'uint8'
+	ingredientsCount.imports.addImportFrom_asStr(Z0Z_module, Z0Z_type_name, Z0Z_asname)
+
+	from numpy import int16 as Array1DLeavesTotal, int16 as Array1DElephino, int16 as Array3D
+
 	ingredientsCount.astFunctionDef.decorator_list = [] # TODO low-priority, handle this more elegantly
 	# TODO when I add the function signature in numba style back to the decorator, the logic needs to handle `ProgressBarType:`
 	ingredientsCount = decorateCallableWithNumba(ingredientsCount, spices.parametersNumba)
@@ -149,10 +186,11 @@ def makeJobNumba(job: RecipeJob, spices: SpicesJobNumba):
 	"""
 
 if __name__ == '__main__':
-	mapShape = (3,4)
+	mapShape = (6,6)
 	state = makeInitializedComputationState(mapShape)
+	foldsTotalEstimated = getFoldsTotalKnown(state.mapShape) // state.leavesTotal
 	pathModule = PurePosixPath(The.pathPackage, 'jobs')
 	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
-	aJob = RecipeJob(state, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
+	aJob = RecipeJob(state, foldsTotalEstimated, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
 	spices = SpicesJobNumba()
 	makeJobNumba(aJob, spices)

mapFolding/someAssemblyRequired/toolboxNumba.py

@@ -23,10 +23,11 @@ from collections.abc import Callable, Sequence
 from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal, getPathRootJobDEFAULT
 from mapFolding.someAssemblyRequired import IngredientsModule, LedgerOfImports, Make, NodeChanger, NodeTourist, RecipeSynthesizeFlow, Then, ast_Identifier, be, ifThis, parsePathFilename2astModule, str_nameDOTname, IngredientsFunction, ShatteredDataclass
 from mapFolding.someAssemblyRequired.transformationTools import Z0Z_inlineThisFunctionWithTheseValues, Z0Z_lameFindReplace, Z0Z_makeDictionaryReplacementStatements, astModuleToIngredientsFunction, shatter_dataclassesDOTdataclass, write_astModule
-from mapFolding.theSSOT import ComputationState
+from mapFolding.theSSOT import ComputationState, DatatypeFoldsTotal as TheDatatypeFoldsTotal, DatatypeElephino as TheDatatypeElephino, DatatypeLeavesTotal as TheDatatypeLeavesTotal
+
 from numba.core.compiler import CompilerBase as numbaCompilerBase
 from pathlib import Path, PurePosixPath
-from typing import Any, cast, Final, TYPE_CHECKING
+from typing import Any, cast, Final, TYPE_CHECKING, TypeAlias
 import ast
 import dataclasses
 
@@ -78,8 +79,8 @@ parametersNumbaSuperJitParallel: Final[ParametersNumba] = { **parametersNumbaSup
 """Speed, no helmet, concurrency, no talking to non-jitted functions."""
 parametersNumbaMinimum: Final[ParametersNumba] = { '_nrt': True, 'boundscheck': True, 'cache': True, 'error_model': 'numpy', 'fastmath': True, 'forceinline': False, 'inline': 'always', 'looplift': False, 'no_cfunc_wrapper': False, 'no_cpython_wrapper': False, 'nopython': False, 'forceobj': True, 'parallel': False, }
 
-Z0Z_numbaDataTypeModule = 'numba'
-Z0Z_decoratorCallable = 'jit'
+Z0Z_numbaDataTypeModule: str_nameDOTname = 'numba'
+Z0Z_decoratorCallable: ast_Identifier = 'jit'
 
 def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, parametersNumba: ParametersNumba | None = None) -> IngredientsFunction:
 	def Z0Z_UnhandledDecorators(astCallable: ast.FunctionDef) -> ast.FunctionDef:
@@ -123,7 +124,6 @@ def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, paramete
 
 	list_arg4signature_or_function: list[ast.expr] = []
 	for parameter in ingredientsFunction.astFunctionDef.args.args:
-		# Efficient translation of Python scalar types to Numba types https://github.com/hunterhogan/mapFolding/issues/8
 		# For now, let Numba infer them.
 		continue
 		# signatureElement: ast.Subscript | ast.Name | None = makeSpecialSignatureForNumba(parameter)
@@ -142,8 +142,8 @@ def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, paramete
 		parametersNumba = parametersNumbaDefault
 	listDecoratorKeywords: list[ast.keyword] = [Make.keyword(parameterName, Make.Constant(parameterValue)) for parameterName, parameterValue in parametersNumba.items()]
 
-	decoratorModule: str = Z0Z_numbaDataTypeModule
-	decoratorCallable: str = Z0Z_decoratorCallable
+	decoratorModule = Z0Z_numbaDataTypeModule
+	decoratorCallable = Z0Z_decoratorCallable
 	ingredientsFunction.imports.addImportFrom_asStr(decoratorModule, decoratorCallable)
 	# Leave this line in so that global edits will change it.
 	astDecorator: ast.Call = Make.Call(Make.Name(decoratorCallable), list_argsDecorator, listDecoratorKeywords)
@@ -197,6 +197,12 @@ class RecipeJob:
 	dataclassInstance: ast_Identifier | None = sourceDataclassInstance
 	logicalPathModuleDataclass: str_nameDOTname | None = sourceLogicalPathModuleDataclass
 
+	# ========================================
+	# Datatypes
+	DatatypeFoldsTotal: TypeAlias = TheDatatypeFoldsTotal
+	DatatypeElephino: TypeAlias = TheDatatypeElephino
+	DatatypeLeavesTotal: TypeAlias = TheDatatypeLeavesTotal
+
 	def _makePathFilename(self,
 			pathRoot: PurePosixPath | None = None,
 			logicalPathINFIX: str_nameDOTname | None = None,
@@ -225,13 +231,13 @@ class RecipeJob:
 	def __post_init__(self):
 		pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(self.state.mapShape))
 
-		if self.moduleIdentifier is None:
+		if self.moduleIdentifier is None: # type: ignore
 			self.moduleIdentifier = pathFilenameFoldsTotal.stem
 
-		if self.pathFilenameFoldsTotal is None:
+		if self.pathFilenameFoldsTotal is None: # type: ignore
 			self.pathFilenameFoldsTotal = pathFilenameFoldsTotal
 
-		if self.shatteredDataclass is None and self.logicalPathModuleDataclass and self.dataclassIdentifier and self.dataclassInstance:
+		if self.shatteredDataclass is None and self.logicalPathModuleDataclass and self.dataclassIdentifier and self.dataclassInstance: # type: ignore
 			self.shatteredDataclass = shatter_dataclassesDOTdataclass(self.logicalPathModuleDataclass, self.dataclassIdentifier, self.dataclassInstance)
 
 	# ========================================

mapFolding/someAssemblyRequired/transformationTools.py

@@ -219,14 +219,22 @@ class DeReConstructField2ast:
 
 		dtype = self.metadata.get('dtype', None)
 		if dtype:
+			moduleWithLogicalPath: str_nameDOTname = 'numpy'
+			annotation = 'ndarray'
+			self.ledger.addImportFrom_asStr(moduleWithLogicalPath, annotation)
 			constructor = 'array'
-			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, self.astAnnotation, Make.Call(Make.Name(constructor), list_astKeywords=[Make.keyword('dtype', Make.Name(dtype.__name__))]))
-			self.ledger.addImportFrom_asStr('numpy', constructor)
-			self.ledger.addImportFrom_asStr('numpy', dtype.__name__)
+			self.ledger.addImportFrom_asStr(moduleWithLogicalPath, constructor)
+			dtypeIdentifier: ast_Identifier = dtype.__name__
+			dtype_asnameName: ast.Name = self.astAnnotation
+			# dtypeIdentifier_asname: ast_Identifier = moduleWithLogicalPath + '_' + dtypeIdentifier
+			self.ledger.addImportFrom_asStr(moduleWithLogicalPath, dtypeIdentifier, dtype_asnameName.id)
+			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, Make.Name(annotation), Make.Call(Make.Name(constructor), list_astKeywords=[Make.keyword('dtype', dtype_asnameName)]))
+			# self.astAnnAssignConstructor = Make.AnnAssign(self.astName, Make.Name(annotation), Make.Call(Make.Name(constructor), list_astKeywords=[Make.keyword('dtype', Make.Name(dtypeIdentifier_asname))]))
+			# self.astAnnAssignConstructor = Make.AnnAssign(self.astName, self.astAnnotation, Make.Call(Make.Name(constructor), list_astKeywords=[Make.keyword('dtype', Make.Name(dtypeIdentifier_asname))]))
 			self.Z0Z_hack = (self.astAnnAssignConstructor, 'array')
 		elif be.Name(self.astAnnotation):
 			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, self.astAnnotation, Make.Call(self.astAnnotation, [Make.Constant(-1)]))
-			self.ledger.addImportFrom_asStr(dataclassesDOTdataclassLogicalPathModule, self.astAnnotation.id)
+			# self.ledger.addImportFrom_asStr(dataclassesDOTdataclassLogicalPathModule, self.astAnnotation.id)
 			self.Z0Z_hack = (self.astAnnAssignConstructor, 'scalar')
 		elif be.Subscript(self.astAnnotation):
 			elementConstructor: ast_Identifier = self.metadata['elementConstructor']
@@ -289,7 +297,7 @@ def write_astModule(ingredients: IngredientsModule, pathFilename: PathLike[Any]
 	autoflake_additional_imports: list[str] = ingredients.imports.exportListModuleIdentifiers()
 	if packageName:
 		autoflake_additional_imports.append(packageName)
-	pythonSource = autoflake_fix_code(pythonSource, autoflake_additional_imports, expand_star_imports=False, remove_all_unused_imports=False, remove_duplicate_keys = False, remove_unused_variables = False)
+	pythonSource = autoflake_fix_code(pythonSource, autoflake_additional_imports, expand_star_imports=False, remove_all_unused_imports=True, remove_duplicate_keys = False, remove_unused_variables = False)
 	writeStringToHere(pythonSource, pathFilename)
 
 # END of acceptable classes and functions ======================================================

mapFolding/syntheticModules/numbaCount_doTheNeedful.py

@@ -2,7 +2,6 @@ from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
 from copy import deepcopy
 from mapFolding.theSSOT import Array1DElephino, Array1DFoldsTotal, Array1DLeavesTotal, Array3D, ComputationState, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
 from numba import jit
-from numpy import array, int16, int64
 
 def countInitialize(state: ComputationState) -> ComputationState:
     while state.leaf1ndex > 0:

mapFolding/theSSOT.py

@@ -112,7 +112,6 @@ def getPackageDispatcher() -> Callable[['ComputationState'], 'ComputationState']
 	return The.dispatcher
 # =============================================================================
 # Flexible Data Structure System Needs Enhanced Paradigm https://github.com/hunterhogan/mapFolding/issues/9
-# Efficient translation of Python scalar types to Numba types https://github.com/hunterhogan/mapFolding/issues/8
 
 numpyIntegerType = TypeVar('numpyIntegerType', bound=integer[Any], covariant=True)
 

{mapfolding-0.8.5.dist-info → mapfolding-0.8.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.8.5
+Version: 0.8.6
 Summary: Map folding algorithm with code transformation framework for optimizing numerical computations
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0

{mapfolding-0.8.5.dist-info → mapfolding-0.8.6.dist-info}/RECORD

@@ -1,11 +1,10 @@
-mapFolding/__init__.py,sha256=LBgk-iW95pzqkFGY8PbcnU0oHy0AXwJGo18mM0g8wEw,2227
+mapFolding/__init__.py,sha256=7eMsgeEpydLE6-pY7Ycp397RSkhAA04chz1PojEcK0Q,2319
 mapFolding/basecamp.py,sha256=-__EJ2to84ssS4Fm0CAuQjRnghI9VA4cXZoWGYud1r0,4782
 mapFolding/beDRY.py,sha256=2GPO4A8XcxoEJXB_3sro4ZFQ5gcU7ywc1-c8HLEvEv0,15280
-mapFolding/noHomeYet.py,sha256=UKZeWlyn0SKlF9dhYoud7E6gWXpiSEekZOOoJp88WeI,1362
-mapFolding/oeis.py,sha256=EzEnbRi_4qt8Na2tiMcvL23FXpcJEkXTwuXDYDFH_XI,12631
+mapFolding/oeis.py,sha256=eorjDavo56uaeXIYVSXBH_ais4KKPEx4jpgBof1wcHw,13669
 mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mapFolding/theDao.py,sha256=MVopt1LzhdIQYA97SEoq9bdzct6hbK0lEyPxBAAlVTc,9934
-mapFolding/theSSOT.py,sha256=i3R_G702U7VQOil61ky60JGGsSEOk_x1555rg8yI0Tc,11978
+mapFolding/theSSOT.py,sha256=FvHOBCR-wysuhfmyyjfWQiojV87K4PBdsE8lNH-yCYY,11865
 mapFolding/toolboxFilesystem.py,sha256=WoqRjXqTXy5GYNmbfzWtzv1uufm7vYcgT4zJ9ffhRYY,9982
 mapFolding/reference/__init__.py,sha256=UIEU8BJR_YDzjFQcLel3XtHzOCJiOUGlGiWzOzbvhik,2206
 mapFolding/reference/flattened.py,sha256=QK1xG9SllqCoi68e86Hyl9d9ATUAAFNpTQI-3zmcp5I,16072
@@ -21,28 +20,28 @@ mapFolding/reference/jobsCompleted/[2x19]/p2x19.py,sha256=_tvYtfzMWVo2VtUbIAieos
 mapFolding/reference/jobsCompleted/p2x19/p2x19.py,sha256=eZEw4Me4ocTt6VXoK2-Sbd5SowZtxRIbN9dZmc7OCVg,6395
 mapFolding/someAssemblyRequired/__init__.py,sha256=c2GFI2HSId2_R_aoJWBID-P9AMF3zoHJzOc10XS6DHc,2669
 mapFolding/someAssemblyRequired/_theTypes.py,sha256=SG82WTtQy83BmInlHZHY8Nh3Kp161NcEFSA6-UU5wuE,4623
-mapFolding/someAssemblyRequired/_tool_Make.py,sha256=8ezrMDAdUY6m1raFp-G8vNXrHEr8IGfnZJ-aMVKzGf0,7092
+mapFolding/someAssemblyRequired/_tool_Make.py,sha256=txVsebv1-z5_HShO7vtc9lCdab-uJCBtC0YwR4hLk78,7132
 mapFolding/someAssemblyRequired/_tool_Then.py,sha256=QxuoBqj4iOeKWITjV3DcV8c25fLx3Q6mhUORD7-mCzc,2758
 mapFolding/someAssemblyRequired/_toolboxAntecedents.py,sha256=GEAuniYRj6yOtrJO_6sGZMzsVARdejts8NXhR_0np_c,21914
-mapFolding/someAssemblyRequired/_toolboxContainers.py,sha256=iPLZbFcGB6dKtX3WkopnM-2OtMcVuxXQT46iFhzpdfY,17815
+mapFolding/someAssemblyRequired/_toolboxContainers.py,sha256=UQGTlaV30TMTngNDQE6txDkEeGgwjPz5JLOwCdCc5O0,20732
 mapFolding/someAssemblyRequired/_toolboxPython.py,sha256=za30092eT00tj5ctqUCRrEuq5DGeJZN-vV9T4Dro-1w,3483
 mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=9RPU6vK_eUg64GtVFI_nZnvUryXw8gfHJs9NyDYHIvg,2745
 mapFolding/someAssemblyRequired/newInliner.py,sha256=Tm9PSzt66oIXPVrN9VdQwEYBba2iEOF5X3aEsOOF-FE,946
-mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=0L5ccqBusof6MzKatKnpUmFUNkAtbapzl_Fxmofi4DE,8684
-mapFolding/someAssemblyRequired/toolboxNumba.py,sha256=rluEmsSJOQCl2L6LlJzIc3AfeRxU6cp-sCf-rQFW-og,22613
-mapFolding/someAssemblyRequired/transformationTools.py,sha256=iIvRxSL45qTyl0d0ztHa9BP1MrOikfXE4HBqLlNMENc,20081
+mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=z9v61yaUyJt0sNuClB7-5UMEXwdOHGK8RSobi0cPEBI,10705
+mapFolding/someAssemblyRequired/toolboxNumba.py,sha256=ZCtckbHoeSbT1Kik5CcmAFwPX4Ay-4C-zRGOMVkc_fQ,22932
+mapFolding/someAssemblyRequired/transformationTools.py,sha256=NkH8eiBtlDEJK5PGB9k1vDGcEb0GgmyNQIB27GfKRqs,20866
 mapFolding/syntheticModules/__init__.py,sha256=evVFqhCGa-WZKDiLcnQWjs-Bj34eRnfSLqz_d7dFYZY,83
-mapFolding/syntheticModules/numbaCount_doTheNeedful.py,sha256=3thXThbv2Xo0t_cRGzMbHPFXTBmLClmKejR_Ibu_jOo,15697
-mapfolding-0.8.5.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+mapFolding/syntheticModules/numbaCount_doTheNeedful.py,sha256=vSqV1WbyZ0mXg2TNgMR9EndiitVKM8GQa72ijOUCEZ8,15659
+mapfolding-0.8.6.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/conftest.py,sha256=LfogHLu7PULSECwhLQgGCgqSvDMBc5b9RGWBls3YBrM,11364
-tests/test_computations.py,sha256=XjCej6M6lesfKB_ulWq3O-ryXBsJuuwnJ6_XjKOvgDY,3552
+tests/test_computations.py,sha256=UOES0LNiCdIIwmD4NawyW3RwfH2-OGh6AxHgeFFptVk,3547
 tests/test_filesystem.py,sha256=YEHNU6tUCTj9C65cKs3ETgt3OZTGVnNjxgu4aH6C9uU,3164
 tests/test_oeis.py,sha256=uxvwmgbnylSDdsVJfuAT0LuYLbIVFwSgdLxHm-xUGBM,5043
 tests/test_other.py,sha256=O05PFAK70Skf-k99Wcg4ASLpMpBH-WkELtk6MnynDx0,4293
-tests/test_tasks.py,sha256=S-6PNfM__Npw0zVojgzn5M-6ODBKDyRH5ccMTqQF9C4,2865
-mapfolding-0.8.5.dist-info/METADATA,sha256=vrusTb9uu8FQ3UksfFkVZ3txtYPNufYa3db-Rk6H1y0,9359
-mapfolding-0.8.5.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-mapfolding-0.8.5.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapfolding-0.8.5.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapfolding-0.8.5.dist-info/RECORD,,
+tests/test_tasks.py,sha256=q8YqFxVtI-fZ9qpklSlS04YAwfME2nivIrY-Y9jaGJI,2860
+mapfolding-0.8.6.dist-info/METADATA,sha256=u3cXT3ks2oQv2yLxXXstcJwyGU3bHGMWD5UME299C1Q,9359
+mapfolding-0.8.6.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+mapfolding-0.8.6.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapfolding-0.8.6.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapfolding-0.8.6.dist-info/RECORD,,

tests/test_computations.py

@@ -1,7 +1,7 @@
 from mapFolding.basecamp import countFolds
 from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal
 from mapFolding.beDRY import validateListDimensions
-from mapFolding.noHomeYet import getFoldsTotalKnown
+from mapFolding.oeis import getFoldsTotalKnown
 from mapFolding.oeis import settingsOEIS, oeisIDfor_n
 from mapFolding.someAssemblyRequired.transformationTools import makeInitializedComputationState
 from pathlib import Path, PurePosixPath

tests/test_tasks.py

@@ -1,7 +1,7 @@
 from collections.abc import Callable
 from mapFolding.basecamp import countFolds
 from mapFolding.beDRY import getTaskDivisions, setProcessorLimit, validateListDimensions, getLeavesTotal
-from mapFolding.noHomeYet import getFoldsTotalKnown
+from mapFolding.oeis import getFoldsTotalKnown
 from tests.conftest import standardizedEqualToCallableReturn
 from typing import Literal
 from Z0Z_tools.pytestForYourUse import PytestFor_defineConcurrencyLimit

mapFolding/noHomeYet.py

@@ -1,32 +0,0 @@
-"""
-Interface for retrieving known map folding totals from OEIS (Online Encyclopedia of Integer Sequences).
-
-This module provides utilities for accessing pre-computed map folding totals that are known
-from mathematical literature and stored in the OEIS. The functions cache results for
-performance and provide lookups based on map dimensions.
-
-The main functions are:
-- makeDictionaryFoldsTotalKnown: Creates a dictionary of known folding totals indexed by map dimensions
-- getFoldsTotalKnown: Retrieves the folding total for a specific map shape, returning -1 if unknown
-"""
-
-from functools import cache
-from mapFolding.oeis import settingsOEIS
-
-@cache
-def makeDictionaryFoldsTotalKnown() -> dict[tuple[int, ...], int]:
-	"""Returns a dictionary mapping dimension tuples to their known folding totals."""
-	dictionaryMapDimensionsToFoldsTotalKnown: dict[tuple[int, ...], int] = {}
-
-	for settings in settingsOEIS.values():
-		sequence = settings['valuesKnown']
-
-		for n, foldingsTotal in sequence.items():
-			mapShape = settings['getMapShape'](n)
-			mapShape = tuple(sorted(mapShape))
-			dictionaryMapDimensionsToFoldsTotalKnown[mapShape] = foldingsTotal
-	return dictionaryMapDimensionsToFoldsTotalKnown
-
-def getFoldsTotalKnown(mapShape: tuple[int, ...]) -> int:
-	lookupFoldsTotal = makeDictionaryFoldsTotalKnown()
-	return lookupFoldsTotal.get(tuple(mapShape), -1)