mapFolding 0.16.0__py3-none-any.whl → 0.16.2__py3-none-any.whl

mapFolding/syntheticModules/theorem2.py

@@ -1,4 +1,5 @@
 from mapFolding.dataBaskets import MapFoldingState
+from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
 
 def count(state: MapFoldingState) -> MapFoldingState:
     while state.leaf1ndex > 4:
@@ -47,4 +48,9 @@ def count(state: MapFoldingState) -> MapFoldingState:
         state.leaf1ndex += 1
     else:
         state.groupsOfFolds *= 2
+    return state
+
+def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
+    state = transitionOnGroupsOfFolds(state)
+    state = count(state)
     return state

mapFolding/syntheticModules/theorem2Numba.py

@@ -2,7 +2,7 @@ from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DL
 from numba import jit
 
 @jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
-def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1ndexCeiling: DatatypeElephino, indexDimension: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, connectionGraph: Array3DLeavesTotal, dimensionsTotal: DatatypeLeavesTotal, leavesTotal: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal]:
+def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1ndexCeiling: DatatypeElephino, indexDimension: DatatypeLeavesTotal, indexLeaf: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, connectionGraph: Array3DLeavesTotal, dimensionsTotal: DatatypeLeavesTotal, leavesTotal: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal]:
     while leaf1ndex > 4:
         if leafBelow[0] == 1:
             if leaf1ndex > leavesTotal:
@@ -23,6 +23,12 @@ def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1nde
                             countDimensionsGapped[leafConnectee] += 1
                             leafConnectee = connectionGraph[indexDimension, leaf1ndex, leafBelow[leafConnectee]]
                     indexDimension += 1
+                if not dimensionsUnconstrained:
+                    indexLeaf = 0
+                    while indexLeaf < leaf1ndex:
+                        gapsWhere[gap1ndexCeiling] = indexLeaf
+                        gap1ndexCeiling += 1
+                        indexLeaf += 1
                 indexMiniGap = gap1ndex
                 while indexMiniGap < gap1ndexCeiling:
                     gapsWhere[gap1ndex] = gapsWhere[indexMiniGap]
@@ -43,4 +49,4 @@ def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1nde
         leaf1ndex += 1
     else:
         groupsOfFolds *= 2
-    return (groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)
+    return (groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)

mapFolding/syntheticModules/theorem2Trimmed.py

@@ -1,4 +1,5 @@
 from mapFolding.dataBaskets import MapFoldingState
+from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
 
 def count(state: MapFoldingState) -> MapFoldingState:
     while state.leaf1ndex > 4:
@@ -41,4 +42,9 @@ def count(state: MapFoldingState) -> MapFoldingState:
         state.leaf1ndex += 1
     else:
         state.groupsOfFolds *= 2
+    return state
+
+def doTheNeedful(state: MapFoldingState, /) -> MapFoldingState:
+    state = transitionOnGroupsOfFolds(state)
+    state = count(state)
     return state

mapFolding/tests/conftest.py

@@ -25,7 +25,7 @@ research domain.
 
 from collections.abc import Callable, Generator, Sequence
 from mapFolding import _theSSOT, getLeavesTotal, makeDataContainer, packageSettings, validateListDimensions
-from mapFolding.oeis import dictionaryOEISMapFolding, dictionaryOEISMeanders, oeisIDsImplemented
+from mapFolding.oeis import dictionaryOEIS, dictionaryOEISMapFolding, oeisIDsImplemented
 from pathlib import Path
 from typing import Any
 import numpy
@@ -223,7 +223,7 @@ def oneTestCuzTestsOverwritingTests(oeisID_1random: str) -> tuple[int, ...]:
 			pass
 
 @pytest.fixture
-def mapShapeTestCountFolds(oeisID: str) -> tuple[int, ...]:
+def mapShapeTestCountFolds(oeisIDmapFolding: str) -> tuple[int, ...]:
 	"""For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestValidation` if
 	`validateListDimensions` approves. Each `listDimensions` is suitable for testing counts.
 
@@ -239,10 +239,10 @@ def mapShapeTestCountFolds(oeisID: str) -> tuple[int, ...]:
 
 	"""
 	while True:
-		n = random.choice(dictionaryOEISMapFolding[oeisID]['valuesTestValidation'])
+		n = random.choice(dictionaryOEISMapFolding[oeisIDmapFolding]['valuesTestValidation'])
 		if n < 2:
 			continue
-		listDimensionsCandidate = list(dictionaryOEISMapFolding[oeisID]['getMapShape'](n))
+		listDimensionsCandidate = list(dictionaryOEISMapFolding[oeisIDmapFolding]['getMapShape'](n))
 
 		try:
 			return validateListDimensions(listDimensionsCandidate)
@@ -278,7 +278,7 @@ def mapShapeTestFunctionality(oeisID_1random: str) -> tuple[int, ...]:
 			pass
 
 @pytest.fixture
-def mapShapeTestParallelization(oeisID: str) -> tuple[int, ...]:
+def mapShapeTestParallelization(oeisIDmapFolding: str) -> tuple[int, ...]:
 	"""For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestParallelization`.
 
 	Parameters
@@ -292,8 +292,8 @@ def mapShapeTestParallelization(oeisID: str) -> tuple[int, ...]:
 		Map dimensions suitable for testing parallelization features.
 
 	"""
-	n = random.choice(dictionaryOEISMapFolding[oeisID]['valuesTestParallelization'])
-	return dictionaryOEISMapFolding[oeisID]['getMapShape'](n)
+	n = random.choice(dictionaryOEISMapFolding[oeisIDmapFolding]['valuesTestParallelization'])
+	return dictionaryOEISMapFolding[oeisIDmapFolding]['getMapShape'](n)
 
 @pytest.fixture
 def mockBenchmarkTimer() -> Generator[unittest.mock.MagicMock | unittest.mock.AsyncMock, Any, None]:
@@ -332,7 +332,7 @@ def mockFoldingFunction() -> Callable[..., Callable[..., None]]:
 	return make_mock
 
 @pytest.fixture(params=oeisIDsImplemented)
-def oeisID(request: pytest.FixtureRequest) -> Any:
+def oeisIDmapFolding(request: pytest.FixtureRequest) -> Any:
 	"""Parametrized fixture providing all implemented OEIS sequence identifiers.
 
 	(AI generated docstring)
@@ -350,11 +350,26 @@ def oeisID(request: pytest.FixtureRequest) -> Any:
 	"""
 	return request.param
 
-@pytest.fixture(params=tuple(dictionaryOEISMeanders.keys()))
-def oeisIDMeanders(request: pytest.FixtureRequest) -> Any:
-	"""Parametrized fixture providing all implemented Meanders OEIS sequence identifiers.
+@pytest.fixture(params=('A000682', 'A005316'))
+def oeisIDmeanders(request: pytest.FixtureRequest) -> Any:
+	"""Parametrized fixture providing all Meanders OEIS sequence identifiers.
 
-	(AI generated docstring)
+	Parameters
+	----------
+	request : pytest.FixtureRequest
+		The pytest request object containing the current parameter value.
+
+	Returns
+	-------
+	sequenceIdentifier : Any
+		OEIS sequence identifier for testing across all Meanders sequences.
+
+	"""
+	return request.param
+
+@pytest.fixture(params=tuple(dictionaryOEIS.keys()))
+def oeisIDother(request: pytest.FixtureRequest) -> Any:
+	"""Parametrized fixture providing all other OEIS sequence identifiers.
 
 	Parameters
 	----------
@@ -364,7 +379,7 @@ def oeisIDMeanders(request: pytest.FixtureRequest) -> Any:
 	Returns
 	-------
 	sequenceIdentifier : Any
-		OEIS sequence identifier for testing across all implemented Meanders sequences.
+		OEIS sequence identifier for testing across all other sequences.
 
 	"""
 	return request.param

mapFolding/tests/test_computations.py

@@ -25,67 +25,48 @@ The `test_writeJobNumba` function shows how to test dynamically generated code,
 which is useful if you're working with the code synthesis features of the package.
 """
 
-from mapFolding import countFolds, dictionaryOEISMapFolding, dictionaryOEISMeanders, getFoldsTotalKnown, oeisIDfor_n
-from mapFolding.algorithms import oeisIDbyFormula
+from mapFolding import countFolds, dictionaryOEIS, dictionaryOEISMapFolding, getFoldsTotalKnown, oeisIDfor_n
+from mapFolding.basecamp import NOTcountingFolds
 from mapFolding.dataBaskets import MapFoldingState
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2
 from mapFolding.someAssemblyRequired.toolkitNumba import parametersNumbaLight
 from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
 from mapFolding.tests.conftest import registrarRecordsTemporaryFilesystemObject, standardizedEqualToCallableReturn
 from pathlib import Path, PurePosixPath
-from typing import TYPE_CHECKING
 import importlib.util
 import multiprocessing
 import pytest
 
-if TYPE_CHECKING:
-	from collections.abc import Callable
-
 if __name__ == '__main__':
 	multiprocessing.set_start_method('spawn')
 
-def test_aOFn_calculate_value_mapFolding(oeisID: str) -> None:
-	"""Verify OEIS sequence value calculations against known reference values.
-
-	Tests the `oeisIDfor_n` function by comparing its calculated output against
-	known correct values from the OEIS database. This ensures that sequence
-	value computations remain mathematically accurate across code changes.
-
-	The test iterates through validation test cases defined in `settingsOEIS`
-	for the given OEIS sequence identifier, verifying that each computed value
-	matches its corresponding known reference value.
+@pytest.mark.parametrize('flow', ['algorithm', 'asynchronous',  'asynchronousTheorem2', 'asynchronousTrimmed', 'numba', 'theorem2', 'theorem2Numba', 'theorem2Trimmed'])
+def test_A007822(flow: str) -> None:
+	"""Test A007822 flow options.
 
 	Parameters
 	----------
-	oeisID : str
-		The OEIS sequence identifier to test calculations for.
+	flow : str
+		The computational flow algorithm to validate.
 
 	"""
-	for n in dictionaryOEISMapFolding[oeisID]['valuesTestValidation']:
-		standardizedEqualToCallableReturn(dictionaryOEISMapFolding[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
-
-def test_aOFn_calculate_value_meanders(oeisIDMeanders: str) -> None:
-	"""Verify Meanders OEIS sequence value calculations against known reference values.
+	oeisID = 'A007822'
+	CPUlimit = .5
 
-	Tests the functions in `mapFolding.algorithms.oeisIDbyFormula` by comparing their
-	calculated output against known correct values from the OEIS database for Meanders IDs.
+	oeis_n = 2
+	for oeis_n in dictionaryOEIS[oeisID]['valuesTestValidation']:
+		if oeis_n < 2:
+			continue
 
-	Parameters
-	----------
-	oeisIDMeanders : str
-		The Meanders OEIS sequence identifier to test calculations for.
+		expected = dictionaryOEIS[oeisID]['valuesKnown'][oeis_n]
 
-	"""
-	oeisIDcallable: Callable[[int], int] = getattr(oeisIDbyFormula, oeisIDMeanders)
-	for n in dictionaryOEISMeanders[oeisIDMeanders]['valuesTestValidation']:
 		standardizedEqualToCallableReturn(
-			dictionaryOEISMeanders[oeisIDMeanders]['valuesKnown'][n],
-			oeisIDcallable,
-			n,
-		)
+			expected
+			, NOTcountingFolds, oeisID, oeis_n, flow, CPUlimit
+			)
 
 @pytest.mark.parametrize('flow', ['daoOfMapFolding', 'numba', 'theorem2', 'theorem2Numba', 'theorem2Trimmed'])
-def test_flowControl(mapShapeTestCountFolds: tuple[int, ...], flow: str) -> None:
+def test_countFolds(mapShapeTestCountFolds: tuple[int, ...], flow: str) -> None:
 	"""Validate that different computational flows produce valid results.
 
 	(AI generated docstring)
@@ -105,40 +86,66 @@ def test_flowControl(mapShapeTestCountFolds: tuple[int, ...], flow: str) -> None
 		The computational flow algorithm to validate.
 
 	"""
-	standardizedEqualToCallableReturn(getFoldsTotalKnown(mapShapeTestCountFolds), countFolds, None, None, None, None, mapShapeTestCountFolds, None, None, flow)
+	standardizedEqualToCallableReturn(getFoldsTotalKnown(mapShapeTestCountFolds), countFolds, None, None, None, None, mapShapeTestCountFolds, flow)
 
-@pytest.mark.parametrize('flow', ['daoOfMapFolding', 'numba', 'theorem2', 'theorem2Numba', 'theorem2Trimmed'])
-def test_flowControlByOEISid(oeisID: str, flow: str) -> None:
-	"""Validate that different flow paths using oeisID produce valid results.
+@pytest.mark.parametrize('flow', ['matrixNumPy', 'matrixPandas'])
+def test_meanders(oeisIDmeanders: str, flow: str) -> None:
+	"""Verify Meanders OEIS sequence value calculations against known reference values.
+
+	Tests the functions in `mapFolding.algorithms.oeisIDbyFormula` by comparing their
+	calculated output against known correct values from the OEIS database for Meanders IDs.
 
 	Parameters
 	----------
-	oeisID : str
-		The OEIS sequence identifier to test.
-	flow : str
-		The computational flow algorithm to validate.
+	oeisIDMeanders : str
+		The Meanders OEIS sequence identifier to test calculations for.
 
 	"""
-	listDimensions = None
-	pathLikeWriteFoldsTotal = None
-	computationDivisions = None
-	CPUlimit = None
-	mapShape = None
+	dictionary = dictionaryOEISMapFolding if oeisIDmeanders in dictionaryOEISMapFolding else dictionaryOEIS
+	for n in dictionary[oeisIDmeanders]['valuesTestValidation']:
+		standardizedEqualToCallableReturn(
+			dictionary[oeisIDmeanders]['valuesKnown'][n]
+			, NOTcountingFolds, oeisIDmeanders, n, flow, None
+			)
 
-	oeis_n = 2
-	for oeis_n in dictionaryOEISMapFolding[oeisID]['valuesTestValidation']:
-		if oeis_n < 2:
-			continue
+def test_NOTcountingFolds(oeisIDother: str) -> None:
+	"""Verify Meanders OEIS sequence value calculations against known reference values.
 
-		if oeisID in dictionaryOEISMeanders:
-			expected = dictionaryOEISMeanders[oeisID]['valuesKnown'][oeis_n]
-		else:
-			expected = dictionaryOEISMapFolding[oeisID]['valuesKnown'][oeis_n]
+	Tests the functions in `mapFolding.algorithms.oeisIDbyFormula` by comparing their
+	calculated output against known correct values from the OEIS database for Meanders IDs.
+
+	Parameters
+	----------
+	oeisIDMeanders : str
+		The Meanders OEIS sequence identifier to test calculations for.
 
+	"""
+	dictionary = dictionaryOEISMapFolding if oeisIDother in dictionaryOEISMapFolding else dictionaryOEIS
+	for n in dictionary[oeisIDother]['valuesTestValidation']:
 		standardizedEqualToCallableReturn(
-			expected
-			, countFolds, listDimensions, pathLikeWriteFoldsTotal, computationDivisions, CPUlimit, mapShape
-			, oeisID, oeis_n, flow)
+			dictionary[oeisIDother]['valuesKnown'][n]
+			, NOTcountingFolds, oeisIDother, n, None, None
+			)
+
+def test_oeisIDfor_n(oeisIDmapFolding: str) -> None:
+	"""Verify OEIS sequence value calculations against known reference values.
+
+	Tests the `oeisIDfor_n` function by comparing its calculated output against
+	known correct values from the OEIS database. This ensures that sequence
+	value computations remain mathematically accurate across code changes.
+
+	The test iterates through validation test cases defined in `settingsOEIS`
+	for the given OEIS sequence identifier, verifying that each computed value
+	matches its corresponding known reference value.
+
+	Parameters
+	----------
+	oeisID : str
+		The OEIS sequence identifier to test calculations for.
+
+	"""
+	for n in dictionaryOEISMapFolding[oeisIDmapFolding]['valuesTestValidation']:
+		standardizedEqualToCallableReturn(dictionaryOEISMapFolding[oeisIDmapFolding]['valuesKnown'][n], oeisIDfor_n, oeisIDmapFolding, n)
 
 @pytest.mark.parametrize('pathFilename_tmpTesting', ['.py'], indirect=True)
 def test_writeJobNumba(oneTestCuzTestsOverwritingTests: tuple[int, ...], pathFilename_tmpTesting: Path) -> None:

mapFolding/tests/test_oeis.py

@@ -35,13 +35,13 @@ import random
 import re as regex
 import unittest.mock
 
-def test__validateOEISid_valid_id(oeisID: str) -> None:
-	standardizedEqualToCallableReturn(oeisID, _standardizeOEISid, oeisID)
+def test__validateOEISid_valid_id(oeisIDmapFolding: str) -> None:
+	standardizedEqualToCallableReturn(oeisIDmapFolding, _standardizeOEISid, oeisIDmapFolding)
 
-def test__validateOEISid_valid_id_case_insensitive(oeisID: str) -> None:
-	standardizedEqualToCallableReturn(oeisID.upper(), _standardizeOEISid, oeisID.lower())
-	standardizedEqualToCallableReturn(oeisID.upper(), _standardizeOEISid, oeisID.upper())
-	standardizedEqualToCallableReturn(oeisID.upper(), _standardizeOEISid, oeisID.swapcase())
+def test__validateOEISid_valid_id_case_insensitive(oeisIDmapFolding: str) -> None:
+	standardizedEqualToCallableReturn(oeisIDmapFolding.upper(), _standardizeOEISid, oeisIDmapFolding.lower())
+	standardizedEqualToCallableReturn(oeisIDmapFolding.upper(), _standardizeOEISid, oeisIDmapFolding.upper())
+	standardizedEqualToCallableReturn(oeisIDmapFolding.upper(), _standardizeOEISid, oeisIDmapFolding.swapcase())
 
 parameters_test_aOFn_invalid_n = [
 	(-random.randint(1, 100), "randomNegative"),  # noqa: S311

mapFolding/zCuzDocStoopid/__init__.py

@@ -1 +1,4 @@
-"""I mean, you must write docstrings after you write the code because you don't know what the code will do until after you write it."""
+"""I mean, you must write docstrings after you write the code because you don't know what the code will do until after you write it.
+
+I strongly suspect this directory will slowly evolve into an entire ecosystem of docstring tools.
+"""

mapFolding/zCuzDocStoopid/makeDocstrings.py

@@ -2,38 +2,37 @@
 from astToolkit import Grab, IfThis, Make, NodeChanger, parsePathFilename2astModule, Then
 from astToolkit.transformationTools import makeDictionaryFunctionDef
 from hunterMakesPy import raiseIfNone, writeStringToHere
-from mapFolding import dictionaryOEISMapFolding, dictionaryOEISMeanders, packageSettings
+from mapFolding import dictionaryOEIS, dictionaryOEISMapFolding, packageSettings
 from pathlib import Path
 import ast
 
+# ----------------- General Settings ----------------------------------------------------------------------------------
 sourcePrefix: str = 'zCuzDocStoopid'
 
-pathRoot: Path = packageSettings.pathPackage / "algorithms"
-
-pathFilenameSource: Path = next(iter(pathRoot.glob(f"{sourcePrefix}*.py"))).absolute()
-pathFilenameWrite: Path = pathFilenameSource.with_stem(pathFilenameSource.stem.removeprefix(sourcePrefix))
-
-astModule: ast.Module = parsePathFilename2astModule(pathFilenameSource)
-dictionaryFunctionDef: dict[str, ast.FunctionDef] = makeDictionaryFunctionDef(astModule)
+moduleWarning = "NOTE: This is a generated file; edit the source file."
 
-moduleWarning = """
-NOTE: This is a generated file; edit the source file.
-"""
+def transformOEISidByFormula(pathFilenameSource: Path) -> None:
+    """Transform the docstrings of functions corresponding to OEIS sequences."""
+    pathFilenameWrite: Path = pathFilenameSource.with_stem(pathFilenameSource.stem.removeprefix(sourcePrefix))
+    astModule: ast.Module = parsePathFilename2astModule(pathFilenameSource)
+    dictionaryFunctionDef: dict[str, ast.FunctionDef] = makeDictionaryFunctionDef(astModule)
 
-oeisID = 'Error during transformation' # `ast.FunctionDef.name` of function in `pathFilenameSource`.
-functionOf: str = 'Error during transformation' # The value of `functionOf` is in the docstring of function `oeisID` in `pathFilenameSource`.
+    oeisID = 'Error during transformation' # `ast.FunctionDef.name` of function in `pathFilenameSource`.
+    functionOf: str = 'Error during transformation' # The value of `functionOf` is in the docstring of function `oeisID` in `pathFilenameSource`.
 
-for oeisID, FunctionDef in dictionaryFunctionDef.items():
-    dictionaryOEIS = dictionaryOEISMapFolding if oeisID in dictionaryOEISMapFolding else dictionaryOEISMeanders
-    functionOf = raiseIfNone(ast.get_docstring(FunctionDef))
+    for oeisID, FunctionDef in dictionaryFunctionDef.items():
+        if not oeisID.startswith('A') or not oeisID[1:7].isdigit():
+            continue
+        dictionary = dictionaryOEISMapFolding if oeisID in dictionaryOEISMapFolding else dictionaryOEIS
+        functionOf = raiseIfNone(ast.get_docstring(FunctionDef))
 
-    ImaDocstring= 	f"""
+        ImaDocstring= 	f"""
     Compute {oeisID}(n) as a function of {functionOf}.
 
-    *The On-Line Encyclopedia of Integer Sequences* (OEIS) description of {oeisID} is: "{dictionaryOEIS[oeisID]['description']}"
+    *The On-Line Encyclopedia of Integer Sequences* (OEIS) description of {oeisID} is: "{dictionary[oeisID]['description']}"
 
-    The domain of {oeisID} starts at {dictionaryOEIS[oeisID]['offset']}, therefore for values of `n` < {dictionaryOEIS[oeisID]['offset']}, a(n) is undefined. The smallest value of n for which a(n)
-    has not yet been computed is {dictionaryOEIS[oeisID]['valueUnknown']}.
+    The domain of {oeisID} starts at {dictionary[oeisID]['offset']}, therefore for values of `n` < {dictionary[oeisID]['offset']}, a(n) is undefined. The smallest value of n for which a(n)
+    has not yet been computed is {dictionary[oeisID]['valueUnknown']}.
 
     Parameters
     ----------
@@ -43,7 +42,7 @@ for oeisID, FunctionDef in dictionaryFunctionDef.items():
     Returns
     -------
     a(n) : int
-        {dictionaryOEIS[oeisID]['description']}
+        {dictionary[oeisID]['description']}
 
     Would You Like to Know More?
     ----------------------------
@@ -51,13 +50,21 @@ for oeisID, FunctionDef in dictionaryFunctionDef.items():
         https://oeis.org/{oeisID}
     """
 
-    astExprDocstring = Make.Expr(Make.Constant(ImaDocstring))
+        astExprDocstring = Make.Expr(Make.Constant(ImaDocstring))
 
-    NodeChanger(
-        findThis = IfThis.isFunctionDefIdentifier(oeisID)
-        , doThat = Grab.bodyAttribute(Grab.index(0, Then.replaceWith(astExprDocstring)))
-    ).visit(astModule)
+        NodeChanger(
+            findThis = IfThis.isFunctionDefIdentifier(oeisID)
+            , doThat = Grab.bodyAttribute(Grab.index(0, Then.replaceWith(astExprDocstring)))
+        ).visit(astModule)
 
-ast.fix_missing_locations(astModule)
+    ast.fix_missing_locations(astModule)
 
-writeStringToHere((ast.unparse(astModule)+"\n"), pathFilenameWrite)
+    docstringModule = raiseIfNone(ast.get_docstring(astModule))
+    moduleAsString = ast.unparse(astModule) + "\n"
+    moduleAsString = moduleAsString.replace(docstringModule,docstringModule + "\n\n" + moduleWarning)
+
+    writeStringToHere(moduleAsString, pathFilenameWrite)
+
+pathRoot: Path = packageSettings.pathPackage / "algorithms"
+pathFilenameSource: Path = next(iter(pathRoot.glob(f"{sourcePrefix}*.py"))).absolute()
+transformOEISidByFormula(pathFilenameSource)

mapfolding-0.16.2.dist-info/METADATA

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: mapFolding
+Version: 0.16.2
+Summary: Map folding, meanders, stamp folding, semi-meanders. Experiment with algorithm transformations, and analyze computational states.
+Author-email: Hunter Hogan <HunterHogan@pm.me>
+License: CC-BY-NC-4.0
+Project-URL: Donate, https://www.patreon.com/integrated
+Project-URL: Homepage, https://github.com/hunterhogan/mapFolding
+Project-URL: Issues, https://github.com/hunterhogan/mapFolding/issues
+Project-URL: Repository, https://github.com/hunterhogan/mapFolding.git
+Keywords: A000136,A000560,A000682,A001010,A001011,A001415,A001416,A001417,A001418,A005315,A005316,A007822,A178961,A195646,A223094,A259702,A301620,AST manipulation,JIT compilation,Numba optimization,OEIS,Python optimization,abstract syntax tree,algorithmic combinatorics,algorithmic optimization,arch configurations,automated code generation,bit-packed arrays,bitwise state machines,cache-efficient algorithms,closed meandric numbers,code generation,code optimization,code synthesis,code transformation,codon optimization,combinatorial computing,combinatorial enumeration,combinatorial geometry,combinatorial mathematics,combinatorial problem solver,combinatorics,computational combinatorics,computational geometry,crossing patterns,curve crossings,dataclass transformation,discrete mathematics,dynamic compilation,enumerative combinatorics,folding pattern enumeration,folding problems,high-performance computing,integer sequences,just-in-time compilation,kernel optimization,labeled stamp folding,low-level computation,map folding,mapFolding,mathematical algorithms,mathematical modeling,mathematical optimization,mathematical patterns,mathematical software,mathematical tool,mathematical visualization,meander enumeration,meanders,meandric systems,memory-efficient enumeration,metaprogramming,numerical algorithms,numerical computation,open meandric systems,paper folding mathematics,parallel computing,pattern recognition,performance optimization,permutation patterns,permutations,post-setup optimization,pyproject,scientific computing,semi-meanders,sequence analysis,sequence calculator,sequence enumeration,sequence explorer,sequence generation,source code analysis,stamp folding,symbolic computation,symmetric foldings,topological combinatorics,topological patterns,typed Python
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Pre-processors
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: astToolkit
+Requires-Dist: autoflake
+Requires-Dist: hunterMakesPy
+Requires-Dist: isort
+Requires-Dist: numpy
+Requires-Dist: platformdirs
+Provides-Extra: development
+Requires-Dist: memray; sys_platform == "linux" and extra == "development"
+Requires-Dist: mypy; extra == "development"
+Requires-Dist: pyupgrade; extra == "development"
+Requires-Dist: py-spy; extra == "development"
+Requires-Dist: setuptools-scm; extra == "development"
+Provides-Extra: numba
+Requires-Dist: numba; extra == "numba"
+Requires-Dist: numba_progress; extra == "numba"
+Provides-Extra: pandas
+Requires-Dist: pandas; extra == "pandas"
+Requires-Dist: pyarrow; extra == "pandas"
+Requires-Dist: pyarrow-stubs; extra == "pandas"
+Provides-Extra: testing
+Requires-Dist: numba; extra == "testing"
+Requires-Dist: pandas; extra == "testing"
+Requires-Dist: pyarrow; 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"
+Dynamic: license-file
+
+# mapFolding
+
+[![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/)
+
+Map folding, meanders, stamp folding, semi-meanders. Experiment with algorithm transformations and code optimization.
+
+I don't know how to write a README.md. Furthermore, the package used to be focused on multidimensional map folding and tools for transforming the algorithm to experiment with optimizations or to explore the algorithm.
+
+First, the tools for transforming algorithms became far more sophisticated and powerful than this package. So I moved them to [astToolkit](https://github.com/hunterhogan/astToolkit). But those got so sophisticated, that I create more than half of that package through another layer of meta-programming: [astToolFactory](https://github.com/hunterhogan/astToolFactory).
+
+Second, when I finally understood the connections between map folding and meanders, I added meanders to this package, and applied my transformation tools to that algorithm.
+
+I used a weaker form of this package to [compute new terms for OEIS A001415](https://oeis.org/A001415), "Number of ways of folding a 2 X n strip of stamps."
+There are cool and powerful tools in here, but as of 2025 September 17, I am dissatisfied with the organization and documentation. It's annoying.
+
+## Finding stuff
+
+1. At the moment, almost every algorithm version eventually runs through "mapFolding/basecamp.py", so it's sort of an overview and you can work backwards to find more details.
+2. The directory "mapFolding/algorithms" only has "handmade" algorithms. Therefore, most logic for most computations is based on something in that directory.
+3. The directory "mapFolding/syntheticModules" has code that is generated by the transformation tools.
+4. Transformation functions are in "mapFolding/someAssemblyRequired."
+5. The directory "mapFolding/reference" has "reference" materials.
+6. "mapFolding/tests" has the tests, and I have tried to make it easy for you to add _your_ versions of the algorithms to the tests. Is it actually easy? I'll say it this way: if you were to create your own subclass of `ast.AST` it would be impossible for you to add your subclass to all of the `ast` module tests with just a few lines of code. In contrast, it is possible to fully test your algorithm with in my tests by adding between three and 25 lines of code. So, yeah, it's easy.
+
+## Math and programming
+
+I'm not a mathematician. I don't have training in or professional experience as a programmer. I'm not stupid: I'm ignorant.
+
+## My recovery
+
+[![Static Badge](https://img.shields.io/badge/2011_August-Homeless_since-blue?style=flat)](https://HunterThinks.com/support)
+[![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UC3Gx7kz61009NbhpRtPP7tw)](https://www.youtube.com/@HunterHogan)
+
+[![CC-BY-NC-4.0](https://github.com/hunterhogan/mapFolding/blob/main/CC-BY-NC-4.0.png)](https://creativecommons.org/licenses/by-nc/4.0/)