mapFolding 0.8.3__py3-none-any.whl → 0.8.4__py3-none-any.whl

mapFolding/someAssemblyRequired/_toolboxAntecedents.py

@@ -0,0 +1,326 @@
+from collections.abc import Callable, Container
+from mapFolding.someAssemblyRequired import ast_expr_Slice, ast_Identifier, astClassHasDOTnameNotName, astClassHasDOTtarget, astClassHasDOTvalue, ImaAnnotationType, typeCertified
+from typing import Any, overload, TypeGuard
+import ast
+
+Ima_targetType = ast.AST
+
+class 又:
+	@staticmethod
+	@overload
+	def annotation(predicate: Callable[[ImaAnnotationType], ast.AST | ast_Identifier]) -> Callable[[ast.AnnAssign | ast.arg], ast.AST | ast_Identifier]:...
+	@staticmethod
+	@overload
+	def annotation(predicate: Callable[[ImaAnnotationType], TypeGuard[ImaAnnotationType] | bool]) -> Callable[[ast.AnnAssign | ast.arg], TypeGuard[ast.AnnAssign] | TypeGuard[ast.arg] | bool]:...
+	@staticmethod
+	def annotation(predicate: Callable[[ImaAnnotationType], TypeGuard[ImaAnnotationType] | ast.AST | ast_Identifier | bool]) -> Callable[[ast.AnnAssign | ast.arg], TypeGuard[ast.AnnAssign] | TypeGuard[ast.arg] | ast.AST | ast_Identifier | bool]:
+		@overload
+		def workhorse(node: ast.AnnAssign | ast.arg) -> ast.AST | ast_Identifier:...
+		@overload
+		def workhorse(node: ast.AnnAssign | ast.arg) -> TypeGuard[ast.AnnAssign] | TypeGuard[ast.arg] | bool:...
+		def workhorse(node: ast.AnnAssign | ast.arg) -> TypeGuard[ast.AnnAssign] | TypeGuard[ast.arg] | ast.AST | ast_Identifier | bool:
+			ImaAnnotation = node.annotation
+			if ImaAnnotation is None: return False
+			assert be.Attribute(ImaAnnotation) or be.Constant(ImaAnnotation) or be.Name(ImaAnnotation) or be.Subscript(ImaAnnotation)
+			# assert be.Annotation(ImaAnnotation)
+			return predicate(ImaAnnotation)
+		return workhorse
+	@staticmethod
+	@overload
+	def arg(predicate: Callable[[ast_Identifier], ast.AST | ast_Identifier]) -> Callable[[ast.arg | ast.keyword], ast.AST | ast_Identifier]:...
+	@staticmethod
+	@overload
+	def arg(predicate: Callable[[ast_Identifier], TypeGuard[ast_Identifier] | bool]) -> Callable[[ast.arg | ast.keyword], TypeGuard[ast.arg] | TypeGuard[ast.keyword] | bool]:...
+	@staticmethod
+	def arg(predicate: Callable[[ast_Identifier], TypeGuard[ast_Identifier] | ast.AST | ast_Identifier | bool]) -> Callable[[ast.arg | ast.keyword], TypeGuard[ast.arg] | TypeGuard[ast.keyword] | ast.AST | ast_Identifier | bool]:
+		@overload
+		def workhorse(node: ast.arg | ast.keyword) -> ast.AST | ast_Identifier:...
+		@overload
+		def workhorse(node: ast.arg | ast.keyword) -> TypeGuard[ast.arg] | TypeGuard[ast.keyword] | bool:...
+		def workhorse(node: ast.arg | ast.keyword) -> TypeGuard[ast.arg] | TypeGuard[ast.keyword] | ast.AST | ast_Identifier | bool:
+			Ima_arg = node.arg
+			if Ima_arg is None: return False
+			return predicate(Ima_arg)
+		return workhorse
+	@staticmethod
+	def asname(predicate: Callable[[ast_Identifier | None], TypeGuard[ast_Identifier] | bool]) -> Callable[[ast.alias], TypeGuard[ast.alias] | bool]:
+		return lambda node: predicate(node.asname)
+	@staticmethod
+	def attr(predicate: Callable[[ast_Identifier], TypeGuard[ast_Identifier] | bool]) -> Callable[[ast.Attribute], TypeGuard[ast.Attribute] | bool]:
+		return lambda node: predicate(node.attr)
+	@staticmethod
+	def func(predicate: Callable[[ast.AST], TypeGuard[ast.AST] | bool]) -> Callable[[ast.Call], TypeGuard[ast.Call] | bool]:
+		return lambda node: predicate(node.func)
+	@staticmethod
+	def id(predicate: Callable[[ast_Identifier], TypeGuard[ast_Identifier] | bool]) -> Callable[[ast.Name], TypeGuard[ast.Name] | bool]:
+		return lambda node: predicate(node.id)
+	@staticmethod
+	def module(predicate: Callable[[ast_Identifier | None], TypeGuard[ast_Identifier] | bool]) -> Callable[[ast.ImportFrom], TypeGuard[ast.ImportFrom] | bool]:
+		return lambda node: predicate(node.module)
+	@staticmethod
+	def name(predicate: Callable[[ast_Identifier], TypeGuard[ast_Identifier] | bool]) -> Callable[[astClassHasDOTnameNotName], TypeGuard[astClassHasDOTnameNotName] | bool]:
+		return lambda node: predicate(node.name)
+	@staticmethod
+	def slice(predicate: Callable[[ast_expr_Slice], TypeGuard[ast_expr_Slice] | bool]) -> Callable[[ast.Subscript], TypeGuard[ast.Subscript] | bool]:
+		return lambda node: predicate(node.slice)
+	@staticmethod
+	def target(predicate: Callable[[ast.AST], TypeGuard[ast.AST] | bool]) -> Callable[[astClassHasDOTtarget], TypeGuard[astClassHasDOTtarget] | bool]:
+		return lambda node: predicate(node.target)
+	@staticmethod
+	def value(predicate: Callable[[ast.AST], TypeGuard[ast.AST] | bool]) -> Callable[[astClassHasDOTvalue], TypeGuard[astClassHasDOTvalue] | bool]:
+		def workhorse(node: astClassHasDOTvalue) -> TypeGuard[astClassHasDOTvalue] | bool:
+			ImaValue = node.value
+			if ImaValue is None: return False
+			return predicate(ImaValue)
+		return workhorse
+
+class be:
+	@staticmethod
+	def _typeCertified(antecedent: type[typeCertified]) -> Callable[[Any | None], TypeGuard[typeCertified]]:
+		def workhorse(node: Any | None) -> TypeGuard[typeCertified]:
+			return isinstance(node, antecedent)
+		return workhorse
+	@staticmethod
+	def AnnAssign(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.AnnAssign)(node)
+# 'TypeVar "typeCertified" appears only once in generic function signature. Use "object" instead Pylance(reportInvalidTypeVarUse)"' HOW THE FUCK IS THAT INVALID WHEN IT IS WORKING PERFECTLY TO PASS THE TYPE INFORMATION--IN YOUR FUCKING STATIC TYPE CHECKER, PYLANCE!!!! Fuck you, and fuck your pretentious language.
+	@staticmethod
+	def arg(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.arg)(node)
+
+	# @staticmethod
+	# def Annotation(node: ast.AST) -> TypeGuard[object] | bool:
+	# 	if be.Attribute(node):
+	# 		return be.Attribute(node)
+	# 	elif be.Constant(node):
+	# 		return be.Constant(node)
+	# 	elif be.Name(node):
+	# 		return be.Name(node)
+	# 	elif be.Subscript(node):
+	# 		return be.Subscript(node)
+	# 	else:
+	# 		return False
+		# return be.Attribute(node) or be.Constant(node) or be.Name(node) or be.Subscript(node)
+
+	@staticmethod
+	def Assign(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.Assign)(node)
+	@staticmethod
+	def Attribute(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.Attribute)(node)
+	@staticmethod
+	def AugAssign(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.AugAssign)(node)
+	@staticmethod
+	def BoolOp(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.BoolOp)(node)
+	@staticmethod
+	def Call(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.Call)(node)
+	@staticmethod
+	def ClassDef(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.ClassDef)(node)
+	@staticmethod
+	def Compare(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.Compare)(node)
+	@staticmethod
+	def Constant(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.Constant)(node)
+	@staticmethod
+	def Expr(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.Expr)(node)
+	@staticmethod
+	def FunctionDef(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.FunctionDef)(node)
+	@staticmethod
+	def Import(node: ast.AST) -> TypeGuard[ast.Import]: return be._typeCertified(ast.Import)(node)
+	@staticmethod
+	def ImportFrom(node: ast.AST) -> TypeGuard[ast.ImportFrom]: return be._typeCertified(ast.ImportFrom)(node)
+	@staticmethod
+	def keyword(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.keyword)(node)
+	@staticmethod
+	def Module(node: ast.AST) -> TypeGuard[typeCertified]: return be._typeCertified(ast.Module)(node)
+	@staticmethod
+	def Name(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.Name)(node)
+	@staticmethod
+	def Return(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.Return)(node)
+	@staticmethod
+	def Starred(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.Starred)(node)
+	@staticmethod
+	def Subscript(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.Subscript)(node)
+	@staticmethod
+	def UnaryOp(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.UnaryOp)(node)
+
+class ifThis:
+	@staticmethod
+	def equals(this: Any) -> Callable[[Any], TypeGuard[Any] | bool]:
+		return lambda node: node == this
+	@staticmethod
+	def isAssignAndTargets0Is(targets0Predicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		"""node is Assign and node.targets[0] matches `targets0Predicate`."""
+		return lambda node: be.Assign(node) and targets0Predicate(node.targets[0])
+	@staticmethod
+	def isAssignAndValueIs(valuePredicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		"""node is ast.Assign and node.value matches `valuePredicate`.
+		Parameters:
+			valuePredicate: Function that evaluates the value of the assignment
+		Returns:
+			predicate: matches assignments with values meeting the criteria
+		"""
+		return lambda node: be.Assign(node) and 又.value(valuePredicate)(node)
+	@staticmethod
+	def isFunctionDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		return lambda node: be.FunctionDef(node) and 又.name(ifThis._Identifier(identifier))(node)
+	@staticmethod
+	def isArgument_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		return lambda node: (be.arg(node) or be.keyword(node)) and 又.arg(ifThis._Identifier(identifier))(node)
+	@staticmethod
+	def is_keyword_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		"""see also `isArgument_Identifier`"""
+		return lambda node: be.keyword(node) and 又.arg(ifThis._Identifier(identifier))(node)
+	@staticmethod
+	def is_arg_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		"""see also `isArgument_Identifier`"""
+		return lambda node: be.arg(node) and 又.arg(ifThis._Identifier(identifier))(node)
+	@staticmethod
+	def isClassDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		return lambda node: be.ClassDef(node) and 又.name(ifThis._Identifier(identifier))(node)
+	@staticmethod
+	def isAssignAndValueIsCall_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		return lambda node: be.Assign(node) and 又.value(ifThis.isCall_Identifier(identifier))(node)
+	@staticmethod
+	def isAssignAndValueIsCallAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		return ifThis.isAssignAndValueIs(ifThis.isCallAttributeNamespace_Identifier(namespace, identifier))
+	@staticmethod
+	def is_keywordAndValueIsConstant(node: ast.AST) -> TypeGuard[object]:
+		return be.keyword(node) and 又.value(be.Constant)(node)
+	@staticmethod
+	def is_keyword_IdentifierEqualsConstantValue(identifier: ast_Identifier, ConstantValue: Any) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		return lambda node: ifThis.is_keyword_Identifier(identifier)(node) and ifThis.is_keywordAndValueIsConstant(node) and 又.value(ifThis.isConstantEquals(ConstantValue))(node)
+	"""
+Argument of type "typeCertified@isAnnAssign_targetIs" cannot be assigned to parameter of type "astClassHasDOTtarget"
+	Type "typeCertified@isAnnAssign_targetIs" is not assignable to type "astClassHasDOTtarget"
+		"object*" is not assignable to "AnnAssign"
+		"object*" is not assignable to "AsyncFor"
+		"object*" is not assignable to "AugAssign"
+		"object*" is not assignable to "comprehension"
+		"object*" is not assignable to "For"
+		"object*" is not assignable to "NamedExpr"
+	"""
+	@staticmethod
+	def isAnnAssign_targetIs(targetPredicate: Callable[[Ima_targetType], TypeGuard[Ima_targetType] | bool]) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		def workhorse(node: ast.AST) -> TypeGuard[object] | bool:
+			return be.AnnAssign(node) and 又.target(targetPredicate)(node)
+		return workhorse
+	@staticmethod
+	def isAnnAssignAndAnnotationIsName(node: ast.AST) -> TypeGuard[object] | bool:
+		return be.AnnAssign(node) and 又.annotation(be.Name)(node)
+	@staticmethod
+	def isAugAssign_targetIs(targetPredicate: Callable[[Ima_targetType], TypeGuard[Ima_targetType] | bool]) -> Callable[[ast.AST], TypeGuard[typeCertified] | bool]:
+		def workhorse(node: ast.AST) -> TypeGuard[typeCertified] | bool:
+			return be.AugAssign(node) and 又.target(targetPredicate)(node)
+		return workhorse
+
+	@staticmethod
+	def isAnyCompare(node: ast.AST) -> TypeGuard[object]:
+		return be.Compare(node) or be.BoolOp(node)
+	@staticmethod
+	def isConstantEquals(value: Any) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		return lambda node: be.Constant(node) and 又.value(ifThis.equals(value))(node)
+	@staticmethod
+	def isReturnAnyCompare(node: ast.AST) -> TypeGuard[object] | bool:
+		return be.Return(node) and 又.value(ifThis.isAnyCompare)(node)
+	@staticmethod
+	def isReturnUnaryOp(node: ast.AST) -> TypeGuard[object] | bool:
+		return be.Return(node) and 又.value(be.UnaryOp)(node)
+
+	# ================================================================
+	# Nested identifier
+	@staticmethod
+	def _nestedJunction_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		def workhorse(node: ast.AST) -> TypeGuard[object] | bool:
+			return ifThis.isName_Identifier(identifier)(node) or ifThis.isAttribute_Identifier(identifier)(node) or ifThis.isSubscript_Identifier(identifier)(node) or ifThis.isStarred_Identifier(identifier)(node)
+		return workhorse
+	@staticmethod
+	def isAttribute_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		"""node is `ast.Attribute` and the top-level `ast.Name` is `identifier`"""
+		def workhorse(node: ast.AST) -> TypeGuard[object]:
+			return be.Attribute(node) and 又.value(ifThis._nestedJunction_Identifier(identifier))(node)
+		return workhorse
+	@staticmethod
+	def isStarred_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		"""node is `ast.Starred` and the top-level `ast.Name` is `identifier`"""
+		def workhorse(node: ast.AST) -> TypeGuard[object]:
+			return be.Starred(node) and 又.value(ifThis._nestedJunction_Identifier(identifier))(node)
+		return workhorse
+	@staticmethod
+	def isSubscript_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		"""node is `ast.Subscript` and the top-level `ast.Name` is `identifier`"""
+		def workhorse(node: ast.AST) -> TypeGuard[object]:
+			return be.Subscript(node) and 又.value(ifThis._nestedJunction_Identifier(identifier))(node)
+		return workhorse
+	# ================================================================
+
+	@staticmethod
+	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
+
+	# ================================================================
+	# NOT used
+	# TODO Does this work?
+	@staticmethod
+	def Z0Z_matchesAtLeast1Descendant(predicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], bool]:
+		"""Create a predicate that returns True if any descendant of the node matches the given predicate."""
+		return lambda node: not ifThis.matchesNoDescendant(predicate)(node)
+	# ================================================================
+	# MORE function inlining
+	@staticmethod
+	def onlyReturnAnyCompare(astFunctionDef: ast.AST) -> TypeGuard[object]:
+		return be.FunctionDef(astFunctionDef) and len(astFunctionDef.body) == 1 and ifThis.isReturnAnyCompare(astFunctionDef.body[0])
+	# For function inlining
+	@staticmethod
+	def onlyReturnUnaryOp(astFunctionDef: ast.AST) -> TypeGuard[object]:
+		return be.FunctionDef(astFunctionDef) and len(astFunctionDef.body) == 1 and ifThis.isReturnUnaryOp(astFunctionDef.body[0])
+	# ================================================================
+	# These are used by other functions
+	@staticmethod
+	def isCallAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		return lambda node: be.Call(node) and 又.func(ifThis.isAttributeNamespace_Identifier(namespace, identifier))(node)
+	@staticmethod
+	def isName_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		return lambda node: be.Name(node) and 又.id(ifThis._Identifier(identifier))(node)
+	@staticmethod
+	def isCall_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		return lambda node: be.Call(node) and 又.func(ifThis.isName_Identifier(identifier))(node)
+	# ================================================================
+	@staticmethod
+	def matchesMeButNotAnyDescendant(predicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], bool]:
+		"""Create a predicate that returns True if the node matches but none of its descendants match the predicate."""
+		return lambda node: predicate(node) and ifThis.matchesNoDescendant(predicate)(node)
+	@staticmethod
+	def matchesNoDescendant(predicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], bool]:
+		"""Create a predicate that returns True if no descendant of the node matches the given predicate."""
+		def workhorse(node: ast.AST) -> bool:
+			for descendant in ast.walk(node):
+				if descendant is not node and predicate(descendant):
+					return False
+			return True
+		return workhorse
+
+	@staticmethod
+	def CallDoesNotCallItself(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		"""If `namespace` is not applicable to your case, then call with `namespace=""`."""
+		return lambda node: ifThis.matchesMeButNotAnyDescendant(ifThis.CallReallyIs(namespace, identifier))(node)
+	@staticmethod
+	def CallReallyIs(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		return ifThis.isCall_Identifier(identifier) or ifThis.isCallAttributeNamespace_Identifier(namespace, identifier)
+	@staticmethod
+	def isAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		return lambda node: ifThis.isAttributeName(node) and 又.value(ifThis.isName_Identifier(namespace))(node) and 又.attr(ifThis._Identifier(identifier))(node)
+	@staticmethod
+	def _Identifier(identifier: ast_Identifier) -> Callable[[ast_Identifier | None], TypeGuard[ast_Identifier] | bool]:
+		return lambda node: node == identifier
+	@staticmethod
+	def isAttributeName(node: ast.AST) -> TypeGuard[object]:
+		""" Displayed as Name.attribute."""
+		return be.Attribute(node) and 又.value(be.Name)(node)
+
+	@staticmethod
+	def isCallToName(node: ast.AST) -> TypeGuard[object]:
+		return be.Call(node) and 又.func(be.Name)(node)
+	@staticmethod
+	def ast_IdentifierIn(container: Container[ast_Identifier]) -> Callable[[ast_Identifier], TypeGuard[ast_Identifier] | bool]:
+		return lambda node: node in container
+	# This bullshit is for the crappy function inliner I made.
+	@staticmethod
+	def CallDoesNotCallItselfAndNameDOTidIsIn(container: Container[ast_Identifier]) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+		return lambda node: ifThis.isCallToName(node) and 又.func(又.id(ifThis.ast_IdentifierIn(container)))(node) and ifThis.CallDoesNotCallItself("", node.func.id)(node)

mapFolding/someAssemblyRequired/_toolboxContainers.py

@@ -0,0 +1,306 @@
+"""
+Container classes for AST transformations and code synthesis.
+
+This module provides container classes used in the AST transformation process
+and code synthesis workflows. It acts as a dependency boundary to prevent
+circular imports while providing reusable data structures.
+"""
+from collections import defaultdict
+from collections.abc import Sequence
+from mapFolding.someAssemblyRequired import ast_Identifier, be, ifThis, Make, parseLogicalPath2astModule, str_nameDOTname
+from mapFolding.theSSOT import callableDispatcherHARDCODED, raiseIfNoneGitHubIssueNumber3, The
+from pathlib import Path, PurePosixPath
+from Z0Z_tools import updateExtendPolishDictionaryLists
+import ast
+import dataclasses
+
+class LedgerOfImports:
+	# TODO When resolving the ledger of imports, remove self-referential imports
+	# TODO TypeIgnore :/
+
+	def __init__(self, startWith: ast.AST | None = None) -> None:
+		self.dictionaryImportFrom: dict[str_nameDOTname, list[tuple[ast_Identifier, ast_Identifier | None]]] = defaultdict(list)
+		self.listImport: list[str_nameDOTname] = []
+		if startWith:
+			self.walkThis(startWith)
+
+	def addAst(self, astImport____: ast.Import | ast.ImportFrom) -> None:
+		assert isinstance(astImport____, (ast.Import, ast.ImportFrom)), f"I received {type(astImport____) = }, but I can only accept {ast.Import} and {ast.ImportFrom}."
+		if be.Import(astImport____):
+			for alias in astImport____.names:
+				self.listImport.append(alias.name)
+		elif be.ImportFrom(astImport____):
+			# TODO fix the mess created by `None` means '.'. I need a `str_nameDOTname` to replace '.'
+			if astImport____.module is None:
+				astImport____.module = '.'
+			for alias in astImport____.names:
+				self.dictionaryImportFrom[astImport____.module].append((alias.name, alias.asname))
+
+	def addImport_asStr(self, moduleIdentifier: str_nameDOTname) -> None:
+		self.listImport.append(moduleIdentifier)
+
+	def addImportFrom_asStr(self, moduleIdentifier: ast_Identifier, name: ast_Identifier, asname: ast_Identifier | None = None) -> None:
+		self.dictionaryImportFrom[moduleIdentifier].append((name, asname))
+
+	def exportListModuleIdentifiers(self) -> list[ast_Identifier]:
+		listModuleIdentifiers: list[ast_Identifier] = list(self.dictionaryImportFrom.keys())
+		listModuleIdentifiers.extend(self.listImport)
+		return sorted(set(listModuleIdentifiers))
+
+	def makeList_ast(self) -> list[ast.ImportFrom | ast.Import]:
+		listImportFrom: list[ast.ImportFrom] = []
+		for moduleIdentifier, listOfNameTuples in sorted(self.dictionaryImportFrom.items()):
+			listOfNameTuples = sorted(list(set(listOfNameTuples)), key=lambda nameTuple: nameTuple[0])
+			list_alias: list[ast.alias] = []
+			for name, asname in listOfNameTuples:
+				list_alias.append(Make.alias(name, asname))
+			listImportFrom.append(Make.ImportFrom(moduleIdentifier, list_alias))
+		list_astImport: list[ast.Import] = [Make.Import(moduleIdentifier) for moduleIdentifier in sorted(set(self.listImport))]
+		return listImportFrom + list_astImport
+
+	def update(self, *fromLedger: 'LedgerOfImports') -> None:
+		"""Update this ledger with imports from one or more other ledgers.
+		Parameters:
+			*fromLedger: One or more other `LedgerOfImports` objects from which to merge.
+		"""
+		self.dictionaryImportFrom = updateExtendPolishDictionaryLists(self.dictionaryImportFrom, *(ledger.dictionaryImportFrom for ledger in fromLedger), destroyDuplicates=True, reorderLists=True)
+		for ledger in fromLedger:
+			self.listImport.extend(ledger.listImport)
+
+	def walkThis(self, walkThis: ast.AST) -> None:
+		for nodeBuffalo in ast.walk(walkThis):
+			if isinstance(nodeBuffalo, (ast.Import, ast.ImportFrom)):
+				self.addAst(nodeBuffalo)
+
+@dataclasses.dataclass
+class IngredientsFunction:
+	"""Everything necessary to integrate a function into a module should be here.
+	Parameters:
+		astFunctionDef: hint `Make.astFunctionDef()`
+	"""
+	astFunctionDef: ast.FunctionDef
+	imports: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
+	type_ignores: list[ast.TypeIgnore] = dataclasses.field(default_factory=list)
+
+@dataclasses.dataclass
+class IngredientsModule:
+	"""Everything necessary to create one _logical_ `ast.Module` should be here.
+	Extrinsic qualities should _probably_ be handled externally.
+
+	Parameters:
+		ingredientsFunction (None): One or more `IngredientsFunction` that will appended to `listIngredientsFunctions`.
+	"""
+	ingredientsFunction: dataclasses.InitVar[Sequence[IngredientsFunction] | IngredientsFunction | None] = None
+
+	# init var with an existing module? method to deconstruct an existing module?
+
+	# `body` attribute of `ast.Module`
+	"""NOTE
+	- Bare statements in `prologue` and `epilogue` are not 'protected' by `if __name__ == '__main__':` so they will be executed merely by loading the module.
+	- The dataclass has methods for modifying `prologue`, `epilogue`, and `launcher`.
+	- However, `prologue`, `epilogue`, and `launcher` are `ast.Module` (as opposed to `list[ast.stmt]`), so that you may use tools such as `ast.walk` and `ast.NodeVisitor` on the fields.
+	"""
+	imports: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
+	"""Modify this field using the methods in `LedgerOfImports`."""
+	prologue: ast.Module = Make.Module([],[])
+	"""Statements after the imports and before the functions in listIngredientsFunctions."""
+	listIngredientsFunctions: list[IngredientsFunction] = dataclasses.field(default_factory=list)
+	epilogue: ast.Module = Make.Module([],[])
+	"""Statements after the functions in listIngredientsFunctions and before `launcher`."""
+	launcher: ast.Module = Make.Module([],[])
+	"""`if __name__ == '__main__':`"""
+
+	# `ast.TypeIgnore` statements to supplement those in other fields; `type_ignores` is a parameter for `ast.Module` constructor
+	supplemental_type_ignores: list[ast.TypeIgnore] = dataclasses.field(default_factory=list)
+
+	def __post_init__(self, ingredientsFunction: Sequence[IngredientsFunction] | IngredientsFunction | None = None) -> None:
+		if ingredientsFunction is not None:
+			if isinstance(ingredientsFunction, IngredientsFunction):
+				self.appendIngredientsFunction(ingredientsFunction)
+			else:
+				self.appendIngredientsFunction(*ingredientsFunction)
+
+	def _append_astModule(self, self_astModule: ast.Module, astModule: ast.Module | None, statement: Sequence[ast.stmt] | ast.stmt | None, type_ignores: list[ast.TypeIgnore] | None) -> None:
+		"""Append one or more statements to `prologue`."""
+		list_body: list[ast.stmt] = []
+		listTypeIgnore: list[ast.TypeIgnore] = []
+		if astModule is not None and be.Module(astModule):
+			list_body.extend(astModule.body)
+			listTypeIgnore.extend(astModule.type_ignores)
+		if type_ignores is not None:
+			listTypeIgnore.extend(type_ignores)
+		if statement is not None:
+			if isinstance(statement, Sequence):
+				list_body.extend(statement)
+			else:
+				list_body.append(statement)
+		self_astModule.body.extend(list_body)
+		self_astModule.type_ignores.extend(listTypeIgnore)
+		ast.fix_missing_locations(self_astModule)
+
+	def appendPrologue(self, astModule: ast.Module | None = None, statement: Sequence[ast.stmt] | ast.stmt | None = None, type_ignores: list[ast.TypeIgnore] | None = None) -> None:
+		"""Append one or more statements to `prologue`."""
+		self._append_astModule(self.prologue, astModule, statement, type_ignores)
+
+	def appendEpilogue(self, astModule: ast.Module | None = None, statement: Sequence[ast.stmt] | ast.stmt | None = None, type_ignores: list[ast.TypeIgnore] | None = None) -> None:
+		"""Append one or more statements to `epilogue`."""
+		self._append_astModule(self.epilogue, astModule, statement, type_ignores)
+
+	def appendLauncher(self, astModule: ast.Module | None = None, statement: Sequence[ast.stmt] | ast.stmt | None = None, type_ignores: list[ast.TypeIgnore] | None = None) -> None:
+		"""Append one or more statements to `launcher`."""
+		self._append_astModule(self.launcher, astModule, statement, type_ignores)
+
+	def appendIngredientsFunction(self, *ingredientsFunction: IngredientsFunction) -> None:
+		"""Append one or more `IngredientsFunction`."""
+		for allegedIngredientsFunction in ingredientsFunction:
+			if isinstance(allegedIngredientsFunction, IngredientsFunction):
+				self.listIngredientsFunctions.append(allegedIngredientsFunction)
+			else:
+				raise ValueError(f"I received `{type(allegedIngredientsFunction) = }`, but I can only accept `{IngredientsFunction}`.")
+
+	@property
+	def list_astImportImportFrom(self) -> list[ast.Import | ast.ImportFrom]:
+		"""List of `ast.Import` and `ast.ImportFrom` statements."""
+		sherpaLedger = LedgerOfImports()
+		listLedgers: list[LedgerOfImports] = [self.imports]
+		for ingredientsFunction in self.listIngredientsFunctions:
+			listLedgers.append(ingredientsFunction.imports)
+		sherpaLedger.update(*listLedgers)
+		return sherpaLedger.makeList_ast()
+
+	@property
+	def body(self) -> list[ast.stmt]:
+		list_stmt: list[ast.stmt] = []
+		list_stmt.extend(self.list_astImportImportFrom)
+		list_stmt.extend(self.prologue.body)
+		for ingredientsFunction in self.listIngredientsFunctions:
+			list_stmt.append(ingredientsFunction.astFunctionDef)
+		list_stmt.extend(self.epilogue.body)
+		list_stmt.extend(self.launcher.body)
+		# TODO `launcher`, if it exists, must start with `if __name__ == '__main__':` and be indented
+		return list_stmt
+
+	@property
+	def type_ignores(self) -> list[ast.TypeIgnore]:
+		listTypeIgnore: list[ast.TypeIgnore] = self.supplemental_type_ignores
+		# listTypeIgnore.extend(self.imports.makeListAst())
+		listTypeIgnore.extend(self.prologue.type_ignores)
+		for ingredientsFunction in self.listIngredientsFunctions:
+			listTypeIgnore.extend(ingredientsFunction.type_ignores)
+		listTypeIgnore.extend(self.epilogue.type_ignores)
+		listTypeIgnore.extend(self.launcher.type_ignores)
+		return listTypeIgnore
+
+@dataclasses.dataclass
+class RecipeSynthesizeFlow:
+	"""Settings for synthesizing flow."""
+	# ========================================
+	# Source
+	# ========================================
+	source_astModule = parseLogicalPath2astModule(The.logicalPathModuleSourceAlgorithm)
+
+	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
+	sourceCallableDispatcher: ast_Identifier = The.sourceCallableDispatcher
+	sourceCallableInitialize: ast_Identifier = The.sourceCallableInitialize
+	sourceCallableParallel: ast_Identifier = The.sourceCallableParallel
+	sourceCallableSequential: ast_Identifier = The.sourceCallableSequential
+
+	sourceDataclassIdentifier: ast_Identifier = The.dataclassIdentifier
+	sourceDataclassInstance: ast_Identifier = The.dataclassInstance
+	sourceDataclassInstanceTaskDistribution: ast_Identifier = The.dataclassInstanceTaskDistribution
+	sourceLogicalPathModuleDataclass: str_nameDOTname = The.logicalPathModuleDataclass
+
+	sourceConcurrencyManagerNamespace = The.sourceConcurrencyManagerNamespace
+	sourceConcurrencyManagerIdentifier = The.sourceConcurrencyManagerIdentifier
+
+	# ========================================
+	# Logical identifiers (as opposed to physical identifiers)
+	# ========================================
+	# Package ================================
+	packageIdentifier: ast_Identifier | None = The.packageName
+
+	# Qualified logical path ================================
+	logicalPathModuleDataclass: str_nameDOTname = sourceLogicalPathModuleDataclass
+	logicalPathFlowRoot: ast_Identifier | None = 'syntheticModules'
+	""" `logicalPathFlowRoot` likely corresponds to a physical filesystem directory."""
+
+	# Module ================================
+	moduleDispatcher: ast_Identifier = 'numbaCount_doTheNeedful'
+	moduleInitialize: ast_Identifier = moduleDispatcher
+	moduleParallel: ast_Identifier = moduleDispatcher
+	moduleSequential: ast_Identifier = moduleDispatcher
+
+	# Function ================================
+	callableDispatcher: ast_Identifier = sourceCallableDispatcher
+	callableInitialize: ast_Identifier = sourceCallableInitialize
+	callableParallel: ast_Identifier = sourceCallableParallel
+	callableSequential: ast_Identifier = sourceCallableSequential
+	concurrencyManagerNamespace: ast_Identifier = sourceConcurrencyManagerNamespace
+	concurrencyManagerIdentifier: ast_Identifier = sourceConcurrencyManagerIdentifier
+	dataclassIdentifier: ast_Identifier = sourceDataclassIdentifier
+
+	# Variable ================================
+	dataclassInstance: ast_Identifier = sourceDataclassInstance
+	dataclassInstanceTaskDistribution: ast_Identifier = sourceDataclassInstanceTaskDistribution
+
+	# ========================================
+	# Computed
+	# ========================================
+	"""
+theFormatStrModuleSynthetic = "{packageFlow}Count"
+theFormatStrModuleForCallableSynthetic = theFormatStrModuleSynthetic + "_{callableTarget}"
+theModuleDispatcherSynthetic: ast_Identifier = theFormatStrModuleForCallableSynthetic.format(packageFlow=packageFlowSynthetic, callableTarget=The.sourceCallableDispatcher)
+theLogicalPathModuleDispatcherSynthetic: str = '.'.join([The.packageName, The.moduleOfSyntheticModules, theModuleDispatcherSynthetic])
+
+	"""
+	# logicalPathModuleDispatcher: str = '.'.join([Z0Z_flowLogicalPathRoot, moduleDispatcher])
+	# ========================================
+	# Filesystem (names of physical objects)
+	# ========================================
+	pathPackage: PurePosixPath | None = PurePosixPath(The.pathPackage)
+	fileExtension: str = The.fileExtension
+
+	def _makePathFilename(self, filenameStem: str,
+			pathRoot: PurePosixPath | None = None,
+			logicalPathINFIX: str_nameDOTname | None = None,
+			fileExtension: str | None = None,
+			) -> PurePosixPath:
+		"""filenameStem: (hint: the name of the logical module)"""
+		if pathRoot is None:
+			pathRoot = self.pathPackage or PurePosixPath(Path.cwd())
+		if logicalPathINFIX:
+			whyIsThisStillAThing: list[str] = logicalPathINFIX.split('.')
+			pathRoot = pathRoot.joinpath(*whyIsThisStillAThing)
+		if fileExtension is None:
+			fileExtension = self.fileExtension
+		filename: str = filenameStem + fileExtension
+		return pathRoot.joinpath(filename)
+
+	@property
+	def pathFilenameDispatcher(self) -> PurePosixPath:
+		return self._makePathFilename(filenameStem=self.moduleDispatcher, logicalPathINFIX=self.logicalPathFlowRoot)
+	@property
+	def pathFilenameInitialize(self) -> PurePosixPath:
+		return self._makePathFilename(filenameStem=self.moduleInitialize, logicalPathINFIX=self.logicalPathFlowRoot)
+	@property
+	def pathFilenameParallel(self) -> PurePosixPath:
+		return self._makePathFilename(filenameStem=self.moduleParallel, logicalPathINFIX=self.logicalPathFlowRoot)
+	@property
+	def pathFilenameSequential(self) -> PurePosixPath:
+		return self._makePathFilename(filenameStem=self.moduleSequential, logicalPathINFIX=self.logicalPathFlowRoot)
+
+	def __post_init__(self) -> None:
+		if ((self.concurrencyManagerIdentifier is not None and self.concurrencyManagerIdentifier != self.sourceConcurrencyManagerIdentifier) # `submit` # type: ignore
+			or ((self.concurrencyManagerIdentifier is None) != (self.concurrencyManagerNamespace is None))): # type: ignore
+			import warnings
+			warnings.warn(f"If your synthesized module is weird, check `{self.concurrencyManagerIdentifier=}` and `{self.concurrencyManagerNamespace=}`. (ChildProcessError? 'Yeah! Children shouldn't be processing stuff, man.')", category=ChildProcessError, stacklevel=2) # pyright: ignore[reportCallIssue, reportArgumentType] Y'all Pynatics need to be less shrill and focus on making code that doesn't need 8000 error categories.
+
+		# self.logicalPathModuleDispatcher!=logicalPathModuleDispatcherHARDCODED or
+		if self.callableDispatcher!=callableDispatcherHARDCODED:
+			print(f"fyi: `{self.callableDispatcher=}` but\n\t`{callableDispatcherHARDCODED=}`.")
+
+def astModuleToIngredientsFunction(astModule: ast.AST, identifierFunctionDef: ast_Identifier) -> IngredientsFunction:
+	from mapFolding.someAssemblyRequired import extractFunctionDef
+	astFunctionDef = extractFunctionDef(astModule, identifierFunctionDef)
+	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
+	return IngredientsFunction(astFunctionDef, LedgerOfImports(astModule))