mapFolding 0.9.0__py3-none-any.whl → 0.9.2__py3-none-any.whl

mapFolding/oeis.py

@@ -1,23 +1,21 @@
 """
 Interface to The Online Encyclopedia of Integer Sequences (OEIS) for map folding sequences.
 
-This module provides a comprehensive interface for accessing and utilizing integer sequences
-from the OEIS that relate to map folding problems. It serves as the bridge between
-mathematical sequence definitions and the computational algorithm, implementing:
+This module provides a comprehensive interface for accessing and utilizing integer sequences from the OEIS that relate
+to map folding problems. It serves as the bridge between mathematical sequence definitions and the computational
+algorithm, implementing:
 
 1. Retrieval of sequence data from OEIS with local caching for performance optimization.
 2. Mapping of sequence indices to corresponding map shapes based on sequence definitions.
 3. Command-line and programmatic interfaces for sequence lookups and validation.
 4. Computation of sequence terms not available in the OEIS database.
 
-The module maintains a registry of implemented OEIS sequences (A001415-A001418, A195646)
-with their metadata, known values, and conversion functions between sequence indices and
-map dimensions. This allows the package to validate results against established mathematical
-literature while also extending sequences beyond their currently known terms.
+The module maintains a registry of implemented OEIS sequences (A001415-A001418, A195646) with their metadata, known
+values, and conversion functions between sequence indices and map dimensions. This allows the package to validate
+results against established mathematical literature while also extending sequences beyond their currently known terms.
 
-Each sequence is carefully mapped to its corresponding map folding problem, enabling
-seamless integration between the mathematical definition in OEIS and the computational
-implementation in the package.
+Each sequence is carefully mapped to its corresponding map folding problem, enabling seamless integration between the
+mathematical definition in OEIS and the computational implementation in the package.
 """
 from collections.abc import Callable
 from datetime import datetime, timedelta
@@ -59,14 +57,20 @@ class SettingsOEIShardcodedValues(TypedDict):
 	valuesTestValidation: list[int]
 
 settingsOEIShardcodedValues: dict[str, SettingsOEIShardcodedValues] = {
+	'A000136': {
+		'getMapShape': lambda n: tuple(sorted([1, n])),
+		'valuesBenchmark': [14],
+		'valuesTestParallelization': [*range(3, 7)],
+		'valuesTestValidation': [random.randint(2, 9)],
+	},
 	'A001415': {
-		'getMapShape': lambda n: (2, n) if n >= 2 else (n, 2),
+		'getMapShape': lambda n: tuple(sorted([2, n])),
 		'valuesBenchmark': [14],
 		'valuesTestParallelization': [*range(3, 7)],
 		'valuesTestValidation': [random.randint(2, 9)],
 	},
 	'A001416': {
-		'getMapShape': lambda n: (3, n) if n >= 3 else (n, 3),
+		'getMapShape': lambda n: tuple(sorted([3, n])),
 		'valuesBenchmark': [9],
 		'valuesTestParallelization': [*range(3, 5)],
 		'valuesTestValidation': [random.randint(2, 6)],
@@ -98,10 +102,8 @@ def validateOEISid(oeisIDcandidate: str) -> str:
 	"""
 	Validates an OEIS sequence ID against implemented sequences.
 
-	If the provided ID is recognized within the application's implemented
-	OEIS sequences, the function returns the verified ID in uppercase.
-	Otherwise, a KeyError is raised indicating that the sequence is not
-	directly supported.
+	If the provided ID is recognized within the application's implemented OEIS sequences, the function returns the
+	verified ID in uppercase. Otherwise, a KeyError is raised indicating that the sequence is not directly supported.
 
 	Parameters:
 		oeisIDcandidate: The OEIS sequence identifier to validate.
@@ -132,25 +134,23 @@ def _parseBFileOEIS(OEISbFile: str, oeisID: str) -> dict[int, int]:
 	"""
 	Parses the content of an OEIS b-file for a given sequence ID.
 
-	This function processes a multiline string representing an OEIS b-file and
-	creates a dictionary mapping integer indices to their corresponding sequence
-	values. The first line of the b-file is expected to contain a comment that
+	This function processes a multiline string representing an OEIS b-file and creates a dictionary mapping integer
+	indices to their corresponding sequence values. The first line of the b-file is expected to contain a comment that
 	matches the given sequence ID. If it does not match, a ValueError is raised.
 
 	Parameters:
-		OEISbFile: A multiline string representing an OEIS b-file.
-		oeisID: The expected OEIS sequence identifier.
+		OEISbFile: A multiline string representing an OEIS b-file. oeisID: The expected OEIS sequence identifier.
 	Returns:
-		OEISsequence: A dictionary where each key is an integer index `n` and
-		each value is the sequence value `a(n)` corresponding to that index.
+		OEISsequence: A dictionary where each key is an integer index `n` and each value is the sequence value `a(n)`
+		corresponding to that index.
 	Raises:
-		ValueError: If the first line of the file does not indicate the expected
-		sequence ID or if the content format is invalid.
+		ValueError: If the first line of the file does not indicate the expected sequence ID or if the content format is
+		invalid.
 	"""
 	bFileLines: list[str] = OEISbFile.strip().splitlines()
-	if not bFileLines.pop(0).startswith(f"# {oeisID}"):
-		warnings.warn(f"Content does not match sequence {oeisID}")
-		return {-1: -1}
+	# if not bFileLines.pop(0).startswith(f"# {oeisID}"):
+	# 	warnings.warn(f"Content does not match sequence {oeisID}")
+	# 	return {-1: -1}
 
 	OEISsequence: dict[int, int] = {}
 	for line in bFileLines:
@@ -164,23 +164,21 @@ def getOEISofficial(pathFilenameCache: Path, url: str) -> None | str:
 	"""
 	Retrieve OEIS sequence data from cache or online source.
 
-	This function implements a caching strategy for OEIS sequence data, first checking
-	if a local cached copy exists and is not expired. If a valid cache exists, it returns
-	the cached content; otherwise, it fetches the data from the OEIS website and
-	writes it to the cache for future use.
+	This function implements a caching strategy for OEIS sequence data, first checking if a local cached copy exists and
+	is not expired. If a valid cache exists, it returns the cached content; otherwise, it fetches the data from the OEIS
+	website and writes it to the cache for future use.
 
 	Parameters:
-		pathFilenameCache: Path to the local cache file.
-		url: URL to retrieve the OEIS sequence data from if cache is invalid or missing.
+		pathFilenameCache: Path to the local cache file. url: URL to retrieve the OEIS sequence data from if cache is
+		invalid or missing.
 
 	Returns:
-		oeisInformation: The retrieved OEIS sequence information as a string, or None if
-		the information could not be retrieved.
+		oeisInformation: The retrieved OEIS sequence information as a string, or None if the information could not be
+		retrieved.
 
 	Notes:
-		The cache expiration period is controlled by the global `cacheDays` variable.
-		If the function fails to retrieve data from both cache and online source,
-		it will return None and issue a warning.
+		The cache expiration period is controlled by the global `cacheDays` variable. If the function fails to retrieve
+		data from both cache and online source, it will return None and issue a warning.
 	"""
 	tryCache: bool = False
 	if pathFilenameCache.exists():
@@ -207,22 +205,20 @@ def getOEISofficial(pathFilenameCache: Path, url: str) -> None | str:
 
 def getOEISidValues(oeisID: str) -> dict[int, int]:
 	"""
-	Retrieves the specified OEIS sequence as a dictionary mapping integer indices
-	to their corresponding values.
+	Retrieves the specified OEIS sequence as a dictionary mapping integer indices to their corresponding values.
 
-	This function checks for a cached local copy of the sequence data, using it if
-	it has not expired. Otherwise, it fetches the sequence data from the OEIS
-	website and writes it to the cache. The parsed data is returned as a dictionary
-	mapping each index to its sequence value.
+	This function checks for a cached local copy of the sequence data, using it if it has not expired. Otherwise, it
+	fetches the sequence data from the OEIS website and writes it to the cache. The parsed data is returned as a
+	dictionary mapping each index to its sequence value.
 
 	Parameters:
 		oeisID: The identifier of the OEIS sequence to retrieve.
 	Returns:
-		OEISsequence: A dictionary where each key is an integer index, `n`, and each
-		value is the corresponding `a(n)` from the OEIS entry.
+		OEISsequence: A dictionary where each key is an integer index, `n`, and each value is the corresponding `a(n)`
+		from the OEIS entry.
 	Raises:
-		ValueError: If the cached or downloaded file format is invalid.
-		IOError: If there is an error reading from or writing to the local cache.
+		ValueError: If the cached or downloaded file format is invalid. IOError: If there is an error reading from or
+		writing to the local cache.
 	"""
 
 	pathFilenameCache: Path = pathCache / getFilenameOEISbFile(oeisID)
@@ -238,23 +234,19 @@ def getOEISidInformation(oeisID: str) -> tuple[str, int]:
 	"""
 	Retrieve the description and offset for an OEIS sequence.
 
-	This function fetches the metadata for a given OEIS sequence ID, including
-	its textual description and index offset value. It uses a caching mechanism
-	to avoid redundant network requests while ensuring data freshness.
+	This function fetches the metadata for a given OEIS sequence ID, including its textual description and index offset
+	value. It uses a caching mechanism to avoid redundant network requests while ensuring data freshness.
 
 	Parameters:
 		oeisID: The OEIS sequence identifier to retrieve information for.
 
 	Returns:
-		A tuple containing:
-		- description: A string describing the sequence's mathematical meaning.
-		- offset: An integer representing the starting index of the sequence.
-		  Usually 0 or 1, depending on the mathematical context.
+		A tuple containing: - description: A string describing the sequence's mathematical meaning. - offset: An integer
+		representing the starting index of the sequence. Usually 0 or 1, depending on the mathematical context.
 
 	Notes:
-		Sequence descriptions are parsed from the machine-readable format of OEIS.
-		If information cannot be retrieved, warning messages are issued and
-		fallback values are returned.
+		Sequence descriptions are parsed from the machine-readable format of OEIS. If information cannot be retrieved,
+		warning messages are issued and fallback values are returned.
 	"""
 	oeisID = validateOEISid(oeisID)
 	pathFilenameCache: Path = pathCache / f"{oeisID}.txt"
@@ -287,23 +279,23 @@ def getOEISidInformation(oeisID: str) -> tuple[str, int]:
 def makeSettingsOEIS() -> dict[str, SettingsOEIS]:
 	"""
 	Construct the comprehensive settings dictionary for all implemented OEIS sequences.
-	
-	This function builds a complete configuration dictionary for all supported OEIS 
-	sequences by retrieving and combining:
+
+	This function builds a complete configuration dictionary for all supported OEIS sequences by retrieving and
+	combining:
 	1. Sequence values from OEIS b-files
 	2. Sequence metadata (descriptions and offsets)
 	3. Hardcoded mapping functions and test values
-	
-	The resulting dictionary provides a single authoritative source for all OEIS-related 
-	configurations used throughout the package, including:
+
+	The resulting dictionary provides a single authoritative source for all OEIS-related configurations used throughout
+	the package, including:
 	- Mathematical descriptions of each sequence
 	- Functions to convert between sequence indices and map dimensions
 	- Known sequence values retrieved from OEIS
 	- Testing and benchmarking reference values
-	
+
 	Returns:
-		A dictionary mapping OEIS sequence IDs to their complete settings objects,
-		containing all metadata and known values needed for computation and validation.
+		A dictionary mapping OEIS sequence IDs to their complete settings objects, containing all metadata and known
+		values needed for computation and validation.
 	"""
 	settingsTarget: dict[str, SettingsOEIS] = {}
 	for oeisID in oeisIDsImplemented:
@@ -334,29 +326,28 @@ def makeDictionaryFoldsTotalKnown() -> dict[tuple[int, ...], int]:
 
 		for n, foldingsTotal in sequence.items():
 			mapShape = settings['getMapShape'](n)
-			mapShape = tuple(sorted(mapShape))
+			mapShape = tuple(mapShape)
 			dictionaryMapDimensionsToFoldsTotalKnown[mapShape] = foldingsTotal
 	return dictionaryMapDimensionsToFoldsTotalKnown
 
 def getFoldsTotalKnown(mapShape: tuple[int, ...]) -> int:
 	"""
 	Retrieve the known total number of foldings for a given map shape.
-	
-	This function looks up precalculated folding totals for specific map dimensions
-	from OEIS sequences. It serves as a rapid reference for known values without
-	requiring computation, and can be used to validate algorithm results.
-	
+
+	This function looks up precalculated folding totals for specific map dimensions from OEIS sequences. It serves as a
+	rapid reference for known values without requiring computation, and can be used to validate algorithm results.
+
 	Parameters:
 		mapShape: A tuple of integers representing the dimensions of the map.
-	
+
 	Returns:
-		foldingsTotal: The known total number of foldings for the given map shape,
-		or -1 if the map shape doesn't match any known values in the OEIS sequences.
-	
+		foldingsTotal: The known total number of foldings for the given map shape, or -1 if the map shape doesn't match
+		any known values in the OEIS sequences.
+
 	Notes:
-		The function uses a cached dictionary (via makeDictionaryFoldsTotalKnown) to
-		efficiently retrieve values without repeatedly parsing OEIS data. Map shape
-		tuples are sorted internally to ensure consistent lookup regardless of dimension order.
+		The function uses a cached dictionary (via makeDictionaryFoldsTotalKnown) to efficiently retrieve values without
+		repeatedly parsing OEIS data. Map shape tuples are sorted internally to ensure consistent lookup regardless of
+		dimension order.
 	"""
 	lookupFoldsTotal = makeDictionaryFoldsTotalKnown()
 	return lookupFoldsTotal.get(tuple(mapShape), -1)
@@ -389,15 +380,13 @@ def oeisIDfor_n(oeisID: str, n: int | Any) -> int:
 	Calculate `a(n)` of a sequence from "The On-Line Encyclopedia of Integer Sequences" (OEIS).
 
 	Parameters:
-		oeisID: The ID of the OEIS sequence.
-		n: A non-negative integer for which to calculate the sequence value.
+		oeisID: The ID of the OEIS sequence. n: A non-negative integer for which to calculate the sequence value.
 
 	Returns:
 		sequenceValue: `a(n)` of the OEIS sequence.
 
 	Raises:
-		ValueError: If `n` is negative.
-		KeyError: If the OEIS sequence ID is not directly implemented.
+		ValueError: If `n` is negative. KeyError: If the OEIS sequence ID is not directly implemented.
 	"""
 	oeisID = validateOEISid(oeisID)
 

mapFolding/reference/__init__.py

@@ -13,8 +13,8 @@ Categories of reference implementations:
    - foldings.AA - Reconstructed Atlas Autocode version with corrections
 
 2. Direct translations:
-   - lunnanWhile.py - Python translation using while loops
-   - lunnanNumpy.py - NumPy-based translation with array operations
+   - lunnonWhile.py - Python translation using while loops
+   - lunnonNumpy.py - NumPy-based translation with array operations
 
 3. Alternative implementations:
    - irvineJavaPort.py - Port from Sean A. Irvine's Java implementation

mapFolding/someAssemblyRequired/RecipeJob.py

@@ -0,0 +1,103 @@
+from mapFolding.someAssemblyRequired import ShatteredDataclass, ast_Identifier, parsePathFilename2astModule, str_nameDOTname
+from mapFolding.someAssemblyRequired.toolboxNumba import theNumbaFlow
+from mapFolding.someAssemblyRequired.transformationTools import shatter_dataclassesDOTdataclass
+from mapFolding.theSSOT import ComputationState, DatatypeElephino as TheDatatypeElephino, DatatypeFoldsTotal as TheDatatypeFoldsTotal, DatatypeLeavesTotal as TheDatatypeLeavesTotal
+from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal, getPathRootJobDEFAULT
+
+import dataclasses
+from pathlib import Path, PurePosixPath
+from typing import TypeAlias
+
+@dataclasses.dataclass
+class RecipeJob:
+	state: ComputationState
+	# TODO create function to calculate `foldsTotalEstimated`
+	foldsTotalEstimated: int = 0
+	shatteredDataclass: ShatteredDataclass = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
+
+	# ========================================
+	# Source
+	source_astModule = parsePathFilename2astModule(theNumbaFlow.pathFilenameSequential)
+	sourceCountCallable: ast_Identifier = theNumbaFlow.callableSequential
+
+	sourceLogicalPathModuleDataclass: str_nameDOTname = theNumbaFlow.logicalPathModuleDataclass
+	sourceDataclassIdentifier: ast_Identifier = theNumbaFlow.dataclassIdentifier
+	sourceDataclassInstance: ast_Identifier = theNumbaFlow.dataclassInstance
+
+	sourcePathPackage: PurePosixPath | None = theNumbaFlow.pathPackage
+	sourcePackageIdentifier: ast_Identifier | None = theNumbaFlow.packageIdentifier
+
+	# ========================================
+	# Filesystem (names of physical objects)
+	pathPackage: PurePosixPath | None = None
+	pathModule: PurePosixPath | None = PurePosixPath(getPathRootJobDEFAULT())
+	""" `pathModule` will override `pathPackage` and `logicalPathRoot`."""
+	fileExtension: str = theNumbaFlow.fileExtension
+	pathFilenameFoldsTotal: PurePosixPath = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
+
+	# ========================================
+	# Logical identifiers (as opposed to physical identifiers)
+	packageIdentifier: ast_Identifier | None = None
+	logicalPathRoot: str_nameDOTname | None = None
+	""" `logicalPathRoot` likely corresponds to a physical filesystem directory."""
+	moduleIdentifier: ast_Identifier = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
+	countCallable: ast_Identifier = sourceCountCallable
+	dataclassIdentifier: ast_Identifier | None = sourceDataclassIdentifier
+	dataclassInstance: ast_Identifier | None = sourceDataclassInstance
+	logicalPathModuleDataclass: str_nameDOTname | None = sourceLogicalPathModuleDataclass
+
+	# ========================================
+	# Datatypes
+	DatatypeFoldsTotal: TypeAlias = TheDatatypeFoldsTotal
+	DatatypeElephino: TypeAlias = TheDatatypeElephino
+	DatatypeLeavesTotal: TypeAlias = TheDatatypeLeavesTotal
+
+	def _makePathFilename(self,
+			pathRoot: PurePosixPath | None = None,
+			logicalPathINFIX: str_nameDOTname | None = None,
+			filenameStem: str | None = None,
+			fileExtension: str | None = None,
+			) -> PurePosixPath:
+		if pathRoot is None:
+			pathRoot = self.pathPackage or PurePosixPath(Path.cwd())
+		if logicalPathINFIX:
+			whyIsThisStillAThing: list[str] = logicalPathINFIX.split('.')
+			pathRoot = pathRoot.joinpath(*whyIsThisStillAThing)
+		if filenameStem is None:
+			filenameStem = self.moduleIdentifier
+		if fileExtension is None:
+			fileExtension = self.fileExtension
+		filename: str = filenameStem + fileExtension
+		return pathRoot.joinpath(filename)
+
+	@property
+	def pathFilenameModule(self) -> PurePosixPath:
+		if self.pathModule is None:
+			return self._makePathFilename()
+		else:
+			return self._makePathFilename(pathRoot=self.pathModule, logicalPathINFIX=None)
+
+	def __post_init__(self):
+		pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(self.state.mapShape))
+
+		if self.moduleIdentifier is None: # pyright: ignore[reportUnnecessaryComparison]
+			self.moduleIdentifier = pathFilenameFoldsTotal.stem
+
+		if self.pathFilenameFoldsTotal is None: # pyright: ignore[reportUnnecessaryComparison]
+			self.pathFilenameFoldsTotal = pathFilenameFoldsTotal
+
+		if self.shatteredDataclass is None and self.logicalPathModuleDataclass and self.dataclassIdentifier and self.dataclassInstance: # pyright: ignore[reportUnnecessaryComparison]
+			self.shatteredDataclass = shatter_dataclassesDOTdataclass(self.logicalPathModuleDataclass, self.dataclassIdentifier, self.dataclassInstance)
+
+	# ========================================
+	# Fields you probably don't need =================================
+	# Dispatcher =================================
+	sourceDispatcherCallable: ast_Identifier = theNumbaFlow.callableDispatcher
+	dispatcherCallable: ast_Identifier = sourceDispatcherCallable
+	# Parallel counting =================================
+	sourceDataclassInstanceTaskDistribution: ast_Identifier = theNumbaFlow.dataclassInstanceTaskDistribution
+	sourceConcurrencyManagerNamespace: ast_Identifier = theNumbaFlow.concurrencyManagerNamespace
+	sourceConcurrencyManagerIdentifier: ast_Identifier = theNumbaFlow.concurrencyManagerIdentifier
+	dataclassInstanceTaskDistribution: ast_Identifier = sourceDataclassInstanceTaskDistribution
+	concurrencyManagerNamespace: ast_Identifier = sourceConcurrencyManagerNamespace
+	concurrencyManagerIdentifier: ast_Identifier = sourceConcurrencyManagerIdentifier

mapFolding/someAssemblyRequired/__init__.py

@@ -48,40 +48,42 @@ to verify correctness at each transformation stage through the integrated test s
 """
 
 from mapFolding.someAssemblyRequired._theTypes import (
-	ast_expr_Slice,
-	ast_Identifier,
-	astClassHasDOTnameNotName,
-	astClassHasDOTtarget,
-	astClassHasDOTvalue_expr,
-	astClassHasDOTvalue_exprNone,
-	astClassHasDOTtargetAttributeNameSubscript,
-	astClassHasDOTtarget_expr,
-	astClassHasDOTvalue,
-	astClassOptionallyHasDOTnameNotName,
-	intORlist_ast_type_paramORstr_orNone,
-	intORstr_orNone,
-	list_ast_type_paramORstr_orNone,
-	str_nameDOTname,
-	个,
+	ast_expr_Slice as ast_expr_Slice,
+	ast_Identifier as ast_Identifier,
+	astClassHasDOTnameNotName as astClassHasDOTnameNotName,
+	astClassHasDOTtarget as astClassHasDOTtarget,
+	astClassHasDOTtarget_expr as astClassHasDOTtarget_expr,
+	astClassHasDOTtargetAttributeNameSubscript as astClassHasDOTtargetAttributeNameSubscript,
+	astClassHasDOTvalue as astClassHasDOTvalue,
+	astClassHasDOTvalue_expr as astClassHasDOTvalue_expr,
+	astClassHasDOTvalue_exprNone as astClassHasDOTvalue_exprNone,
+	astClassOptionallyHasDOTnameNotName as astClassOptionallyHasDOTnameNotName,
+	ImaCallToName as ImaCallToName,
+	intORlist_ast_type_paramORstr_orNone as intORlist_ast_type_paramORstr_orNone,
+	intORstr_orNone as intORstr_orNone,
+	list_ast_type_paramORstr_orNone as list_ast_type_paramORstr_orNone,
+	NodeORattribute as NodeORattribute,
+	str_nameDOTname as str_nameDOTname,
+	个 as 个,
 	)
 
 from mapFolding.someAssemblyRequired._toolboxPython import (
-	importLogicalPath2Callable,
-	importPathFilename2Callable,
-	NodeChanger,
-	NodeTourist,
-	parseLogicalPath2astModule,
-	parsePathFilename2astModule,
+	importLogicalPath2Callable as importLogicalPath2Callable,
+	importPathFilename2Callable as importPathFilename2Callable,
+	NodeChanger as NodeChanger,
+	NodeTourist as NodeTourist,
+	parseLogicalPath2astModule as parseLogicalPath2astModule,
+	parsePathFilename2astModule as parsePathFilename2astModule,
 	)
 
-from mapFolding.someAssemblyRequired._toolboxAntecedents import DOT, ifThis
-from mapFolding.someAssemblyRequired._tool_Make import Make
-from mapFolding.someAssemblyRequired._tool_Then import grab, Then
+from mapFolding.someAssemblyRequired._toolboxAntecedents import be as be, DOT as DOT, ifThis as ifThis
+from mapFolding.someAssemblyRequired._tool_Make import Make as Make
+from mapFolding.someAssemblyRequired._tool_Then import grab as grab, Then as Then
 
 from mapFolding.someAssemblyRequired._toolboxContainers import (
-	IngredientsFunction,
-	IngredientsModule,
-	LedgerOfImports,
-	RecipeSynthesizeFlow,
-	ShatteredDataclass,
+	IngredientsFunction as IngredientsFunction,
+	IngredientsModule as IngredientsModule,
+	LedgerOfImports as LedgerOfImports,
+	RecipeSynthesizeFlow as RecipeSynthesizeFlow,
+	ShatteredDataclass as ShatteredDataclass,
 )

mapFolding/someAssemblyRequired/_theTypes.py

@@ -13,10 +13,17 @@ else:
 	astClassHasDOTnameNotName = stuPyd
 	astClassHasDOTvalue_expr = stuPyd
 
+class ImaCallToName(ast.Call):
+	func: ast.Name # pyright: ignore[reportIncompatibleVariableOverride]
+	# assert isinstance(ast.Call.func, ast.Name), "brinksmanship"
+	# func: ast.Name
+
 astClassHasDOTtargetAttributeNameSubscript: typing_TypeAlias = ast.AnnAssign | ast.AugAssign
 astClassHasDOTtarget_expr: typing_TypeAlias = ast.AsyncFor | ast.comprehension | ast.For
 astClassHasDOTtarget: typing_TypeAlias = ast.NamedExpr | astClassHasDOTtarget_expr | astClassHasDOTtargetAttributeNameSubscript
+
 astClassOptionallyHasDOTnameNotName: typing_TypeAlias = ast.ExceptHandler | ast.MatchAs | ast.MatchStar
+
 astClassHasDOTvalue_exprNone: typing_TypeAlias = ast.AnnAssign | ast.Return | ast.Yield
 astClassHasDOTvalue: typing_TypeAlias = ast.Constant | ast.MatchSingleton | astClassHasDOTvalue_expr | astClassHasDOTvalue_exprNone
 
@@ -27,7 +34,8 @@ intORstr_orNone: typing_TypeAlias = Any
 list_ast_type_paramORstr_orNone: typing_TypeAlias = Any
 str_nameDOTname: typing_TypeAlias = stuPyd
 
-个 = typing_TypeVar('个', bound= ast.AST, covariant=True)
+个 = typing_TypeVar('个', bound = ast.AST, covariant = True)
+NodeORattribute = typing_TypeVar('NodeORattribute', bound = ast.AST | ast_expr_Slice | ast_Identifier | str_nameDOTname | bool | Any | None, covariant = True)
 
 # All ast classes by subgroup:
 Ima_ast_boolop: typing_TypeAlias = ast.boolop | ast.And | ast.Or

mapFolding/someAssemblyRequired/_tool_Make.py

@@ -56,7 +56,7 @@ class Make:
 		return ast.arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults, kwarg, defaults)
 
 	@staticmethod
-	def Assign(listTargets: Any, value: ast.expr, **keywordArguments: intORstr_orNone) -> ast.Assign:
+	def Assign(listTargets: list[ast.expr], value: ast.expr, **keywordArguments: intORstr_orNone) -> ast.Assign:
 		return ast.Assign(listTargets, value, **keywordArguments)
 
 	@staticmethod
@@ -83,7 +83,6 @@ class Make:
 
 	@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

mapFolding/someAssemblyRequired/_tool_Then.py

@@ -15,7 +15,7 @@ once they have been identified using predicate functions from ifThis.
 """
 
 from collections.abc import Callable, Sequence
-from mapFolding.someAssemblyRequired import ast_Identifier, astClassHasDOTvalue
+from mapFolding.someAssemblyRequired import ast_Identifier, astClassHasDOTvalue, ImaCallToName, NodeORattribute
 from typing import Any
 import ast
 
@@ -46,6 +46,13 @@ class grab:
 			return node
 		return workhorse
 
+	@staticmethod
+	def funcDOTidAttribute(action: Callable[[ast_Identifier], Any]) -> Callable[[ImaCallToName], ImaCallToName]:
+		def workhorse(node: ImaCallToName) -> ImaCallToName:
+			node.func = grab.idAttribute(action)(node.func)
+			return node
+		return workhorse
+
 	@staticmethod
 	def idAttribute(action: Callable[[ast_Identifier], ast_Identifier]) -> Callable[[ast.Name], ast.Name]:
 		def workhorse(node: ast.Name) -> ast.Name:
@@ -54,7 +61,7 @@ class grab:
 		return workhorse
 
 	@staticmethod
-	def valueAttribute(action: Callable[[Any | ast.expr | bool | None], Any]) -> Callable[[astClassHasDOTvalue], astClassHasDOTvalue]:
+	def valueAttribute(action: Callable[[Any], Any]) -> Callable[[astClassHasDOTvalue], astClassHasDOTvalue]:
 		def workhorse(node: astClassHasDOTvalue) -> astClassHasDOTvalue:
 			node.value = action(node.value)
 			return node
@@ -73,14 +80,14 @@ class Then:
 	pattern-matching-and-action workflow for AST manipulation.
 	"""
 	@staticmethod
-	def appendTo(listOfAny: list[Any]) -> Callable[[ast.AST | ast_Identifier], list[Any]]:
-		def workhorse(node: ast.AST | ast_Identifier) -> list[Any]:
+	def appendTo(listOfAny: list[Any]) -> Callable[[ast.AST | ast_Identifier], ast.AST | ast_Identifier]:
+		def workhorse(node: ast.AST | ast_Identifier) -> ast.AST | ast_Identifier:
 			listOfAny.append(node)
-			return listOfAny
+			return node
 		return workhorse
 
 	@staticmethod
-	def extractIt(node: ast.AST) -> ast.AST | ast_Identifier:
+	def extractIt(node: NodeORattribute) -> NodeORattribute:
 		return node
 
 	@staticmethod
@@ -92,10 +99,11 @@ class Then:
 		return lambda belowMe: [belowMe, *list_astAST]
 
 	@staticmethod
-	def removeIt(_node: ast.AST) -> None: return None
+	def removeIt(_removeMe: ast.AST) -> None:
+		return None
 
 	@staticmethod
-	def replaceWith(astAST: Any) -> Callable[[Any], Any]:
+	def replaceWith(astAST: NodeORattribute) -> Callable[[NodeORattribute], NodeORattribute]:
 		return lambda _replaceMe: astAST
 
 	@staticmethod