mapFolding 0.9.1__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
@@ -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)
 

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

@@ -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), "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

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

mapFolding/someAssemblyRequired/_toolboxAntecedents.py

@@ -2,17 +2,22 @@
 AST Node Predicate and Access Utilities for Pattern Matching and Traversal
 
 This module provides utilities for accessing and matching AST nodes in a consistent way.
-It contains two primary classes:
+It contains three primary classes:
 
 1. DOT: Provides consistent accessor methods for AST node attributes across different
    node types, simplifying the access to node properties.
 
-2. ifThis: Contains predicate functions for matching AST nodes based on various criteria,
+2. be: Offers type-guard functions that verify AST node types, enabling safe type
+   narrowing for static type checking and improving code safety.
+
+3. ifThis: Contains predicate functions for matching AST nodes based on various criteria,
    enabling precise targeting of nodes for analysis or transformation.
 
 These utilities form the foundation of the pattern-matching component in the AST
 manipulation framework, working in conjunction with the NodeChanger and NodeTourist
-classes to enable precise and targeted code transformations.
+classes to enable precise and targeted code transformations. Together, they implement
+a declarative approach to AST manipulation that separates node identification (ifThis),
+type verification (be), and data access (DOT).
 """
 
 from collections.abc import Callable
@@ -26,6 +31,7 @@ from mapFolding.someAssemblyRequired import (
 	astClassHasDOTvalue_expr,
 	astClassOptionallyHasDOTnameNotName,
 	astClassHasDOTvalue_exprNone,
+	ImaCallToName,
 )
 from typing import Any, overload, TypeGuard
 import ast
@@ -65,9 +71,17 @@ class DOT:
 	@staticmethod
 	def attr(node: ast.Attribute) -> ast_Identifier:
 		return node.attr
+
+	@staticmethod
+	@overload
+	def func(node: ImaCallToName) -> ast.Name:...
 	@staticmethod
-	def func(node: ast.Call) -> ast.expr:
+	@overload
+	def func(node: ast.Call) -> ast.expr:...
+	@staticmethod
+	def func(node: ast.Call | ImaCallToName) -> ast.expr | ast.Name:
 		return node.func
+
 	@staticmethod
 	def id(node: ast.Name) -> ast_Identifier:
 		return node.id
@@ -111,6 +125,75 @@ class DOT:
 	def value(node: astClassHasDOTvalue) -> Any | ast.expr | bool | None:
 		return node.value
 
+class be:
+	"""
+	Provide type-guard functions for safely verifying AST node types during manipulation.
+
+	The be class contains static methods that perform runtime type verification of AST nodes,
+	returning TypeGuard results that enable static type checkers to narrow node types in
+	conditional branches. These type-guards:
+
+	1. Improve code safety by preventing operations on incompatible node types
+	2. Enable IDE tooling to provide better autocompletion and error detection
+	3. Document expected node types in a way that's enforced by the type system
+	4. Support pattern-matching workflows where node types must be verified before access
+
+	When used with conditional statements, these type-guards allow for precise,
+	type-safe manipulation of AST nodes while maintaining full static type checking
+	capabilities, even in complex transformation scenarios.
+	"""
+	@staticmethod
+	def AnnAssign(node: ast.AST) -> TypeGuard[ast.AnnAssign]:
+		return isinstance(node, ast.AnnAssign)
+
+	@staticmethod
+	def arg(node: ast.AST) -> TypeGuard[ast.arg]:
+		return isinstance(node, ast.arg)
+
+	@staticmethod
+	def Assign(node: ast.AST) -> TypeGuard[ast.Assign]:
+		return isinstance(node, ast.Assign)
+
+	@staticmethod
+	def Attribute(node: ast.AST) -> TypeGuard[ast.Attribute]:
+		return isinstance(node, ast.Attribute)
+
+	@staticmethod
+	def AugAssign(node: ast.AST) -> TypeGuard[ast.AugAssign]:
+		return isinstance(node, ast.AugAssign)
+
+	@staticmethod
+	def Call(node: ast.AST) -> TypeGuard[ast.Call]:
+		return isinstance(node, ast.Call)
+
+	@staticmethod
+	def ClassDef(node: ast.AST) -> TypeGuard[ast.ClassDef]:
+		return isinstance(node, ast.ClassDef)
+
+	@staticmethod
+	def FunctionDef(node: ast.AST) -> TypeGuard[ast.FunctionDef]:
+		return isinstance(node, ast.FunctionDef)
+
+	@staticmethod
+	def keyword(node: ast.AST) -> TypeGuard[ast.keyword]:
+		return isinstance(node, ast.keyword)
+
+	@staticmethod
+	def Name(node: ast.AST) -> TypeGuard[ast.Name]:
+		return isinstance(node, ast.Name)
+
+	@staticmethod
+	def Return(node: ast.AST) -> TypeGuard[ast.Return]:
+		return isinstance(node, ast.Return)
+
+	@staticmethod
+	def Starred(node: ast.AST) -> TypeGuard[ast.Starred]:
+		return isinstance(node, ast.Starred)
+
+	@staticmethod
+	def Subscript(node: ast.AST) -> TypeGuard[ast.Subscript]:
+		return isinstance(node, ast.Subscript)
+
 class ifThis:
 	"""
 	Provide predicate functions for matching and filtering AST nodes based on various criteria.
@@ -135,41 +218,41 @@ class ifThis:
 	@staticmethod
 	def is_arg_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.arg] | bool]:
 		"""see also `isArgument_Identifier`"""
-		return lambda node: isinstance(node, ast.arg) and ifThis._Identifier(identifier)(DOT.arg(node))
+		return lambda node: be.arg(node) and ifThis._Identifier(identifier)(DOT.arg(node))
 	@staticmethod
 	def is_keyword_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.keyword] | bool]:
 		"""see also `isArgument_Identifier`"""
-		return lambda node: isinstance(node, ast.keyword) and ifThis._Identifier(identifier)(DOT.arg(node))
+		return lambda node: be.keyword(node) and ifThis._Identifier(identifier)(DOT.arg(node))
 
 	@staticmethod
 	def isAnnAssign_targetIs(targetPredicate: Callable[[ast.expr], TypeGuard[ast.expr] | bool]) -> Callable[[ast.AST], TypeGuard[ast.AnnAssign] | bool]:
 		def workhorse(node: ast.AST) -> TypeGuard[ast.AnnAssign] | bool:
-			return isinstance(node, ast.AnnAssign) and targetPredicate(DOT.target(node))
+			return be.AnnAssign(node) and targetPredicate(DOT.target(node))
 		return workhorse
 
 	@staticmethod
 	def isArgument_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.arg | ast.keyword] | bool]:
-		return lambda node: (isinstance(node, ast.arg) or isinstance(node, ast.keyword)) and ifThis._Identifier(identifier)(DOT.arg(node))
+		return lambda node: (be.arg(node) or be.keyword(node)) and ifThis._Identifier(identifier)(DOT.arg(node))
 
 	@staticmethod
 	def isAssignAndTargets0Is(targets0Predicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], TypeGuard[ast.AnnAssign] | bool]:
 		"""node is Assign and node.targets[0] matches `targets0Predicate`."""
-		return lambda node: isinstance(node, ast.Assign) and targets0Predicate(node.targets[0])
+		return lambda node: be.Assign(node) and targets0Predicate(node.targets[0])
 	@staticmethod
 	def isAssignAndValueIs(valuePredicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], TypeGuard[ast.Assign] | bool]:
 		"""node is ast.Assign and node.value matches `valuePredicate`. """
-		return lambda node: isinstance(node, ast.Assign) and valuePredicate(DOT.value(node))
+		return lambda node: be.Assign(node) and valuePredicate(DOT.value(node))
 
 	@staticmethod
 	def isAttribute_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Attribute] | bool]:
 		"""node is `ast.Attribute` and the top-level `ast.Name` is `identifier`"""
 		def workhorse(node: ast.AST) -> TypeGuard[ast.Attribute]:
-			return isinstance(node, ast.Attribute) and ifThis._nested_Identifier(identifier)(DOT.value(node))
+			return be.Attribute(node) and ifThis._nested_Identifier(identifier)(DOT.value(node))
 		return workhorse
 	@staticmethod
 	def isAttributeName(node: ast.AST) -> TypeGuard[ast.Attribute]:
 		""" Displayed as Name.attribute."""
-		return isinstance(node, ast.Attribute) and isinstance(DOT.value(node), ast.Name)
+		return be.Attribute(node) and be.Name(DOT.value(node))
 	@staticmethod
 	def isAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Attribute] | bool]:
 		return lambda node: ifThis.isAttributeName(node) and ifThis.isName_Identifier(namespace)(DOT.value(node)) and ifThis._Identifier(identifier)(DOT.attr(node))
@@ -177,42 +260,47 @@ class ifThis:
 	@staticmethod
 	def isAugAssign_targetIs(targetPredicate: Callable[[ast.expr], TypeGuard[ast.expr] | bool]) -> Callable[[ast.AST], TypeGuard[ast.AugAssign] | bool]:
 		def workhorse(node: ast.AST) -> TypeGuard[ast.AugAssign] | bool:
-			return isinstance(node, ast.AugAssign) and targetPredicate(DOT.target(node))
+			return be.AugAssign(node) and targetPredicate(DOT.target(node))
 		return workhorse
 
 	@staticmethod
-	def isCall_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Call] | bool]:
-		return lambda node: isinstance(node, ast.Call) and ifThis.isName_Identifier(identifier)(DOT.func(node))
+	def isCall_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ImaCallToName] | bool]:
+		def workhorse(node: ast.AST) -> TypeGuard[ImaCallToName] | bool:
+			return ifThis.isCallToName(node) and ifThis._Identifier(identifier)(DOT.id(DOT.func(node)))
+		return workhorse
+
 	@staticmethod
 	def isCallAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Call] | bool]:
-		return lambda node: isinstance(node, ast.Call) and ifThis.isAttributeNamespace_Identifier(namespace, identifier)(DOT.func(node))
+		def workhorse(node: ast.AST) -> TypeGuard[ast.Call] | bool:
+			return be.Call(node) and ifThis.isAttributeNamespace_Identifier(namespace, identifier)(DOT.func(node))
+		return workhorse
 	@staticmethod
-	def isCallToName(node: ast.AST) -> TypeGuard[ast.Call]:
-		return isinstance(node, ast.Call) and isinstance(DOT.func(node), ast.Name)
+	def isCallToName(node: ast.AST) -> TypeGuard[ImaCallToName]:
+		return be.Call(node) and be.Name(DOT.func(node))
 
 	@staticmethod
 	def isClassDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.ClassDef] | bool]:
-		return lambda node: isinstance(node, ast.ClassDef) and ifThis._Identifier(identifier)(DOT.name(node))
+		return lambda node: be.ClassDef(node) and ifThis._Identifier(identifier)(DOT.name(node))
 
 	@staticmethod
 	def isFunctionDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.FunctionDef] | bool]:
-		return lambda node: isinstance(node, ast.FunctionDef) and ifThis._Identifier(identifier)(DOT.name(node))
+		return lambda node: be.FunctionDef(node) and ifThis._Identifier(identifier)(DOT.name(node))
 
 	@staticmethod
 	def isName_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Name] | bool]:
-		return lambda node: isinstance(node, ast.Name) and ifThis._Identifier(identifier)(DOT.id(node))
+		return lambda node: be.Name(node) and ifThis._Identifier(identifier)(DOT.id(node))
 
 	@staticmethod
 	def isStarred_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Starred] | bool]:
 		"""node is `ast.Starred` and the top-level `ast.Name` is `identifier`"""
 		def workhorse(node: ast.AST) -> TypeGuard[ast.Starred]:
-			return isinstance(node, ast.Starred) and ifThis._nested_Identifier(identifier)(DOT.value(node))
+			return be.Starred(node) and ifThis._nested_Identifier(identifier)(DOT.value(node))
 		return workhorse
 	@staticmethod
 	def isSubscript_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Subscript] | bool]:
 		"""node is `ast.Subscript` and the top-level `ast.Name` is `identifier`"""
 		def workhorse(node: ast.AST) -> TypeGuard[ast.Subscript]:
-			return isinstance(node, ast.Subscript) and ifThis._nested_Identifier(identifier)(DOT.value(node))
+			return be.Subscript(node) and ifThis._nested_Identifier(identifier)(DOT.value(node))
 		return workhorse
 
 	@staticmethod
@@ -231,15 +319,3 @@ class ifThis:
 	def Z0Z_unparseIs(astAST: ast.AST) -> Callable[[ast.AST], bool]:
 		def workhorse(node: ast.AST) -> bool: return ast.unparse(node) == ast.unparse(astAST)
 		return workhorse
-
-
-class be:
-	@staticmethod
-	def Call(node: ast.AST) -> TypeGuard[ast.Call]:
-		return isinstance(node, ast.Call)
-	@staticmethod
-	def Name(node: ast.AST) -> TypeGuard[ast.Name]:
-		return isinstance(node, ast.Name)
-	@staticmethod
-	def Return(node: ast.AST) -> TypeGuard[ast.Return]:
-		return isinstance(node, ast.Return)

mapFolding/someAssemblyRequired/_toolboxContainers.py

@@ -251,7 +251,6 @@ class IngredientsModule:
 	def appendIngredientsFunction(self, *ingredientsFunction: IngredientsFunction) -> None:
 		"""Append one or more `IngredientsFunction`."""
 		for allegedIngredientsFunction in ingredientsFunction:
-			assert isinstance(allegedIngredientsFunction, IngredientsFunction), ValueError(f"I received `{type(allegedIngredientsFunction) = }`, but I can only accept `{IngredientsFunction}`.")
 			self.listIngredientsFunctions.append(allegedIngredientsFunction)
 
 	def removeImportFromModule(self, moduleWithLogicalPath: str_nameDOTname) -> None: