mapFolding 0.9.1__py3-none-any.whl → 0.9.3__py3-none-any.whl

mapFolding/dataBaskets.py

@@ -0,0 +1,49 @@
+from mapFolding.beDRY import getConnectionGraph, getLeavesTotal, makeDataContainer
+from mapFolding.datatypes import Array3D, Array1DElephino, Array1DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
+import dataclasses
+
+@dataclasses.dataclass
+class MapFoldingState:
+	mapShape: tuple[DatatypeLeavesTotal, ...] = dataclasses.field(init=True, metadata={'elementConstructor': 'DatatypeLeavesTotal'})
+
+	groupsOfFolds: DatatypeFoldsTotal = dataclasses.field(default=DatatypeFoldsTotal(0), metadata={'theCountingIdentifier': True})
+
+	gap1ndex: DatatypeElephino = DatatypeElephino(0)
+	gap1ndexCeiling: DatatypeElephino = DatatypeElephino(0)
+	indexDimension: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+	indexLeaf: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+	indexMiniGap: DatatypeElephino = DatatypeElephino(0)
+	leaf1ndex: DatatypeLeavesTotal = DatatypeLeavesTotal(1)
+	leafConnectee: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+
+	dimensionsUnconstrained: DatatypeLeavesTotal = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+
+	countDimensionsGapped: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	gapRangeStart: Array1DElephino = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DElephino.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	gapsWhere: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	leafAbove: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	leafBelow: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+
+	connectionGraph: Array3D = dataclasses.field(init=False, metadata={'dtype': Array3D.__args__[1].__args__[0]}) # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
+	dimensionsTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
+	leavesTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
+
+	@property
+	def foldsTotal(self) -> DatatypeFoldsTotal:
+		_foldsTotal = DatatypeFoldsTotal(self.leavesTotal) * self.groupsOfFolds
+		return _foldsTotal
+
+	def __post_init__(self) -> None:
+		self.dimensionsTotal = DatatypeLeavesTotal(len(self.mapShape))
+		self.leavesTotal = DatatypeLeavesTotal(getLeavesTotal(self.mapShape))
+
+		leavesTotalAsInt = int(self.leavesTotal)
+
+		self.connectionGraph = getConnectionGraph(self.mapShape, leavesTotalAsInt, self.__dataclass_fields__['connectionGraph'].metadata['dtype'])
+
+		if self.dimensionsUnconstrained is None: self.dimensionsUnconstrained = DatatypeLeavesTotal(int(self.dimensionsTotal)) # pyright: ignore[reportUnnecessaryComparison]
+		if self.gapsWhere is None: self.gapsWhere = makeDataContainer(leavesTotalAsInt * leavesTotalAsInt + 1, self.__dataclass_fields__['gapsWhere'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
+		if self.countDimensionsGapped is None: self.countDimensionsGapped = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['countDimensionsGapped'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
+		if self.gapRangeStart is None: self.gapRangeStart = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['gapRangeStart'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
+		if self.leafAbove is None: self.leafAbove = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafAbove'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
+		if self.leafBelow is None: self.leafBelow = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafBelow'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]

mapFolding/datatypes.py

@@ -0,0 +1,21 @@
+from numpy import dtype, int64 as numpy_int64, integer, ndarray
+from typing import Any, TypeAlias, TypeVar
+
+# =============================================================================
+# Flexible Data Structure System Needs Enhanced Paradigm https://github.com/hunterhogan/mapFolding/issues/9
+
+NumPyIntegerType = TypeVar('NumPyIntegerType', bound=integer[Any], covariant=True)
+
+DatatypeLeavesTotal: TypeAlias = int
+NumPyLeavesTotal: TypeAlias = numpy_int64
+
+DatatypeElephino: TypeAlias = int
+NumPyElephino: TypeAlias = numpy_int64
+
+DatatypeFoldsTotal: TypeAlias = int
+NumPyFoldsTotal: TypeAlias = numpy_int64
+
+Array3D: TypeAlias = ndarray[tuple[int, int, int], dtype[NumPyLeavesTotal]]
+Array1DLeavesTotal: TypeAlias = ndarray[tuple[int], dtype[NumPyLeavesTotal]]
+Array1DElephino: TypeAlias = ndarray[tuple[int], dtype[NumPyElephino]]
+Array1DFoldsTotal: TypeAlias = ndarray[tuple[int], dtype[NumPyFoldsTotal]]

mapFolding/oeis.py

@@ -1,28 +1,26 @@
 """
 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
 from functools import cache
-from mapFolding import writeStringToHere, The
+from mapFolding import countFolds, The, writeStringToHere
 from pathlib import Path
 from typing import Any, Final, TYPE_CHECKING
 import argparse
@@ -104,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.
@@ -138,20 +134,18 @@ 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}"):
@@ -170,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():
@@ -213,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)
@@ -244,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"
@@ -294,22 +280,22 @@ 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:
@@ -340,7 +326,7 @@ 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
 
@@ -348,21 +334,20 @@ 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)
@@ -395,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)
 
@@ -418,7 +401,6 @@ def oeisIDfor_n(oeisID: str, n: int | Any) -> int:
 			raise ArithmeticError(f"OEIS sequence {oeisID} is not defined at {n = }.")
 		foldsTotal: int = settingsOEIS[oeisID]['valuesKnown'][n]
 		return foldsTotal
-	from mapFolding.basecamp import countFolds
 	return countFolds(mapShape)
 
 def OEIS_for_n() -> None:

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/__init__.py

@@ -22,7 +22,7 @@ functional implementations into highly-optimized variants with verified correctn
    - Recipe configuration for generating optimized code (RecipeSynthesizeFlow)
    - Dataclass decomposition for compatibility (ShatteredDataclass)
 
-3. **Optimization Pipelines**
+3. **Optimization assembly lines**
    - General-purpose Numba acceleration (makeNumbaFlow)
    - Job-specific optimization for concrete parameters (makeJobNumba)
    - Specialized component transformation (decorateCallableWithNumba)
@@ -52,15 +52,17 @@ from mapFolding.someAssemblyRequired._theTypes import (
 	ast_Identifier as ast_Identifier,
 	astClassHasDOTnameNotName as astClassHasDOTnameNotName,
 	astClassHasDOTtarget as astClassHasDOTtarget,
-	astClassHasDOTvalue_expr as astClassHasDOTvalue_expr,
-	astClassHasDOTvalue_exprNone as astClassHasDOTvalue_exprNone,
-	astClassHasDOTtargetAttributeNameSubscript as astClassHasDOTtargetAttributeNameSubscript,
 	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 个,
 	)

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), "brinkmanship"
+	# 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

@@ -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