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

mapFolding/reference/jobsCompleted/p2x19/p2x19.py

@@ -0,0 +1,29 @@
+from numba import uint8,jit,int64
+from numpy import uint8
+from numpy import array
+@jit(int64(),_nrt=True,boundscheck=False,cache=True,error_model='numpy',fastmath=True,forceinline=True,inline='always',looplift=False,no_cfunc_wrapper=False,no_cpython_wrapper=False,nopython=True,parallel=False)
+def countSequential()->int64:
+	groupsOfFolds=int64(0);leafAbove=array([1,2]+[0]*37,dtype=uint8);countDimensionsGapped=array([0]*39,dtype=uint8);gapRangeStart=array([0]*2+[1]+[0]*36,dtype=uint8);leafBelow=array([2,0,1]+[0]*36,dtype=uint8);gap1ndex=uint8(1);indexMiniGap=uint8(2);leafConnectee=uint8(2);indexDimension=uint8(2);gap1ndexCeiling=uint8(2);dimensionsUnconstrained=uint8(1);leaf1ndex=uint8(3);gapsWhere=array([1]+[0]*1444,dtype=uint8);connectionGraph=array([[[0]*39,[0,1]+[0]*37,[0,2,1]+[0]*36,[0,1,2,3]+[0]*35,[0,2,1,4,3]+[0]*34,[*range(0,6)]+[0]*33,[0,2,1,4,3,6,5]+[0]*32,[*range(0,8)]+[0]*31,[0,2,1,4,3,6,5,8,7]+[0]*30,[*range(0,10)]+[0]*29,[0,2,1,4,3,6,5,8,7,10,9]+[0]*28,[*range(0,12)]+[0]*27,[0,2,1,4,3,6,5,8,7,10,9,12,11]+[0]*26,[*range(0,14)]+[0]*25,[0,2,1,4,3,6,5,8,7,10,9,12,11,14,13]+[0]*24,[*range(0,16)]+[0]*23,[0,2,1,4,3,6,5,8,7,10,9,12,11,14,13,16,15]+[0]*22,[*range(0,18)]+[0]*21,[0,2,1,4,3,6,5,8,7,10,9,12,11,14,13,16,15,18,17]+[0]*20,[*range(0,20)]+[0]*19,[0,2,1,4,3,6,5,8,7,10,9,12,11,14,13,16,15,18,17,20,19]+[0]*18,[*range(0,22)]+[0]*17,[0,2,1,4,3,6,5,8,7,10,9,12,11,14,13,16,15,18,17,20,19,22,21]+[0]*16,[*range(0,24)]+[0]*15,[0,2,1,4,3,6,5,8,7,10,9,12,11,14,13,16,15,18,17,20,19,22,21,24,23]+[0]*14,[*range(0,26)]+[0]*13,[0,2,1,4,3,6,5,8,7,10,9,12,11,14,13,16,15,18,17,20,19,22,21,24,23,26,25]+[0]*12,[*range(0,28)]+[0]*11,[0,2,1,4,3,6,5,8,7,10,9,12,11,14,13,16,15,18,17,20,19,22,21,24,23,26,25,28,27]+[0]*10,[*range(0,30)]+[0]*9,[0,2,1,4,3,6,5,8,7,10,9,12,11,14,13,16,15,18,17,20,19,22,21,24,23,26,25,28,27,30,29]+[0]*8,[*range(0,32)]+[0]*7,[0,2,1,4,3,6,5,8,7,10,9,12,11,14,13,16,15,18,17,20,19,22,21,24,23,26,25,28,27,30,29,32,31]+[0]*6,[*range(0,34)]+[0]*5,[0,2,1,4,3,6,5,8,7,10,9,12,11,14,13,16,15,18,17,20,19,22,21,24,23,26,25,28,27,30,29,32,31,34,33]+[0]*4,[*range(0,36)]+[0]*3,[0,2,1,4,3,6,5,8,7,10,9,12,11,14,13,16,15,18,17,20,19,22,21,24,23,26,25,28,27,30,29,32,31,34,33,36,35]+[0]*2,[*range(0,38),0],[0,2,1,4,3,6,5,8,7,10,9,12,11,14,13,16,15,18,17,20,19,22,21,24,23,26,25,28,27,30,29,32,31,34,33,36,35,38,37]],[[0]*39,[0,1]+[0]*37,[0,1,2]+[0]*36,[0,3,2,1]+[0]*35,[0,3,4,1,2]+[0]*34,[0,1,2,5,4,3]+[0]*33,[0,1,2,5,6,3,4]+[0]*32,[0,3,4,1,2,7,6,5]+[0]*31,[0,3,4,1,2,7,8,5,6]+[0]*30,[0,1,2,5,6,3,4,9,8,7]+[0]*29,[0,1,2,5,6,3,4,9,10,7,8]+[0]*28,[0,3,4,1,2,7,8,5,6,11,10,9]+[0]*27,[0,3,4,1,2,7,8,5,6,11,12,9,10]+[0]*26,[0,1,2,5,6,3,4,9,10,7,8,13,12,11]+[0]*25,[0,1,2,5,6,3,4,9,10,7,8,13,14,11,12]+[0]*24,[0,3,4,1,2,7,8,5,6,11,12,9,10,15,14,13]+[0]*23,[0,3,4,1,2,7,8,5,6,11,12,9,10,15,16,13,14]+[0]*22,[0,1,2,5,6,3,4,9,10,7,8,13,14,11,12,17,16,15]+[0]*21,[0,1,2,5,6,3,4,9,10,7,8,13,14,11,12,17,18,15,16]+[0]*20,[0,3,4,1,2,7,8,5,6,11,12,9,10,15,16,13,14,19,18,17]+[0]*19,[0,3,4,1,2,7,8,5,6,11,12,9,10,15,16,13,14,19,20,17,18]+[0]*18,[0,1,2,5,6,3,4,9,10,7,8,13,14,11,12,17,18,15,16,21,20,19]+[0]*17,[0,1,2,5,6,3,4,9,10,7,8,13,14,11,12,17,18,15,16,21,22,19,20]+[0]*16,[0,3,4,1,2,7,8,5,6,11,12,9,10,15,16,13,14,19,20,17,18,23,22,21]+[0]*15,[0,3,4,1,2,7,8,5,6,11,12,9,10,15,16,13,14,19,20,17,18,23,24,21,22]+[0]*14,[0,1,2,5,6,3,4,9,10,7,8,13,14,11,12,17,18,15,16,21,22,19,20,25,24,23]+[0]*13,[0,1,2,5,6,3,4,9,10,7,8,13,14,11,12,17,18,15,16,21,22,19,20,25,26,23,24]+[0]*12,[0,3,4,1,2,7,8,5,6,11,12,9,10,15,16,13,14,19,20,17,18,23,24,21,22,27,26,25]+[0]*11,[0,3,4,1,2,7,8,5,6,11,12,9,10,15,16,13,14,19,20,17,18,23,24,21,22,27,28,25,26]+[0]*10,[0,1,2,5,6,3,4,9,10,7,8,13,14,11,12,17,18,15,16,21,22,19,20,25,26,23,24,29,28,27]+[0]*9,[0,1,2,5,6,3,4,9,10,7,8,13,14,11,12,17,18,15,16,21,22,19,20,25,26,23,24,29,30,27,28]+[0]*8,[0,3,4,1,2,7,8,5,6,11,12,9,10,15,16,13,14,19,20,17,18,23,24,21,22,27,28,25,26,31,30,29]+[0]*7,[0,3,4,1,2,7,8,5,6,11,12,9,10,15,16,13,14,19,20,17,18,23,24,21,22,27,28,25,26,31,32,29,30]+[0]*6,[0,1,2,5,6,3,4,9,10,7,8,13,14,11,12,17,18,15,16,21,22,19,20,25,26,23,24,29,30,27,28,33,32,31]+[0]*5,[0,1,2,5,6,3,4,9,10,7,8,13,14,11,12,17,18,15,16,21,22,19,20,25,26,23,24,29,30,27,28,33,34,31,32]+[0]*4,[0,3,4,1,2,7,8,5,6,11,12,9,10,15,16,13,14,19,20,17,18,23,24,21,22,27,28,25,26,31,32,29,30,35,34,33]+[0]*3,[0,3,4,1,2,7,8,5,6,11,12,9,10,15,16,13,14,19,20,17,18,23,24,21,22,27,28,25,26,31,32,29,30,35,36,33,34]+[0]*2,[0,1,2,5,6,3,4,9,10,7,8,13,14,11,12,17,18,15,16,21,22,19,20,25,26,23,24,29,30,27,28,33,34,31,32,37,36,35,0],[0,1,2,5,6,3,4,9,10,7,8,13,14,11,12,17,18,15,16,21,22,19,20,25,26,23,24,29,30,27,28,33,34,31,32,37,38,35,36]]],dtype=uint8)
+	while leaf1ndex:
+		if leaf1ndex<=1 or leafBelow[0]==1:
+			if leaf1ndex>38:groupsOfFolds+=1
+			else:
+				dimensionsUnconstrained=2;gap1ndexCeiling=gapRangeStart[leaf1ndex-1];indexDimension=0
+				while indexDimension<2:
+					if connectionGraph[indexDimension,leaf1ndex,leaf1ndex]==leaf1ndex:dimensionsUnconstrained-=1
+					else:
+						leafConnectee=connectionGraph[indexDimension,leaf1ndex,leaf1ndex]
+						while leafConnectee!=leaf1ndex:
+							gapsWhere[gap1ndexCeiling]=leafConnectee
+							if countDimensionsGapped[leafConnectee]==0:gap1ndexCeiling+=1
+							countDimensionsGapped[leafConnectee]+=1;leafConnectee=connectionGraph[indexDimension,leaf1ndex,leafBelow[leafConnectee]]
+					indexDimension+=1
+				indexMiniGap=gap1ndex
+				while indexMiniGap<gap1ndexCeiling:
+					gapsWhere[gap1ndex]=gapsWhere[indexMiniGap]
+					if countDimensionsGapped[gapsWhere[indexMiniGap]]==dimensionsUnconstrained:gap1ndex+=1
+					countDimensionsGapped[gapsWhere[indexMiniGap]]=0;indexMiniGap+=1
+		while leaf1ndex and gap1ndex==gapRangeStart[leaf1ndex-1]:leaf1ndex-=1;leafBelow[leafAbove[leaf1ndex]]=leafBelow[leaf1ndex];leafAbove[leafBelow[leaf1ndex]]=leafAbove[leaf1ndex]
+		if leaf1ndex:gap1ndex-=1;leafAbove[leaf1ndex]=gapsWhere[gap1ndex];leafBelow[leaf1ndex]=leafBelow[leafAbove[leaf1ndex]];leafBelow[leafAbove[leaf1ndex]]=leaf1ndex;leafAbove[leafBelow[leaf1ndex]]=leaf1ndex;gapRangeStart[leaf1ndex]=gap1ndex;leaf1ndex+=1
+	return groupsOfFolds*38
+if __name__=='__main__':import time;timeStart=time.perf_counter();foldsTotal=countSequential();print(foldsTotal,time.perf_counter()-timeStart);writeStream=open('C:/apps/mapFolding/mapFolding/jobs/p2x19.foldsTotal','w');writeStream.write(str(foldsTotal));writeStream.close()

mapFolding/someAssemblyRequired/__init__.py

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

mapFolding/someAssemblyRequired/_theTypes.py

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

mapFolding/someAssemblyRequired/_tool_Make.py

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

mapFolding/someAssemblyRequired/_tool_Then.py

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

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)