mapFolding 0.6.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

mapFolding/theSSOT.py

@@ -1,20 +1,264 @@
-from collections.abc import Callable
-from mapFolding.theSSOTdatatypes import *
-from numba.core.compiler import CompilerBase as numbaCompilerBase
-from numpy import dtype, integer, ndarray
+from importlib import import_module as importlib_import_module
+from inspect import getfile as inspect_getfile
+from numpy import dtype, int64 as numpy_int64, int16 as numpy_int16, ndarray, signedinteger
 from pathlib import Path
+from sys import modules as sysModules
+from tomli import load as tomli_load
 from types import ModuleType
-from typing import Any, Final, TYPE_CHECKING, cast
+from typing import Any, Final, TypeAlias
+import dataclasses
+
+"""
+2025 March 11
+Note to self: fundamental concept in Python:
+Identifiers: scope and resolution, LEGB (Local, Enclosing, Global, Builtin)
+- Local: Inside the function
+- Enclosing: Inside enclosing functions
+- Global: At the uppermost level
+- Builtin: Python's built-in names
+"""
+
+# I _think_, in theSSOT, I have abstracted the flow settings to only these couple of lines:
+packageFlowSynthetic = 'numba'
+Z0Z_packageFlow = 'algorithm'
+# Z0Z_packageFlow = packageFlowSynthetic
+
+# =============================================================================
+# The Wrong Way The Wrong Way The Wrong Way The Wrong Way The Wrong Way
+# Evaluate When Packaging Evaluate When Packaging Evaluate When Packaging
+
+sourceAlgorithmPACKAGING: str = 'theDao'
+datatypePackagePACKAGING: Final[str] = 'numpy'
+dispatcherCallableAsStrPACKAGING: str = 'doTheNeedful'
+moduleOfSyntheticModulesPACKAGING: Final[str] = 'syntheticModules'
+
+dataclassModuleAsStrPACKAGING: str = 'theSSOT'
+dataclassIdentifierAsStrPACKAGING: str = 'ComputationState'
+dataclassInstanceAsStrPACKAGING: str = 'state'
+dataclassInstance_Pre_ParallelAsStrPACKAGING = dataclassInstanceAsStrPACKAGING + 'PARALLEL'
+dataclassInstance_Post_ParallelAsStrPACKAGING = dataclassInstanceAsStrPACKAGING + 'COMPLETE'
+
+Z0Z_initializeCallableAsStrPACKAGING = 'countInitialize'
+Z0Z_sequentialCallableAsStrPACKAGING = 'countSequential'
+Z0Z_parallelCallableAsStrPACKAGING = 'countParallel'
 
 try:
-	from typing import NotRequired
+	thePackageNameIsPACKAGING: str = tomli_load(Path("../pyproject.toml").open('rb'))["project"]["name"]
 except Exception:
-	from typing_extensions import NotRequired # type: ignore
+	thePackageNameIsPACKAGING: str = "mapFolding"
+
+# =============================================================================
+# The Wrong Way The Wrong Way The Wrong Way The Wrong Way The Wrong Way
+# Evaluate When Installing Evaluate When Installing Evaluate When Installing
+
+fileExtensionINSTALLING: str = '.py'
+
+def getPathPackageINSTALLING() -> Path:
+	pathPackage: Path = Path(inspect_getfile(importlib_import_module(thePackageNameIsPACKAGING)))
+	if pathPackage.is_file():
+		pathPackage = pathPackage.parent
+	return pathPackage
+
+# =============================================================================
+# The Wrong Way The Wrong Way The Wrong Way The Wrong Way The Wrong Way
+# Hardcoding Hardcoding Hardcoding Hardcoding Hardcoding Hardcoding Hardcoding
+
+# =============================================================================
+# The right way, perhaps.
+
+# =====================
+# Create enduring identifiers from the hopefully transient identifiers above.
+thePackageName: Final[str] = thePackageNameIsPACKAGING
+thePathPackage: Path = getPathPackageINSTALLING()
+
+"""
+NOTE on semiotics: `theIdentifier` vs `identifier`
+
+- This package has a typical, "hardcoded" algorithm for counting map folds.
+- This package has logic for transforming that algorithm into other forms.
+- The transformation logic can transform other algorithms if 1) they are similar enough to the "hardcoded" algorithm and 2) I have written the transformation logic well enough to handle the differences.
+- To avoid confusion and namespace collisions, I differentiate between, for example, `theSourceAlgorithm` of the package and any other `sourceAlgorithm` being transformed by the package.
+"""
+
+theSourceAlgorithm: str = sourceAlgorithmPACKAGING
+theDatatypePackage: Final[str] = datatypePackagePACKAGING
+
+theDispatcherCallableAsStr: str = dispatcherCallableAsStrPACKAGING
+
+theDataclassModuleAsStr: str = dataclassModuleAsStrPACKAGING
+theDataclassIdentifierAsStr: str = dataclassIdentifierAsStrPACKAGING
+theDataclassInstanceAsStr: str = dataclassInstanceAsStrPACKAGING
+theDataclassInstance_Pre_ParallelAsStr: str = dataclassInstance_Pre_ParallelAsStrPACKAGING
+theDataclassInstance_Post_ParallelAsStr: str = dataclassInstance_Post_ParallelAsStrPACKAGING
+
+theFileExtension: str = fileExtensionINSTALLING
+
+theModuleOfSyntheticModules: Final[str] = moduleOfSyntheticModulesPACKAGING
+
+Z0Z_initializeCallableAsStr = Z0Z_initializeCallableAsStrPACKAGING
+Z0Z_sequentialCallableAsStr = Z0Z_sequentialCallableAsStrPACKAGING
+Z0Z_parallelCallableAsStr = Z0Z_parallelCallableAsStrPACKAGING
+
+# =============================================================================
+# The right way.
+concurrencyPackage: str = Z0Z_packageFlow
+
+# =============================================================================
+# The relatively flexible type system needs a different paradigm, but I don't
+# know what it should be. The system needs to 1) help optimize computation, 2)
+# make it possible to change the basic type of the package (e.g., from numpy
+# to superTypePy), 3) make it possible to synthesize the optimized flow of used
+# by the package, and 4) make it possible to synthesize arbitrary modules with
+# different type systems.
+
+DatatypeLeavesTotal: TypeAlias = int
+# this would be uint8, but mapShape (2,2,2,2, 2,2,2,2) has 256 leaves, so generic containers accommodate
+numpyLeavesTotal: TypeAlias = numpy_int16
+
+DatatypeElephino: TypeAlias = int
+numpyElephino: TypeAlias = numpy_int16
+
+DatatypeFoldsTotal: TypeAlias = int
+numpyFoldsTotal: TypeAlias = numpy_int64
+numpyDtypeDefault = numpyFoldsTotal
+
+Array3D: TypeAlias = ndarray[tuple[int, int, int], dtype[numpyLeavesTotal]]
+Array1DLeavesTotal: TypeAlias = ndarray[tuple[int], dtype[numpyLeavesTotal]]
+Array1DElephino: TypeAlias = ndarray[tuple[int], dtype[numpyElephino]]
+Array1DFoldsTotal: TypeAlias = ndarray[tuple[int], dtype[numpyFoldsTotal]]
+
+# =============================================================================
+# The right way.
+# (The dataclass, not the typing of the dataclass.)
+# (Also, my noobplementation of the dataclass certainly needs improvement.)
+
+@dataclasses.dataclass
+class ComputationState:
+	mapShape: tuple[DatatypeLeavesTotal, ...]
+	leavesTotal: DatatypeLeavesTotal
+	taskDivisions: DatatypeLeavesTotal
 
-if TYPE_CHECKING:
-	from typing import TypedDict
-else:
-	TypedDict = dict
+	connectionGraph: Array3D = dataclasses.field(init=False, metadata={'description': 'A 3D array representing the connection graph of the map.'})
+	dimensionsTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
+
+	countDimensionsGapped: Array1DLeavesTotal = dataclasses.field(default=None) # pyright: ignore[reportAssignmentType]
+	dimensionsUnconstrained: DatatypeLeavesTotal = dataclasses.field(default=None) # pyright: ignore[reportAssignmentType]
+	gapRangeStart: Array1DElephino = dataclasses.field(default=None) # pyright: ignore[reportAssignmentType]
+	gapsWhere: Array1DLeavesTotal = dataclasses.field(default=None) # pyright: ignore[reportAssignmentType]
+	leafAbove: Array1DLeavesTotal = dataclasses.field(default=None) # pyright: ignore[reportAssignmentType]
+	leafBelow: Array1DLeavesTotal = dataclasses.field(default=None) # pyright: ignore[reportAssignmentType]
+	foldGroups: Array1DFoldsTotal = dataclasses.field(default=None) # pyright: ignore[reportAssignmentType]
+
+	foldsTotal: DatatypeFoldsTotal = DatatypeFoldsTotal(0)
+	gap1ndex: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+	gap1ndexCeiling: DatatypeElephino = DatatypeElephino(0)
+	groupsOfFolds: DatatypeFoldsTotal = DatatypeFoldsTotal(0)
+	indexDimension: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+	indexLeaf: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+	indexMiniGap: DatatypeElephino = DatatypeElephino(0)
+	leaf1ndex: DatatypeElephino = DatatypeElephino(1)
+	leafConnectee: DatatypeElephino = DatatypeElephino(0)
+	taskIndex: DatatypeLeavesTotal = dataclasses.field(default=DatatypeLeavesTotal(0), metadata={'myType': DatatypeLeavesTotal})
+	# taskIndex: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+
+	def __post_init__(self):
+		from mapFolding.beDRY import makeConnectionGraph, makeDataContainer
+		self.dimensionsTotal = DatatypeLeavesTotal(len(self.mapShape))
+		self.connectionGraph = makeConnectionGraph(self.mapShape, self.leavesTotal, numpyLeavesTotal)
+
+		if self.dimensionsUnconstrained is None: # pyright: ignore[reportUnnecessaryComparison]
+			self.dimensionsUnconstrained = DatatypeLeavesTotal(int(self.dimensionsTotal))
+
+		if self.foldGroups is None:
+			self.foldGroups = makeDataContainer(max(2, int(self.taskDivisions) + 1), numpyFoldsTotal)
+			self.foldGroups[-1] = self.leavesTotal
+
+		leavesTotalAsInt = int(self.leavesTotal)
+
+		if self.countDimensionsGapped is None:
+			self.countDimensionsGapped = makeDataContainer(leavesTotalAsInt + 1, numpyElephino)
+		if self.gapRangeStart is None:
+			self.gapRangeStart = makeDataContainer(leavesTotalAsInt + 1, numpyLeavesTotal)
+		if self.gapsWhere is None:
+			self.gapsWhere = makeDataContainer(leavesTotalAsInt * leavesTotalAsInt + 1, numpyLeavesTotal)
+		if self.leafAbove is None:
+			self.leafAbove = makeDataContainer(leavesTotalAsInt + 1, numpyLeavesTotal)
+		if self.leafBelow is None:
+			self.leafBelow = makeDataContainer(leavesTotalAsInt + 1, numpyLeavesTotal)
+
+	def getFoldsTotal(self):
+		self.foldsTotal = DatatypeFoldsTotal(self.foldGroups[0:-1].sum() * self.leavesTotal)
+
+	# factory? constructor?
+	# state.taskIndex = state.taskIndex.type(indexSherpa)
+	# self.fieldName = self.fieldName.fieldType(indexSherpa)
+	# state.taskIndex.toMyType(indexSherpa)
+
+# =============================================================================
+# The most right way I know how to implement.
+
+theLogicalPathModuleSourceAlgorithm: str = '.'.join([thePackageName, theSourceAlgorithm])
+theLogicalPathModuleDispatcher: str = theLogicalPathModuleSourceAlgorithm
+theLogicalPathModuleDataclass: str = '.'.join([thePackageName, theDataclassModuleAsStr])
+
+def getSourceAlgorithm() -> ModuleType:
+	moduleImported: ModuleType = importlib_import_module(theLogicalPathModuleSourceAlgorithm)
+	return moduleImported
+
+def getAlgorithmDispatcher():
+	moduleImported: ModuleType = getSourceAlgorithm()
+	# TODO I think I need to use `inspect` to type the return value
+	dispatcherCallable = getattr(moduleImported, theDispatcherCallableAsStr)
+	return dispatcherCallable
+
+def getPathSyntheticModules() -> Path:
+	return thePathPackage / theModuleOfSyntheticModules
+
+# TODO learn how to see this from the user's perspective
+def getPathJobRootDEFAULT() -> Path:
+	if 'google.colab' in sysModules:
+		pathJobDEFAULT: Path = Path("/content/drive/MyDrive") / "jobs"
+	else:
+		pathJobDEFAULT = thePathPackage / "jobs"
+	return pathJobDEFAULT
+
+_datatypePackage: str = ''
+def getDatatypePackage() -> str:
+	global _datatypePackage
+	if not _datatypePackage:
+		_datatypePackage = theDatatypePackage
+	return _datatypePackage
+
+def getNumpyDtypeDefault() -> type[signedinteger[Any]]:
+	return numpyDtypeDefault
+
+# =============================================================================
+# The coping way.
+
+class FREAKOUT(Exception): pass
+
+# =============================================================================
+# Temporary or transient or something; probably still the wrong way
+
+# THIS IS A STUPID SYSTEM BUT I CAN'T FIGURE OUT AN IMPROVEMENT
+theFormatStrModuleSynthetic = "{packageFlow}Count"
+theFormatStrModuleForCallableSynthetic = theFormatStrModuleSynthetic + "_{callableTarget}"
+
+theModuleDispatcherSynthetic: str = theFormatStrModuleForCallableSynthetic.format(packageFlow=packageFlowSynthetic, callableTarget=theDispatcherCallableAsStr)
+theLogicalPathModuleDispatcherSynthetic: str = '.'.join([thePackageName, theModuleOfSyntheticModules, theModuleDispatcherSynthetic])
+
+# =============================================================================
+# The most right way I know how to implement.
+
+if Z0Z_packageFlow == packageFlowSynthetic: # pyright: ignore [reportUnnecessaryComparison]
+	theLogicalPathModuleDispatcher = theLogicalPathModuleDispatcherSynthetic
+
+def getPackageDispatcher():
+	moduleImported: ModuleType = importlib_import_module(theLogicalPathModuleDispatcher)
+	dispatcherCallable = getattr(moduleImported, theDispatcherCallableAsStr)
+	from mapFolding.syntheticModules.numbaCountSequential import flattenData
+	dispatcherCallable = flattenData
+	return dispatcherCallable
 
 """Technical concepts I am likely using and likely want to use more effectively:
 - Configuration Registry
@@ -27,94 +271,3 @@ theSSOT and yourSSOT
 delay realization/instantiation until a concrete value is desired
 moment of truth: when the value is needed, not when the value is defined
 """
-
-"""
-listDimensions: list[int]
-mapShape
-tupleDimensions: tuple[int, ...]
-dimensionsTuple
-dimensionTuple
-"""
-
-def getPathSyntheticModules() -> Path:
-	return pathPackage / moduleOfSyntheticModules
-
-def getAlgorithmDispatcher() -> Callable[..., None]:
-	algorithmSource: ModuleType = getAlgorithmSource()
-	return cast(Callable[..., None], algorithmSource.doTheNeedful) # 'doTheNeedful' is duplicated and there is not a SSOT for it
-
-# NOTE I want this _concept_, not necessarily this method, to be well implemented and usable everywhere: Python, Numba, Jax, CUDA, idc
-class computationState(TypedDict):
-	connectionGraph:	ndarray[tuple[int, int, int], dtype[integer[Any]]]
-	foldGroups:			ndarray[tuple[int]			, dtype[integer[Any]]]
-	gapsWhere:			ndarray[tuple[int]			, dtype[integer[Any]]]
-	mapShape:			ndarray[tuple[int]			, dtype[integer[Any]]]
-	my:					ndarray[tuple[int]			, dtype[integer[Any]]]
-	track:				ndarray[tuple[int, int]		, dtype[integer[Any]]]
-
-_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
-
-# The following identifier is declared in theDao.py.
-# TODO Learn how to assign theDao.py the power to set this truth
-# while using theSSOT.py as the SSOT.
-Z0Z_identifierCountFolds = 'groupsOfFolds'
-
-class ParametersNumba(TypedDict):
-	_dbg_extend_lifetimes: NotRequired[bool]
-	_dbg_optnone: NotRequired[bool]
-	_nrt: NotRequired[bool]
-	boundscheck: NotRequired[bool]
-	cache: bool
-	debug: NotRequired[bool]
-	error_model: str
-	fastmath: bool
-	forceinline: bool
-	forceobj: NotRequired[bool]
-	inline: str
-	locals: NotRequired[dict[str, Any]]
-	looplift: bool
-	no_cfunc_wrapper: bool
-	no_cpython_wrapper: bool
-	no_rewrites: NotRequired[bool]
-	nogil: NotRequired[bool]
-	nopython: bool
-	parallel: bool
-	pipeline_class: NotRequired[type[numbaCompilerBase]]
-	signature_or_function: NotRequired[Any | Callable[..., Any] | str | tuple[Any, ...]]
-	target: NotRequired[str]
-
-parametersNumbaFailEarly: Final[ParametersNumba] = { '_nrt': True, 'boundscheck': True, 'cache': True, 'error_model': 'python', 'fastmath': False, 'forceinline': True, 'inline': 'always', 'looplift': False, 'no_cfunc_wrapper': False, 'no_cpython_wrapper': False, 'nopython': True, 'parallel': False, }
-"""For a production function: speed is irrelevant, error discovery is paramount, must be compatible with anything downstream."""
-
-parametersNumbaDEFAULT: Final[ParametersNumba] = { '_nrt': True, 'boundscheck': False, 'cache': True, 'error_model': 'numpy', 'fastmath': True, 'forceinline': True, 'inline': 'always', 'looplift': False, 'no_cfunc_wrapper': False, 'no_cpython_wrapper': False, 'nopython': True, 'parallel': False, }
-"""Middle of the road: fast, lean, but will talk to non-jitted functions."""
-
-parametersNumbaParallelDEFAULT: Final[ParametersNumba] = { **parametersNumbaDEFAULT, '_nrt': True, 'parallel': True, }
-"""Middle of the road: fast, lean, but will talk to non-jitted functions."""
-
-parametersNumbaSuperJit: Final[ParametersNumba] = { **parametersNumbaDEFAULT, 'no_cfunc_wrapper': True, 'no_cpython_wrapper': True, }
-"""Speed, no helmet, no talking to non-jitted functions."""
-
-parametersNumbaSuperJitParallel: Final[ParametersNumba] = { **parametersNumbaSuperJit, '_nrt': True, 'parallel': True, }
-"""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, }

{mapfolding-0.6.0.dist-info → mapfolding-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.6.0
+Version: 0.7.0
 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
@@ -8,7 +8,7 @@ Project-URL: Donate, https://www.patreon.com/integrated
 Project-URL: Homepage, https://github.com/hunterhogan/mapFolding
 Project-URL: Repository, https://github.com/hunterhogan/mapFolding.git
 Keywords: A001415,A001416,A001417,A001418,A195646,combinatorics,folding,map folding,OEIS,optimization,stamp folding
-Classifier: Development Status :: 5 - Production/Stable
+Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Education
 Classifier: Intended Audience :: End Users/Desktop
@@ -28,19 +28,20 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: autoflake
+Requires-Dist: more_itertools
+Requires-Dist: numba_progress
 Requires-Dist: numba
 Requires-Dist: numpy
+Requires-Dist: python_minifier
+Requires-Dist: tomli
 Requires-Dist: Z0Z_tools
 Provides-Extra: testing
-Requires-Dist: autoflake; extra == "testing"
 Requires-Dist: mypy; extra == "testing"
-Requires-Dist: more_itertools; extra == "testing"
-Requires-Dist: numba_progress; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: pytest-env; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
-Requires-Dist: python_minifier; extra == "testing"
 Requires-Dist: pyupgrade; extra == "testing"
 Requires-Dist: updateCitation; extra == "testing"
 

mapfolding-0.7.0.dist-info/RECORD

@@ -0,0 +1,50 @@
+mapFolding/__init__.py,sha256=dg1pzBxbhIY8FRtS2uphqL7YwUwR5uxZ5epduKhl3Y8,189
+mapFolding/basecamp.py,sha256=H-cZeoDhKftRwZu1Q_Xo66lCweVEtB0ChqJY_GNEfdI,3835
+mapFolding/beDRY.py,sha256=WsXAPbjFfjO0bVFq8GGbEdEP9lmrYTaZxzIWpO9s3ok,8209
+mapFolding/filesystem.py,sha256=TfvvIXnlLU6NNZrrY9T9Wk9cIGksvDjeI-JgsKHdsLY,3767
+mapFolding/noHomeYet.py,sha256=HjxLP-7BGVkKL66T50q4BWnC0Cg2gHUeCKMFuwR2mEQ,785
+mapFolding/oeis.py,sha256=xqnL_VyhwRBET-Kdpnf59K5W5metGbW0JiufTlVw7g0,11853
+mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/theDao.py,sha256=Bcd-VmZfarxdsdyFh40XdURrMPjV2QIO0WoMJ6AS6hw,8054
+mapFolding/theSSOT.py,sha256=1-trVx4JHT2twT5gmKY5cCdZ2gLSKjScMBzE9QiyIXo,12594
+mapFolding/reference/flattened.py,sha256=S6D9wiFTlbeoetEqaMLOcA-R22BHOzjqPRujffNxxUM,14875
+mapFolding/reference/hunterNumba.py,sha256=jDS0ORHkIhcJ1rzA5hT49sZHKf3rgJOoGesUCcbKFFY,6054
+mapFolding/reference/irvineJavaPort.py,sha256=7GvBU0tnS6wpFgkYad3465do9jBQW-2bYvbCYyABPHM,3341
+mapFolding/reference/jax.py,sha256=7ji9YWia6Kof0cjcNdiS1GG1rMbC5SBjcyVr_07AeUk,13845
+mapFolding/reference/lunnan.py,sha256=iAbJELfW6RKNMdPcBY9b6rGQ-z1zoRf-1XCurCRMOo8,3951
+mapFolding/reference/lunnanNumpy.py,sha256=rwVP3WIDXimpAuaxhRIuBYU56nVDTKlfGiclw_FkgUU,3765
+mapFolding/reference/lunnanWhile.py,sha256=uRrMT23jTJvoQDlD_FzeIQe_pfMXJG6_bRvs7uhC8z0,3271
+mapFolding/reference/rotatedEntryPoint.py,sha256=USZY3n3zwhSE68ATscUuN66t1qShuEbMI790Gz9JFTw,9352
+mapFolding/reference/total_countPlus1vsPlusN.py,sha256=wpgay-uqPOBd64Z4Pg6tg40j7-4pzWHGMM6v0bnmjhE,6288
+mapFolding/someAssemblyRequired/Z0Z_workbench.py,sha256=wkTqYlzi-okXloPCg4IHpThq97vuyCzrLSn1wsF6-_0,1627
+mapFolding/someAssemblyRequired/__init__.py,sha256=pYkG-1LM8emzTeQbGtOfiZsAiklm5DU92-WE63qB-9s,602
+mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=sGDzg5HG21Q42M0upRD1NWzOUsd7mZ_9wUKJIQHI13o,1000
+mapFolding/someAssemblyRequired/ingredientsNumba.py,sha256=HnWgo1KwIoevUrE5A1WZh4AVFXKQllt8L6RL46JTXEg,2787
+mapFolding/someAssemblyRequired/synthesizeCountingFunctions.py,sha256=77iNPPsN8BmwHaYKdXcDKCwoZKS1g41CJNenQB0W-eg,252
+mapFolding/someAssemblyRequired/synthesizeDataConverters.py,sha256=qNedUaXxU107x3OBx1AHcSEQPM3bMe5ym-GfpJ9O0bc,6237
+mapFolding/someAssemblyRequired/synthesizeNumba.py,sha256=cKXvp0BxmYayUBMQ2RJLkVoJUSvzPI1S4Wy_APRM5cI,4788
+mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=w7zLUzLrLXf2N6O75jKvXDoyTJemWB8GOdK4ryqSWbs,22700
+mapFolding/someAssemblyRequired/synthesizeNumbaModules.py,sha256=zUclYPmAr6X5qFO3nQK1_HHqdiRq6j3EIBXjeax_b8c,4388
+mapFolding/someAssemblyRequired/transformationTools.py,sha256=FwaZlwMnfzoGvtax5GQSjkyBWr5atMo2VFxPHaBwuNA,21019
+mapFolding/someAssemblyRequired/whatWillBe.py,sha256=ue_NsFN3Z6IxlTgVOaikG8GCiXz9Dk1dvNlypOWMcG0,12188
+mapFolding/syntheticModules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/syntheticModules/dataNamespaceFlattened.py,sha256=vsU4PDEMoEcZ424AzsXOJoXoVlX_bSk-pXSTlDsSN9k,2939
+mapFolding/syntheticModules/numbaCount.py,sha256=znFV9RhZ0WqPA-r-DT92WDgZXUyhdQlrsKmnsGySuKc,4561
+mapFolding/syntheticModules/numbaCountExample.py,sha256=Oo0Xeex89sLD15iRt3N76OKRFScKl9qwO84-d5sv6lM,11871
+mapFolding/syntheticModules/numbaCountSequential.py,sha256=iJ-IyzXv0c41uugceJGIHutdzJpkhqbTj0ic_3DqHEM,4326
+mapFolding/syntheticModules/numbaCount_doTheNeedful.py,sha256=J9wZ9PW5EVduOQWVze7CgpTHkUjRIvBPG8fNuT3IVpA,1145
+mapFolding/syntheticModules/numba_doTheNeedful.py,sha256=8kgV2GGjy_nxVi9o_aAtrZzRSxsYr8HVNsVXesf4Kec,767
+mapFolding/syntheticModules/numba_doTheNeedfulExample.py,sha256=J9wZ9PW5EVduOQWVze7CgpTHkUjRIvBPG8fNuT3IVpA,1145
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/conftest.py,sha256=oPc1IS4RXhLQIBskhuawi4GEWhy6kXbM6D2MdX9kDhw,10833
+tests/test_computations.py,sha256=s4ce78iEa9axlknR83NqwXwluX8Z5HN1GtTJ3RyXuzQ,3240
+tests/test_filesystem.py,sha256=7Ova6f4R6lI9rwnnu8SkZgficTYlKEhSzLp-nBRWESM,3183
+tests/test_oeis.py,sha256=uxvwmgbnylSDdsVJfuAT0LuYLbIVFwSgdLxHm-xUGBM,5043
+tests/test_other.py,sha256=CS64h5NACYmXhG3owBpPDcXv3BpYlXNeLqPcqT4quwg,4303
+tests/test_tasks.py,sha256=nsrNuGYk49EnTUslZIQTgqEONwuCSlQaPCpoQTkE08k,2849
+mapfolding-0.7.0.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+mapfolding-0.7.0.dist-info/METADATA,sha256=xR40gKDQ001BELktPxoyqtsdz7b6zFVmqdU8zV2qoRg,7696
+mapfolding-0.7.0.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+mapfolding-0.7.0.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapfolding-0.7.0.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapfolding-0.7.0.dist-info/RECORD,,

{mapfolding-0.6.0.dist-info → mapfolding-0.7.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{mapfolding-0.6.0.dist-info → mapfolding-0.7.0.dist-info}/top_level.txt

@@ -1 +1,2 @@
 mapFolding
+tests