mapFolding 0.17.1__py3-none-any.whl → 0.18.0__py3-none-any.whl

mapFolding/someAssemblyRequired/RecipeJob.py

@@ -3,7 +3,7 @@
 from astToolkit import identifierDotAttribute, parseLogicalPath2astModule
 from astToolkit.containers import IngredientsFunction, IngredientsModule, LedgerOfImports
 from astToolkit.transformationTools import pythonCode2ast_expr
-from hunterMakesPy import autoDecodingRLE
+from hunterMakesPy.dataStructures import autoDecodingRLE
 # TODO 'The____' identifiers are a vestigial semiotic system. Do I still need to import `asname`? If so, would different
 # identifiers better integrate into the current semiotics?
 from mapFolding import (
@@ -84,7 +84,7 @@ class RecipeJobTheorem2:
 	shatteredDataclass: ShatteredDataclass = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
 	"""Deconstructed dataclass metadata for code transformation."""
 
-# ------- Source -----------------------------------------
+#-------- Source -----------------------------------------
 	source_astModule: ast.Module = parseLogicalPath2astModule(f'{packageSettings.identifierPackage}.{default['logicalPath']['synthetic']}.theorem2Numba')  # noqa: RUF009
 	"""Parsed AST of the source module containing the generic algorithm."""
 	identifierCallableSource: str = default['function']['counting']
@@ -102,7 +102,7 @@ class RecipeJobTheorem2:
 	sourcePackageIdentifier: str | None = packageSettings.identifierPackage
 	"""Name of the source package."""
 
-# ------- Filesystem, names of physical objects ------------------------------------------
+#-------- Filesystem, names of physical objects ------------------------------------------
 	pathPackage: PurePosixPath | None = None
 	"""Override path for the target package."""
 	pathModule: PurePosixPath | None = PurePosixPath(getPathRootJobDEFAULT())  # noqa: RUF009
@@ -112,7 +112,7 @@ class RecipeJobTheorem2:
 	pathFilenameFoldsTotal: PurePosixPath = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
 	"""Path for writing fold count results."""
 
-# ------- Logical identifiers, as opposed to physical identifiers ------------------------
+#-------- Logical identifiers, as opposed to physical identifiers ------------------------
 	packageIdentifier: str | None = None
 	"""Target package identifier."""
 	logicalPathRoot: identifierDotAttribute | None = None
@@ -128,7 +128,7 @@ class RecipeJobTheorem2:
 	logicalPathModuleDataclass: identifierDotAttribute | None = sourceLogicalPathModuleDataclass
 	"""Logical path to target dataclass module."""
 
-# ------- Datatypes ------------------------------------------
+#-------- Datatypes ------------------------------------------
 	type DatatypeFoldsTotal = TheDatatypeFoldsTotal
 	"""Type alias for datatype linked to the magnitude of `foldsTotal`."""
 	type DatatypeElephino = TheDatatypeElephino

mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py

@@ -10,7 +10,7 @@ progress integration for long-running calculations, and launcher generation for
 
 from astToolkit import Be, Make, NodeChanger, NodeTourist, parseLogicalPath2astModule, Then
 from astToolkit.containers import astModuleToIngredientsFunction, IngredientsFunction, IngredientsModule
-from hunterMakesPy import autoDecodingRLE, identifierDotAttribute
+from hunterMakesPy.dataStructures import autoDecodingRLE
 from mapFolding import (
 	DatatypeLeavesTotal, dictionaryOEIS, getFoldsTotalKnown, getPathFilenameFoldsTotal, packageSettings)
 from mapFolding.dataBaskets import MapFoldingState, SymmetricFoldsState
@@ -19,9 +19,12 @@ from mapFolding.someAssemblyRequired.RecipeJob import customizeDatatypeViaImport
 from mapFolding.someAssemblyRequired.toolkitNumba import decorateCallableWithNumba, parametersNumbaLight, SpicesJobNumba
 from mapFolding.someAssemblyRequired.transformationTools import shatter_dataclassesDOTdataclass
 from pathlib import PurePosixPath
-from typing import cast
+from typing import cast, TYPE_CHECKING
 import ast
 
+if TYPE_CHECKING:
+	from hunterMakesPy import identifierDotAttribute
+
 # TODO More convergence with `makeJobTheorem2codon`
 
 # TODO Dynamically calculate the bitwidth of each datatype. NOTE I've delayed dynamic calculation because I don't know how to

mapFolding/someAssemblyRequired/makeJobTheorem2codon.py

@@ -7,6 +7,7 @@ from astToolkit import (
 from astToolkit.containers import IngredientsFunction, IngredientsModule
 from astToolkit.transformationTools import removeUnusedParameters, write_astModule
 from hunterMakesPy import raiseIfNone
+from io import TextIOBase
 from mapFolding import DatatypeLeavesTotal, getPathFilenameFoldsTotal, packageSettings
 from mapFolding.dataBaskets import MapFoldingState
 from mapFolding.someAssemblyRequired import DatatypeConfiguration, default, IfThis
@@ -14,14 +15,11 @@ from mapFolding.someAssemblyRequired.RecipeJob import (
 	customizeDatatypeViaImport, moveShatteredDataclass_arg2body, RecipeJobTheorem2)
 from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
 from pathlib import Path, PurePosixPath
-from typing import cast, TYPE_CHECKING
+from typing import cast
+import ast
 import subprocess
 import sys
 
-if TYPE_CHECKING:
-	from io import TextIOBase
-	import ast
-
 # TODO Converge with `makeJobTheorem2Numba`.
 
 listDatatypeConfigurations: list[DatatypeConfiguration] = [
@@ -73,8 +71,8 @@ def _variableCompatibility(ingredientsFunction: IngredientsFunction, job: Recipe
 		identifier: str = ast_arg.arg
 		annotation: ast.expr = raiseIfNone(ast_arg.annotation)
 
-	# ------- `identifier` is target of Augmented Assignment, or --------------
-	# ------- `identifier` is target of Assignment and value is Constant. -----
+	#-------- `identifier` is target of Augmented Assignment, or --------------
+	#-------- `identifier` is target of Assignment and value is Constant. -----
 		NodeChanger(
 			IfThis.isAnyOf(
 							Be.AugAssign.targetIs(IfThis.isNestedNameIdentifier(identifier))
@@ -84,23 +82,23 @@ def _variableCompatibility(ingredientsFunction: IngredientsFunction, job: Recipe
 			, doThat=lambda node, annotation=annotation: Grab.valueAttribute(Then.replaceWith(Make.Call(annotation, listParameters=[node.value])))(node)
 		).visit(ingredientsFunction.astFunctionDef)
 
-	# ------- `identifier` - 1. ----------------------------------------------
+	#-------- `identifier` - 1. ----------------------------------------------
 		NodeChanger(Be.BinOp.leftIs(IfThis.isNestedNameIdentifier(identifier))
 			, doThat=lambda node, annotation=annotation: Grab.rightAttribute(Then.replaceWith(Make.Call(annotation, listParameters=[node.right])))(node)
 		).visit(ingredientsFunction.astFunctionDef)
 
-	# ------- `identifier` in Comparison. -------------------------------------
+	#-------- `identifier` in Comparison. -------------------------------------
 		NodeChanger(Be.Compare.leftIs(IfThis.isNestedNameIdentifier(identifier))
 			, doThat=lambda node, annotation=annotation: Grab.comparatorsAttribute(lambda at, annotation=annotation: Then.replaceWith([Make.Call(annotation, listParameters=[node.comparators[0]])])(at[0]))(node)
 		).visit(ingredientsFunction.astFunctionDef)
 
-	# ------- `identifier` has exactly one index value. -----------------------
+	#-------- `identifier` has exactly one index value. -----------------------
 		NodeChanger(IfThis.isAllOf(Be.Subscript.valueIs(IfThis.isNestedNameIdentifier(identifier))
 			, lambda node: not Be.Subscript.sliceIs(Be.Tuple)(node))
 			, doThat=lambda node: Grab.sliceAttribute(Then.replaceWith(Make.Call(Make.Name('int'), listParameters=[node.slice])))(node)
 		).visit(ingredientsFunction.astFunctionDef)
 
-	# ------- `identifier` has multiple index values. -------------------------
+	#-------- `identifier` has multiple index values. -------------------------
 		NodeChanger(IfThis.isAllOf(Be.Subscript.valueIs(IfThis.isNestedNameIdentifier(identifier))
 								,  Be.Subscript.sliceIs(Be.Tuple))
 			, doThat=lambda node: Grab.sliceAttribute(Grab.eltsAttribute(

mapFolding/someAssemblyRequired/mapFoldingModules/makeMapFoldingModules.py

@@ -5,7 +5,8 @@ from astToolkit import (
 from astToolkit.containers import (
 	astModuleToIngredientsFunction, IngredientsFunction, IngredientsModule, LedgerOfImports)
 from astToolkit.transformationTools import inlineFunctionDef, removeUnusedParameters, write_astModule
-from hunterMakesPy import importLogicalPath2Identifier, raiseIfNone
+from hunterMakesPy import raiseIfNone
+from hunterMakesPy.filesystemToolkit import importLogicalPath2Identifier
 from mapFolding import packageSettings
 from mapFolding.someAssemblyRequired import default, DeReConstructField2ast, IfThis, ShatteredDataclass
 from mapFolding.someAssemblyRequired.makingModules_count import (

mapFolding/someAssemblyRequired/transformationTools.py

@@ -28,7 +28,7 @@ through specialized compilation paths essential for computationally intensive ma
 from astToolkit import Be, extractClassDef, identifierDotAttribute, Make, NodeChanger, parseLogicalPath2astModule, Then
 from astToolkit.containers import IngredientsFunction
 from astToolkit.transformationTools import unparseFindReplace
-from hunterMakesPy import importLogicalPath2Identifier
+from hunterMakesPy.filesystemToolkit import importLogicalPath2Identifier
 from mapFolding.someAssemblyRequired import DeReConstructField2ast, IfThis, ShatteredDataclass
 import ast
 import dataclasses

mapFolding/tests/Z0Z_test_e_excluder.py

@@ -0,0 +1,155 @@
+"""Tests for the excluder system and analysis tools.
+
+This module tests the functionality of the excluder system, including:
+1.  The logic for excluding leaves based on pinned piles (`_Z0Z_excludeThisLeaf`, `Z0Z_excluder`).
+2.  The generation and analysis of exclusion data (`theExcluderBeast.py`).
+3.  The transformation of indices to fraction/addend representations.
+
+The tests use `pytest` fixtures and parametrization to ensure flexibility and coverage.
+"""
+
+from fractions import Fraction
+from mapFolding._e.dataBaskets import EliminationState
+from mapFolding._e.pin2上nDimensionsAnnex import Z0Z_excluder
+from mapFolding._e.Z0Z_analysisPython import theExcluderBeast
+from mapFolding._e.Z0Z_analysisPython.theExcluderBeast import (
+	_getContiguousEndingAtNegativeOne, _getContiguousFromStart, expressIndexAsFractionAddend, FractionAddend,
+	writeAggregatedExclusions, writeExclusionDataCollated, writeExclusionDictionaries)
+from pathlib import Path, PurePath
+from typing import Any
+from unittest.mock import MagicMock, patch
+import pandas
+import pytest
+
+#======== Logic Tests (Adapted from test_excluder_logic.py) =======
+
+@pytest.mark.parametrize("dimensionsTotal, pileLast, permutationSpace, expectedResult", [
+	(6, 99, {7: 4, 12: 36}, True),
+], ids=["2d6_pileLast99_pinned7_4_12_36"])
+def test_Z0Z_excluder(dimensionsTotal: int, pileLast: int, permutationSpace: dict[int, int], expectedResult: bool, monkeypatch: pytest.MonkeyPatch) -> None:
+	"""Verify Z0Z_excluder correctly identifies invalid states."""
+	state = MagicMock(spec=EliminationState)
+	state.dimensionsTotal = dimensionsTotal
+	state.pileLast = pileLast
+	state.permutationSpace = permutationSpace
+
+	stubLookup: dict[int, dict[int, dict[int, list[int]]]] = {
+		7: {
+			4: {
+				12: [36]
+			}
+		}
+	}
+	monkeypatch.setattr("mapFolding._e.pin2上nDimensionsAnnex.dictionary2d6AtPileLeafExcludedByPile", stubLookup)
+
+	result = Z0Z_excluder(state)
+	assert result == expectedResult
+
+#======== Transformation Tests =======
+
+@pytest.mark.parametrize("index, pilesTotal, denominators, expected", [
+	(0, 10, (), (Fraction(0, 1), 0)),
+	(5, 10, (2,), (Fraction(1, 2), 0)),
+	(-1, 10, (), (Fraction(0, 1), -1)),
+], ids=["index=0", "index=5", "index=-1"])
+def test_expressIndexAsFractionAddend(index: int, pilesTotal: int, denominators: tuple[int, ...], expected: FractionAddend) -> None:
+	"""Verify index to fraction/addend conversion."""
+	assert expressIndexAsFractionAddend(index, pilesTotal, denominators) == expected
+
+#======== Analysis Method Tests =======
+
+@pytest.mark.parametrize("indices, expected", [
+	([0, 1, 2, 5], [0, 1, 2]),
+	([1, 2, 3], []),
+	([0], []),
+], ids=["contiguous-run", "no-zero-start", "single-value"])
+def test_getContiguousFromStart(indices: list[int], expected: list[int]) -> None:
+	assert _getContiguousFromStart(indices) == expected
+
+@pytest.mark.parametrize("offsets, expected", [
+	([-4, -3, -1], []),
+	([-3, -2, -1], [-3, -2, -1]),
+	([-1], []),
+], ids=["missing-terminal", "full-run", "single-value"])
+def test_getContiguousEndingAtNegativeOne(offsets: list[int], expected: list[int]) -> None:
+	assert _getContiguousEndingAtNegativeOne(offsets) == expected
+
+#======== File Generation Tests =======
+
+def test_writeExclusionDataCollated_creates_files(path_tmpTesting: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+	def stubLeafZero(dimensionsTotal: int) -> int:
+		return 0
+
+	def stubLeafOne(dimensionsTotal: int) -> int:
+		return 1
+
+	monkeypatch.setattr(theExcluderBeast, "functionsHeadDimensions", [stubLeafZero, stubLeafOne])
+	monkeypatch.setattr(theExcluderBeast, "dictionaryFunctionsByName", {stubLeafZero.__name__: stubLeafZero, stubLeafOne.__name__: stubLeafOne})
+	monkeypatch.setattr(theExcluderBeast, "pathExclusionData", path_tmpTesting)
+
+	def stubLeafDomains(state: EliminationState) -> dict[int, range]:
+		return {0: range(2), 1: range(2)}
+
+	monkeypatch.setattr(theExcluderBeast, "getDictionaryLeafDomains", stubLeafDomains)
+
+	def stubDataFrameFoldings(state: EliminationState) -> pandas.DataFrame:
+		return pandas.DataFrame({0: [0, 1], 1: [1, 0]})
+
+	monkeypatch.setattr(theExcluderBeast, "getDataFrameFoldings", stubDataFrameFoldings)
+
+	pathsCreated: list[PurePath] = writeExclusionDataCollated(listDimensions=[5])
+
+	assert pathsCreated
+	for pathCreated in pathsCreated:
+		assert Path(pathCreated).exists()
+		assert Path(pathCreated).parent == path_tmpTesting
+		assert "leafExcluderData" in Path(pathCreated).read_text(encoding="utf-8")
+
+def test_writeAggregatedExclusions_creates_files(path_tmpTesting: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+	def stubLeaf(dimensionsTotal: int) -> int:
+		return 0
+
+	monkeypatch.setattr(theExcluderBeast, "functionsHeadDimensions", [stubLeaf])
+	monkeypatch.setattr(theExcluderBeast, "pathExclusionData", path_tmpTesting)
+
+	stub_data: dict[str, dict[str, dict[str, list[tuple[Fraction, int]]]]] = {
+		stubLeaf.__name__: {
+			stubLeaf.__name__: {
+				stubLeaf.__name__: [(Fraction(0, 1), 0), (Fraction(0, 1), 1)]
+			}
+		}
+	}
+	def stub_analyze(*args: Any, **kwargs: Any) -> dict[str, dict[str, dict[str, list[tuple[Fraction, int]]]]]:
+		return stub_data
+
+	monkeypatch.setattr(theExcluderBeast, "analyzeContiguousEndAbsolute", stub_analyze)
+	monkeypatch.setattr(theExcluderBeast, "analyzeContiguousEndRelative", stub_analyze)
+	monkeypatch.setattr(theExcluderBeast, "analyzeContiguousStartAbsolute", stub_analyze)
+	monkeypatch.setattr(theExcluderBeast, "analyzeContiguousStartRelative", stub_analyze)
+	monkeypatch.setattr(theExcluderBeast, "analyzeNonContiguousIndicesRelative", stub_analyze)
+
+	listPathFilenames: list[PurePath] = writeAggregatedExclusions(path_tmpTesting)
+
+	assert listPathFilenames
+	for pathCreated in listPathFilenames:
+		assert Path(pathCreated).exists()
+		assert Path(pathCreated).parent == path_tmpTesting
+		assert "dictionaryExclusions" in Path(pathCreated).read_text(encoding="utf-8")
+
+def test_writeExclusionDictionaries_createsFile(path_tmpTesting: Path) -> None:
+	"""Verify writeExclusionDictionaries creates the output file."""
+	# This function calls loadAggregatedExclusions which looks for files in pathExclusionData.
+	# We need to ensure there are files there or mock loadAggregatedExclusions.
+
+	with patch("mapFolding._e.Z0Z_analysisPython.theExcluderBeast.pathExclusionData", path_tmpTesting), \
+			patch("mapFolding._e.Z0Z_analysisPython.theExcluderBeast.loadAggregatedExclusions", return_value={}):
+		# It also calls restructureAggregatedExclusionsForMapShape which needs to work with empty dict
+			pathExclusionsFile: Path = path_tmpTesting / "_exclusions.py"
+			pathCreated: PurePath = writeExclusionDictionaries(pathExclusionsFile)
+
+			assert Path(pathCreated).exists()
+			assert Path(pathCreated).name == "_exclusions.py"
+
+			content = Path(pathCreated).read_text(encoding="utf-8")
+			assert "dictionary2d5LeafExcludedAtPileByPile" in content
+