mapFolding 0.8.3__tar.gz → 0.8.4__tar.gz

{mapfolding-0.8.3 → mapfolding-0.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.8.3
+Version: 0.8.4
 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
@@ -45,6 +45,7 @@ Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: pytest-env; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
 Requires-Dist: pyupgrade; extra == "testing"
+Requires-Dist: ruff; extra == "testing"
 Dynamic: license-file
 
 # mapFolding: Algorithms for enumerating distinct map/stamp folding patterns 🗺️

{mapfolding-0.8.3 → mapfolding-0.8.4}/mapFolding/__init__.py

@@ -24,13 +24,13 @@ Special directories:
   core algorithm created by the code transformation framework
 - reference/: Historical implementations and educational resources for algorithm exploration
   - reference/jobsCompleted/: Contains successful computations for previously unknown values,
-    including first-ever calculations for 2×19 and 2×20 maps (OEIS A001415)
+    including first-ever calculations for 2x19 and 2x20 maps (OEIS A001415)
 
 This package strives to balance algorithm readability and understandability with
 high-performance computation capabilities, allowing users to compute map folding
 totals for larger dimensions than previously feasible.
 """
-from mapFolding.basecamp import countFolds as countFolds
+from mapFolding.basecamp import countFolds
 from mapFolding.oeis import clearOEIScache, getOEISids, OEIS_for_n, oeisIDfor_n
 
 __all__ = [

{mapfolding-0.8.3 → mapfolding-0.8.4}/mapFolding/basecamp.py

@@ -14,13 +14,13 @@ implementation, and optional persistence of results.
 
 from collections.abc import Sequence
 from mapFolding.beDRY import outfitCountFolds, setCPUlimit, validateListDimensions
-from mapFolding.filesystem import getPathFilenameFoldsTotal, saveFoldsTotal
+from mapFolding.filesystem import getPathFilenameFoldsTotal, saveFoldsTotal, saveFoldsTotalFAILearly
 from mapFolding.theSSOT import ComputationState, getPackageDispatcher, The
 from os import PathLike
-from pathlib import Path
+from pathlib import PurePath
 
 def countFolds(listDimensions: Sequence[int]
-				, pathLikeWriteFoldsTotal: str | PathLike[str] | None = None
+				, pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None
 				, computationDivisions: int | str | None = None
 				, CPUlimit: int | float | bool | None = None
 				) -> int:
@@ -57,13 +57,19 @@ def countFolds(listDimensions: Sequence[int]
 	concurrencyLimit: int = setCPUlimit(CPUlimit, The.concurrencyPackage)
 	computationStateInitialized: ComputationState = outfitCountFolds(mapShape, computationDivisions, concurrencyLimit)
 
+	if pathLikeWriteFoldsTotal is not None:
+		pathFilenameFoldsTotal = getPathFilenameFoldsTotal(computationStateInitialized.mapShape, pathLikeWriteFoldsTotal)
+		saveFoldsTotalFAILearly(pathFilenameFoldsTotal)
+	else:
+		pathFilenameFoldsTotal = None
+
 	dispatcherCallableProxy = getPackageDispatcher()
 	computationStateComplete: ComputationState = dispatcherCallableProxy(computationStateInitialized)
+	# computationStateComplete: ComputationState = The.dispatcher(computationStateInitialized)
 
 	computationStateComplete.getFoldsTotal()
 
-	if pathLikeWriteFoldsTotal is not None:
-		pathFilenameFoldsTotal: Path = getPathFilenameFoldsTotal(computationStateComplete.mapShape, pathLikeWriteFoldsTotal)
+	if pathFilenameFoldsTotal is not None:
 		saveFoldsTotal(pathFilenameFoldsTotal, computationStateComplete.foldsTotal)
 
 	return computationStateComplete.foldsTotal

mapfolding-0.8.4/mapFolding/filesystem.py

@@ -0,0 +1,154 @@
+"""
+Filesystem utilities for managing map folding computation results.
+
+This module provides functions for standardized handling of files related to the mapFolding
+package, with a focus on saving, retrieving, and naming computation results. It implements
+consistent naming conventions and path resolution strategies to ensure that:
+
+1. Computation results are stored in a predictable location
+2. Filenames follow a consistent pattern based on map dimensions
+3. Results can be reliably retrieved for future reference
+4. The system handles file operations safely with appropriate error handling
+
+The module serves as the interface between the computational components of the package
+and the filesystem, abstracting away the details of file operations and path management.
+"""
+from mapFolding.theSSOT import The
+from os import PathLike
+from pathlib import Path, PurePath
+from sys import modules as sysModules
+from typing import Any
+import os
+
+def getFilenameFoldsTotal(mapShape: tuple[int, ...]) -> str:
+	"""
+	Create a standardized filename for a computed `foldsTotal` value.
+
+	This function generates a consistent, filesystem-safe filename based on map dimensions.
+	Standardizing filenames ensures that results can be reliably stored and retrieved,
+	avoiding potential filesystem incompatibilities or Python naming restrictions.
+
+	Parameters:
+		mapShape: A sequence of integers representing the dimensions of the map.
+
+	Returns:
+		filenameFoldsTotal: A filename string in format 'pMxN.foldsTotal' where M,N are sorted dimensions.
+
+	Notes:
+		The filename format ensures:
+		- No spaces in the filename
+		- Safe filesystem characters
+		- Unique extension (.foldsTotal)
+		- Python-safe strings (no starting with numbers, no reserved words)
+		- The 'p' prefix preserves compatibility with Lunnan's original code.
+	"""
+	return 'p' + 'x'.join(str(dimension) for dimension in sorted(mapShape)) + '.foldsTotal'
+
+def getPathFilenameFoldsTotal(mapShape: tuple[int, ...], pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None) -> Path:
+	"""
+	Get a standardized path and filename for the computed foldsTotal value.
+
+	This function resolves paths for storing computation results, handling different
+	input types including directories, absolute paths, or relative paths. It ensures
+	that all parent directories exist in the resulting path.
+
+	Parameters:
+		mapShape: List of dimensions for the map folding problem.
+		pathLikeWriteFoldsTotal (getPathJobRootDEFAULT): Path, filename, or relative path and filename.
+			If None, uses default path. If a directory, appends standardized filename.
+
+	Returns:
+		pathFilenameFoldsTotal: Absolute path and filename for storing the foldsTotal value.
+
+	Notes:
+		The function creates any necessary directories in the path if they don't exist.
+	"""
+
+	if pathLikeWriteFoldsTotal is None:
+		pathFilenameFoldsTotal = getPathRootJobDEFAULT() / getFilenameFoldsTotal(mapShape)
+	else:
+		pathLikeSherpa = Path(pathLikeWriteFoldsTotal)
+		if pathLikeSherpa.is_dir():
+			pathFilenameFoldsTotal = pathLikeSherpa / getFilenameFoldsTotal(mapShape)
+		elif pathLikeSherpa.is_file() and pathLikeSherpa.is_absolute():
+			pathFilenameFoldsTotal = pathLikeSherpa
+		else:
+			pathFilenameFoldsTotal = getPathRootJobDEFAULT() / pathLikeSherpa
+
+	pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
+	return pathFilenameFoldsTotal
+
+# TODO learn how to see this from the user's perspective
+def getPathRootJobDEFAULT() -> Path:
+	pathJobDEFAULT = The.pathPackage / "jobs"
+	if 'google.colab' in sysModules:
+		pathJobDEFAULT = Path("/content/drive/MyDrive") / "jobs"
+	pathJobDEFAULT.mkdir(parents=True, exist_ok=True)
+	return pathJobDEFAULT
+
+def _saveFoldsTotal(pathFilename: PathLike[str] | PurePath, foldsTotal: int) -> None:
+	pathFilenameFoldsTotal = Path(pathFilename)
+	pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
+	pathFilenameFoldsTotal.write_text(str(foldsTotal))
+
+def saveFoldsTotal(pathFilename: PathLike[str] | PurePath, foldsTotal: int) -> None:
+	"""
+	Save `foldsTotal` value to disk with multiple fallback mechanisms.
+
+	This function attempts to save the computed `foldsTotal` value to the specified
+	location, with backup strategies in case the primary save attempt fails.
+	The robustness is critical since these computations may take days to complete.
+
+	Parameters:
+		pathFilename: Target save location for the `foldsTotal` value
+		foldsTotal: The computed value to save
+
+	Notes:
+		If the primary save fails, the function will attempt alternative save methods:
+		1. Print the value prominently to stdout
+		2. Create a fallback file in the current working directory
+		3. As a last resort, simply print the value
+	"""
+	try:
+		_saveFoldsTotal(pathFilename, foldsTotal)
+	except Exception as ERRORmessage:
+		try:
+			print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
+			print(ERRORmessage)
+			print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
+			randomnessPlanB = (int(str(foldsTotal).strip()[-1]) + 1) * ['YO_']
+			filenameInfixUnique = ''.join(randomnessPlanB)
+			pathFilenamePlanB = os.path.join(os.getcwd(), 'foldsTotal' + filenameInfixUnique + '.txt')
+			writeStreamFallback = open(pathFilenamePlanB, 'w')
+			writeStreamFallback.write(str(foldsTotal))
+			writeStreamFallback.close()
+			print(str(pathFilenamePlanB))
+		except Exception:
+			print(foldsTotal)
+	return None
+
+def saveFoldsTotalFAILearly(pathFilename: PathLike[str] | PurePath) -> None:
+	if Path(pathFilename).exists():
+		raise FileExistsError(f"{pathFilename=} exists: a battle of overwriting might cause tears.")
+	if not Path(pathFilename).parent.exists():
+		raise FileNotFoundError(f"I received {pathFilename=} 0.000139 seconds ago from a function that promised it created the parent directory, but the parent directory does not exist. Fix that now, so your computation doesn't get deleted later. And be compassionate to others.")
+	foldsTotal = 149302889205120
+	_saveFoldsTotal(pathFilename, foldsTotal)
+	if not Path(pathFilename).exists():
+		raise FileNotFoundError(f"I just wrote a test file to {pathFilename=}, but it does not exist. Fix that now, so your computation doesn't get deleted later. And continually improve your empathy skills.")
+	foldsTotalRead = int(Path(pathFilename).read_text())
+	if foldsTotalRead != foldsTotal:
+		raise FileNotFoundError(f"I wrote a test file to {pathFilename=} with contents of {str(foldsTotal)=}, but I read {foldsTotalRead=} from the file. Python says the values are not equal. Fix that now, so your computation doesn't get corrupted later. And be pro-social.")
+
+def writeStringToHere(this: str, pathFilename: PathLike[str] | PurePath) -> None:
+	"""
+	Write a string to a file, creating parent directories if needed.
+
+	Parameters:
+		this: The string content to write to the file
+		pathFilename: The target file path where the string should be written
+	"""
+	pathFilename = Path(pathFilename)
+	pathFilename.parent.mkdir(parents=True, exist_ok=True)
+	pathFilename.write_text(str(this))
+	return None

{mapfolding-0.8.3 → mapfolding-0.8.4}/mapFolding/oeis.py

@@ -33,7 +33,7 @@ if TYPE_CHECKING:
 else:
 	TypedDict = dict
 
-cacheDays = 7
+cacheDays = 30
 
 """
 Section: make `settingsOEIS`"""

{mapfolding-0.8.3 → mapfolding-0.8.4}/mapFolding/someAssemblyRequired/__init__.py

@@ -24,23 +24,42 @@ These tools were developed for map folding computation optimization but are desi
 general-purpose utilities applicable to a wide range of code transformation scenarios,
 particularly for numerically-intensive algorithms that benefit from just-in-time compilation.
 """
+from mapFolding.someAssemblyRequired._theTypes import (
+	ast_expr_Slice,
+	ast_Identifier,
+	ImaAnnotationType,
+	astClassHasDOTnameNotName,
+	astClassHasDOTnameNotNameOptional,
+	astClassHasDOTtarget,
+	astClassHasDOTvalue,
+	astMosDef,
+	intORlist_ast_type_paramORstr_orNone,
+	intORstr_orNone,
+	list_ast_type_paramORstr_orNone,
+	str_nameDOTname,
+	typeCertified,
+	)
+
+from mapFolding.someAssemblyRequired._toolboxPython import (
+	importLogicalPath2Callable,
+	importPathFilename2Callable,
+	NodeChanger,
+	NodeTourist,
+	parseLogicalPath2astModule,
+	parsePathFilename2astModule,
+	)
+
+from mapFolding.someAssemblyRequired._toolboxAntecedents import be, ifThis, 又
+from mapFolding.someAssemblyRequired._tool_Make import Make
+from mapFolding.someAssemblyRequired._tool_Then import Then
+
 from mapFolding.someAssemblyRequired.transformationTools import (
-	ast_Identifier as ast_Identifier,
-	extractClassDef as extractClassDef,
-	extractFunctionDef as extractFunctionDef,
-	ifThis as ifThis,
-	IngredientsFunction as IngredientsFunction,
-	IngredientsModule as IngredientsModule,
-	inlineThisFunctionWithTheseValues as inlineThisFunctionWithTheseValues,
-	LedgerOfImports as LedgerOfImports,
-	Make as Make,
-	makeDictionaryReplacementStatements as makeDictionaryReplacementStatements,
-	NodeCollector as NodeCollector,
-	NodeReplacer as NodeReplacer,
-	RecipeSynthesizeFlow as RecipeSynthesizeFlow,
-	strDotStrCuzPyStoopid as strDotStrCuzPyStoopid,
-	Then as Then,
-	write_astModule as write_astModule,
-	Z0Z_executeActionUnlessDescendantMatches as Z0Z_executeActionUnlessDescendantMatches,
-	Z0Z_replaceMatchingASTnodes as Z0Z_replaceMatchingASTnodes,
+	dictionaryEstimates,
+	extractClassDef,
+	extractFunctionDef,
+	write_astModule,
+	Z0Z_executeActionUnlessDescendantMatches,
+	Z0Z_inlineThisFunctionWithTheseValues,
+	Z0Z_lameFindReplace,
+	Z0Z_makeDictionaryReplacementStatements,
 	)

mapfolding-0.8.4/mapFolding/someAssemblyRequired/_theTypes.py

@@ -0,0 +1,35 @@
+"""
+Type definitions used across the AST transformation modules.
+
+This module provides type aliases and variables used in AST manipulation,
+centralizing type definitions to prevent circular imports.
+"""
+from typing import Any, TYPE_CHECKING, TypeAlias as typing_TypeAlias, TypeVar as typing_TypeVar
+import ast
+
+stuPyd: typing_TypeAlias = str
+
+if TYPE_CHECKING:
+	astClassHasDOTnameNotName: typing_TypeAlias = ast.alias | ast.AsyncFunctionDef | ast.ClassDef | ast.FunctionDef | ast.ParamSpec | ast.TypeVar | ast.TypeVarTuple
+	astClassHasDOTnameNotNameOptional: typing_TypeAlias = astClassHasDOTnameNotName | ast.ExceptHandler | ast.MatchAs | ast.MatchStar | None
+	astClassHasDOTtarget: typing_TypeAlias = ast.AnnAssign | ast.AsyncFor | ast.AugAssign | ast.comprehension | ast.For | ast.NamedExpr
+	astClassHasDOTvalue: typing_TypeAlias = ast.AnnAssign | ast.Assign | ast.Attribute | ast.AugAssign | ast.Await | ast.Constant | ast.DictComp | ast.Expr | ast.FormattedValue | ast.keyword | ast.MatchValue | ast.NamedExpr | ast.Return | ast.Starred | ast.Subscript | ast.TypeAlias | ast.Yield | ast.YieldFrom
+else:
+	astClassHasDOTnameNotName = stuPyd
+	astClassHasDOTnameNotNameOptional = stuPyd
+	astClassHasDOTtarget = stuPyd
+	astClassHasDOTvalue = stuPyd
+
+ast_expr_Slice: typing_TypeAlias = ast.expr
+ast_Identifier: typing_TypeAlias = str
+intORlist_ast_type_paramORstr_orNone: typing_TypeAlias = Any
+intORstr_orNone: typing_TypeAlias = Any
+list_ast_type_paramORstr_orNone: typing_TypeAlias = Any
+# TODO I am using the moniker `nameDOTname` in two very different ways: differentiate them.
+str_nameDOTname: typing_TypeAlias = stuPyd
+ImaAnnotationType: typing_TypeAlias = ast.Attribute | ast.Constant | ast.Name | ast.Subscript
+
+# TODO understand whatever the fuck `typing.TypeVar` is _supposed_ to fucking do.
+typeCertified = typing_TypeVar('typeCertified')
+
+astMosDef = typing_TypeVar('astMosDef', bound=astClassHasDOTnameNotName)

mapfolding-0.8.4/mapFolding/someAssemblyRequired/_tool_Make.py

@@ -0,0 +1,92 @@
+from collections.abc import Sequence
+from mapFolding.someAssemblyRequired import ast_expr_Slice, ast_Identifier, ImaAnnotationType, intORlist_ast_type_paramORstr_orNone, intORstr_orNone, list_ast_type_paramORstr_orNone
+from typing import Any
+import ast
+
+class Make:
+	"""Almost all parameters described here are only accessible through a method's `**keywordArguments` parameter.
+
+	Parameters:
+		context (ast.Load()): Are you loading from, storing to, or deleting the identifier? The `context` (also, `ctx`) value is `ast.Load()`, `ast.Store()`, or `ast.Del()`.
+		col_offset (0): int Position information specifying the column where an AST node begins.
+		end_col_offset (None): int|None Position information specifying the column where an AST node ends.
+		end_lineno (None): int|None Position information specifying the line number where an AST node ends.
+		level (0): int Module import depth level that controls relative vs absolute imports. Default 0 indicates absolute import.
+		lineno: int Position information manually specifying the line number where an AST node begins.
+		kind (None): str|None Used for type annotations in limited cases.
+		type_comment (None): str|None "type_comment is an optional string with the type annotation as a comment." or `# type: ignore`.
+		type_params: list[ast.type_param] Type parameters for generic type definitions.
+
+	The `ast._Attributes`, lineno, col_offset, end_lineno, and end_col_offset, hold position information; however, they are, importantly, _not_ `ast._fields`.
+	"""
+	@staticmethod
+	def alias(name: ast_Identifier, asname: ast_Identifier | None = None) -> ast.alias:
+		return ast.alias(name, asname)
+	@staticmethod
+	def AnnAssign(target: ast.Attribute | ast.Name | ast.Subscript, annotation: ImaAnnotationType, value: ast.expr | None = None, **keywordArguments: int) -> ast.AnnAssign: # `simple: int`: uses a clever int-from-boolean to assign the correct value to the `simple` attribute. So, don't make it a method parameter.
+		return ast.AnnAssign(target, annotation, value, simple=int(isinstance(target, ast.Name)), **keywordArguments)
+	@staticmethod
+	def arg(identifier: ast_Identifier, annotation: ast.expr | None = None, **keywordArguments: intORstr_orNone) -> ast.arg:
+		return ast.arg(identifier, annotation, **keywordArguments)
+	@staticmethod
+	def argumentsSpecification(posonlyargs:list[ast.arg]=[], args:list[ast.arg]=[], vararg:ast.arg|None=None, kwonlyargs:list[ast.arg]=[], kw_defaults:list[ast.expr|None]=[None], kwarg:ast.arg|None=None, defaults:list[ast.expr]=[]) -> ast.arguments:
+		return ast.arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults, kwarg, defaults)
+	@staticmethod
+	def Assign(listTargets: Any, value: ast.expr, **keywordArguments: intORstr_orNone) -> ast.Assign:
+		return ast.Assign(listTargets, value, **keywordArguments)
+	@staticmethod
+	def Attribute(value: ast.expr, *attribute: ast_Identifier, context: ast.expr_context = ast.Load(), **keywordArguments: int) -> ast.Attribute:
+		""" If two `ast_Identifier` are joined by a dot `.`, they are _usually_ an `ast.Attribute`, but see `ast.ImportFrom`.
+		Parameters:
+			value: the part before the dot (Often `ast.Name`, but also `ast.Attribute`, `ast.Starred`, and `ast.Subscript`.)
+			attribute: an `ast_Identifier` after a dot `.`; you can pass multiple `attribute` and they will be chained together.
+		"""
+		# TODO confirm the precision of the docstring.
+		def addDOTattribute(chain, identifier: ast_Identifier, context: ast.expr_context, **keywordArguments: int) -> ast.Attribute:
+			return ast.Attribute(value=chain, attr=identifier, ctx=context, **keywordArguments)
+		buffaloBuffalo = addDOTattribute(value, attribute[0], context, **keywordArguments)
+		for identifier in attribute[1:None]:
+			buffaloBuffalo = addDOTattribute(buffaloBuffalo, identifier, context, **keywordArguments)
+		return buffaloBuffalo
+	@staticmethod
+	# TODO are the types for `callee` comprehensive?
+	# TODO is there an easier way to create precise typings for `ast`? I mean, it's a fucking closed system: there should be a lot of mystery involved.
+	def Call(callee: ast.Attribute | ast.Name | ast.Subscript, listArguments: Sequence[ast.expr] | None = None, list_astKeywords: Sequence[ast.keyword] | None = None) -> ast.Call:
+		return ast.Call(func=callee, args=list(listArguments) if listArguments else [], keywords=list(list_astKeywords) if list_astKeywords else [])
+	@staticmethod
+	def ClassDef(name: ast_Identifier, listBases: list[ast.expr]=[], list_keyword: list[ast.keyword]=[], body: list[ast.stmt]=[], decorator_list: list[ast.expr]=[], **keywordArguments: list_ast_type_paramORstr_orNone) -> ast.ClassDef:
+		return ast.ClassDef(name, listBases, list_keyword, body, decorator_list, **keywordArguments)
+	@staticmethod
+	def Constant(value: Any, **keywordArguments: intORstr_orNone) -> ast.Constant:
+		"""value: str|int|float|bool|None|bytes|bytearray|memoryview|complex|list|tuple|dict|set, or any other type that can be represented as a constant in Python."""
+		return ast.Constant(value, **keywordArguments)
+	@staticmethod
+	def Expr(value: ast.expr, **keywordArguments: int) -> ast.Expr:
+		return ast.Expr(value, **keywordArguments)
+	@staticmethod
+	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)
+	@staticmethod
+	def ImportFrom(moduleIdentifier: ast_Identifier, list_astAlias: list[ast.alias], **keywordArguments: int) -> ast.ImportFrom:
+		return ast.ImportFrom(moduleIdentifier, list_astAlias, **keywordArguments)
+	@staticmethod
+	def keyword(keywordArgument: ast_Identifier, value: ast.expr, **keywordArguments: int) -> ast.keyword:
+		return ast.keyword(arg=keywordArgument, value=value, **keywordArguments)
+	@staticmethod
+	def Module(body: list[ast.stmt] = [], type_ignores: list[ast.TypeIgnore] = []) -> ast.Module:
+		return ast.Module(body, type_ignores)
+	@staticmethod
+	def Name(identifier: ast_Identifier, context: ast.expr_context = ast.Load(), **keywordArguments: int) -> ast.Name:
+		return ast.Name(identifier, context, **keywordArguments)
+	@staticmethod
+	def Return(value: ast.expr | None = None, **keywordArguments: int) -> ast.Return:
+		return ast.Return(value, **keywordArguments)
+	@staticmethod
+	def Subscript(value: ast.expr, slice: ast_expr_Slice, context: ast.expr_context = ast.Load(), **keywordArguments: int) -> ast.Subscript:
+		return ast.Subscript(value, slice, context, **keywordArguments)
+	@staticmethod
+	def Tuple(elements: Sequence[ast.expr] = [], context: ast.expr_context = ast.Load(), **keywordArguments: int) -> ast.Tuple:
+		return ast.Tuple(list(elements), context, **keywordArguments)

mapfolding-0.8.4/mapFolding/someAssemblyRequired/_tool_Then.py

@@ -0,0 +1,65 @@
+from collections.abc import Callable, Sequence
+from mapFolding.someAssemblyRequired import ast_Identifier, astClassHasDOTvalue, astMosDef
+from typing import Any
+import ast
+
+class Then:
+	@staticmethod
+	def allOf(listActions: Sequence[Callable[[ast.AST], Any]]) -> Callable[[ast.AST], ast.AST]:
+		def workhorse(node: ast.AST) -> ast.AST:
+			for action in listActions: action(node)
+			return node
+		return workhorse
+
+	@staticmethod
+	def appendTo(listOfAny: list[Any]) -> Callable[[ast.AST], None]:
+		return lambda node: listOfAny.append(node)
+
+	@staticmethod
+	def DOTarg(action: Callable[[Any], Any]) -> Callable[[ast.arg | ast.keyword], ast.arg | ast.keyword]:
+		def workhorse(node: ast.arg | ast.keyword) -> ast.arg | ast.keyword:
+			node.arg = action(node.arg)
+			return node
+		return workhorse
+	@staticmethod
+	def DOTfunc(action: Callable[[Any], Any]) -> Callable[[ast.Call], ast.Call]:
+		def workhorse(node: ast.Call) -> ast.Call:
+			node.func = action(node.func)
+			return node
+		return workhorse
+	@staticmethod
+	def DOTid(action: Callable[[Any], Any]) -> Callable[[ast.Name], ast.Name]:
+		def workhorse(node: ast.Name) -> ast.Name:
+			node.id = action(node.id)
+			return node
+		return workhorse
+	@staticmethod
+	def DOTtarget(action: Callable[[Any], Any]) -> Callable[[ast.AnnAssign | ast.AugAssign], ast.AnnAssign | ast.AugAssign]:
+		def workhorse(node: ast.AnnAssign | ast.AugAssign) -> ast.AnnAssign | ast.AugAssign:
+			node.target = action(node.target)
+			return node
+		return workhorse
+	@staticmethod
+	def DOTvalue(action: Callable[[Any], Any]) -> Callable[[astClassHasDOTvalue], astClassHasDOTvalue]:
+		def workhorse(node: astClassHasDOTvalue) -> astClassHasDOTvalue:
+			node.value = action(node.value)
+			return node
+		return workhorse
+
+	@staticmethod
+	def getIt(node: ast.AST) -> ast.AST | ast_Identifier:
+		return node
+	@staticmethod
+	def insertThisAbove(list_astAST: Sequence[ast.AST]) -> Callable[[ast.AST], Sequence[ast.AST]]:
+		return lambda aboveMe: [*list_astAST, aboveMe]
+	@staticmethod
+	def insertThisBelow(list_astAST: Sequence[ast.AST]) -> Callable[[ast.AST], Sequence[ast.AST]]:
+		return lambda belowMe: [belowMe, *list_astAST]
+	@staticmethod
+	def removeIt(_node: ast.AST) -> None: return None
+	@staticmethod
+	def replaceWith(astAST: ast.AST | ast_Identifier) -> Callable[[ast.AST], ast.AST | ast_Identifier]:
+		return lambda _replaceMe: astAST
+	@staticmethod
+	def updateThis(dictionaryOf_astMosDef: dict[ast_Identifier, astMosDef]) -> Callable[[astMosDef], astMosDef]:
+		return lambda node: dictionaryOf_astMosDef.setdefault(node.name, node)