mapFolding 0.9.5__py3-none-any.whl → 0.10.0__py3-none-any.whl

mapFolding/someAssemblyRequired/Z0Z_makeSomeModules.py

@@ -2,11 +2,11 @@ from mapFolding import raiseIfNoneGitHubIssueNumber3, The
 from mapFolding.someAssemblyRequired import (
 	ast_Identifier,
 	astModuleToIngredientsFunction,
-	be,
+	Be,
 	DOT,
 	extractFunctionDef,
-	grab,
-	ifThis,
+	Grab,
+	IfThis,
 	IngredientsFunction,
 	IngredientsModule,
 	LedgerOfImports,
@@ -35,7 +35,7 @@ sourceCallableIdentifierHARDCODED = 'count'
 logicalPathInfixHARDCODED: ast_Identifier = 'syntheticModules'
 theCountingIdentifierHARDCODED: ast_Identifier = 'groupsOfFolds'
 
-def makeInitializeGroupsOfFolds():
+def makeInitializeGroupsOfFolds() -> None:
 	callableIdentifierHARDCODED = 'initializeGroupsOfFolds'
 	moduleIdentifierHARDCODED: ast_Identifier = 'initializeCount'
 
@@ -53,14 +53,14 @@ def makeInitializeGroupsOfFolds():
 
 	countInitializeIngredients.astFunctionDef.name = callableIdentifier
 
-	dataclassInstanceIdentifier = NodeTourist(be.arg, Then.extractIt(DOT.arg)).captureLastMatch(countInitializeIngredients.astFunctionDef)
+	dataclassInstanceIdentifier = NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(countInitializeIngredients.astFunctionDef)
 	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
 	theCountingIdentifier = theCountingIdentifierHARDCODED
 
-	findThis = ifThis.isWhileAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
-	doThat = grab.testAttribute(grab.andDoAllOf([
-		grab.opsAttribute(Then.replaceWith([ast.Eq()])), # type: ignore
-		grab.leftAttribute(grab.attrAttribute(Then.replaceWith(theCountingIdentifier))) # type: ignore
+	findThis = IfThis.isWhileAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	doThat = Grab.testAttribute(Grab.andDoAllOf([
+		Grab.opsAttribute(Then.replaceWith([ast.Eq()])), # type: ignore
+		Grab.leftAttribute(Grab.attrAttribute(Then.replaceWith(theCountingIdentifier))) # type: ignore
 	]))
 	NodeChanger(findThis, doThat).visit(countInitializeIngredients.astFunctionDef.body[0])
 
@@ -70,7 +70,7 @@ def makeInitializeGroupsOfFolds():
 
 	write_astModule(ingredientsModule, pathFilename, The.packageName)
 
-def makeDaoOfMapFolding():
+def makeDaoOfMapFolding() -> PurePath:
 	moduleIdentifierHARDCODED: ast_Identifier = 'daoOfMapFolding'
 
 	algorithmSourceModule = algorithmSourceModuleHARDCODED
@@ -84,9 +84,9 @@ def makeDaoOfMapFolding():
 	daoOfMapFolding = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule)
 		, LedgerOfImports(astModule))
 
-	dataclassName: ast.expr | None = NodeTourist(be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(daoOfMapFolding.astFunctionDef)
+	dataclassName: ast.expr | None = NodeTourist(Be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(daoOfMapFolding.astFunctionDef)
 	if dataclassName is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclass_Identifier: ast_Identifier | None = NodeTourist(be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
+	dataclass_Identifier: ast_Identifier | None = NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
 	if dataclass_Identifier is None: raise raiseIfNoneGitHubIssueNumber3
 
 	dataclassLogicalPathModule = None
@@ -98,7 +98,7 @@ def makeDaoOfMapFolding():
 		if dataclassLogicalPathModule:
 			break
 	if dataclassLogicalPathModule is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclassInstanceIdentifier = NodeTourist(be.arg, Then.extractIt(DOT.arg)).captureLastMatch(daoOfMapFolding.astFunctionDef)
+	dataclassInstanceIdentifier = NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(daoOfMapFolding.astFunctionDef)
 	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
 	shatteredDataclass = shatter_dataclassesDOTdataclass(dataclassLogicalPathModule, dataclass_Identifier, dataclassInstanceIdentifier)
 
@@ -121,13 +121,14 @@ def makeDaoOfMapFolding():
 	doTheNeedful.imports.update(shatteredDataclass.imports)
 	targetCallableIdentifier = daoOfMapFolding.astFunctionDef.name
 	doTheNeedful = unpackDataclassCallFunctionRepackDataclass(doTheNeedful, targetCallableIdentifier, shatteredDataclass)
-	astTuple: ast.Tuple | None = NodeTourist(be.Return, Then.extractIt(DOT.value)).captureLastMatch(daoOfMapFolding.astFunctionDef)
+	astTuple: ast.Tuple | None = NodeTourist(Be.Return, Then.extractIt(DOT.value)).captureLastMatch(daoOfMapFolding.astFunctionDef)
 	if astTuple is None: raise raiseIfNoneGitHubIssueNumber3
 	astTuple.ctx = ast.Store()
 
-	findThis = ifThis.isAssignAndValueIs(ifThis.isCall_Identifier(targetCallableIdentifier))
-	doThat = Then.replaceWith(Make.Assign(listTargets=[astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts)))
-	NodeChanger(findThis, doThat).visit(doTheNeedful.astFunctionDef)
+	findThis = IfThis.isAssignAndValueIs(IfThis.isCall_Identifier(targetCallableIdentifier))
+	doThat = Then.replaceWith(Make.Assign([astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts)))
+	changeAssignCallToTarget = NodeChanger(findThis, doThat)
+	changeAssignCallToTarget.visit(doTheNeedful.astFunctionDef)
 
 	ingredientsModule = IngredientsModule([daoOfMapFolding, doTheNeedful])
 	ingredientsModule.removeImportFromModule('numpy')
@@ -138,7 +139,7 @@ def makeDaoOfMapFolding():
 
 	return pathFilename
 
-def makeTheorem2():
+def makeTheorem2() -> PurePath:
 	moduleIdentifierHARDCODED: ast_Identifier = 'theorem2'
 
 	algorithmSourceModule = algorithmSourceModuleHARDCODED
@@ -152,31 +153,31 @@ def makeTheorem2():
 	countTheorem2 = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule)
 		, LedgerOfImports(astModule))
 
-	dataclassInstanceIdentifier = NodeTourist(be.arg, Then.extractIt(DOT.arg)).captureLastMatch(countTheorem2.astFunctionDef)
+	dataclassInstanceIdentifier = NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(countTheorem2.astFunctionDef)
 	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
 
-	findThis = ifThis.isWhileAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
-	doThat = grab.testAttribute(grab.comparatorsAttribute(Then.replaceWith([Make.Constant(4)]))) # type: ignore
+	findThis = IfThis.isWhileAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	doThat = Grab.testAttribute(Grab.comparatorsAttribute(Then.replaceWith([Make.Constant(4)]))) # type: ignore
 	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
 
-	findThis = ifThis.isIfAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	findThis = IfThis.isIfAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
 	doThat = Then.extractIt(DOT.body)
 	insertLeaf = NodeTourist(findThis, doThat).captureLastMatch(countTheorem2.astFunctionDef)
-	findThis = ifThis.isIfAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	findThis = IfThis.isIfAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
 	doThat = Then.replaceWith(insertLeaf)
 	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
 
-	findThis = ifThis.isAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	findThis = IfThis.isAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
 	doThat = Then.removeIt
 	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
 
-	findThis = ifThis.isAttributeNamespace_IdentifierLessThanOrEqual(dataclassInstanceIdentifier, 'leaf1ndex')
+	findThis = IfThis.isAttributeNamespace_IdentifierLessThanOrEqual(dataclassInstanceIdentifier, 'leaf1ndex')
 	doThat = Then.removeIt
 	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
 
 	theCountingIdentifier = theCountingIdentifierHARDCODED
 	doubleTheCount = Make.AugAssign(Make.Attribute(ast.Name(dataclassInstanceIdentifier), theCountingIdentifier), ast.Mult(), Make.Constant(2))
-	findThis = be.Return
+	findThis = Be.Return
 	doThat = Then.insertThisAbove([doubleTheCount])
 	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
 
@@ -188,15 +189,15 @@ def makeTheorem2():
 
 	return pathFilename
 
-def trimTheorem2(pathFilenameSource: PurePath):
+def trimTheorem2(pathFilenameSource: PurePath) -> PurePath:
 	logicalPathInfix = logicalPathInfixHARDCODED
 	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
 	ingredientsFunction = astModuleToIngredientsFunction(parsePathFilename2astModule(pathFilenameSource), sourceCallableIdentifier)
 
-	dataclassInstanceIdentifier = NodeTourist(be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef)
+	dataclassInstanceIdentifier = NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef)
 	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
 
-	findThis = ifThis.isIfUnaryNotAttributeNamespace_Identifier(dataclassInstanceIdentifier, 'dimensionsUnconstrained')
+	findThis = IfThis.isIfUnaryNotAttributeNamespace_Identifier(dataclassInstanceIdentifier, 'dimensionsUnconstrained')
 	doThat = Then.removeIt
 	NodeChanger(findThis, doThat).visit(ingredientsFunction.astFunctionDef)
 
@@ -215,17 +216,17 @@ def trimTheorem2(pathFilenameSource: PurePath):
 	logicalPath.append(pathFilename.stem)
 	moduleWithLogicalPath: str_nameDOTname = '.'.join(logicalPath)
 
-	astImportFrom: ast.ImportFrom = Make.ImportFrom(moduleWithLogicalPath, list_astAlias=[Make.alias(ingredientsFunction.astFunctionDef.name)])
+	astImportFrom: ast.ImportFrom = Make.ImportFrom(moduleWithLogicalPath, list_alias=[Make.alias(ingredientsFunction.astFunctionDef.name)])
 
 	return pathFilename
 
-def numbaOnTheorem2(pathFilenameSource: PurePath):
+def numbaOnTheorem2(pathFilenameSource: PurePath) -> ast.ImportFrom:
 	logicalPathInfix = logicalPathInfixHARDCODED
 	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
 	countNumbaTheorem2 = astModuleToIngredientsFunction(parsePathFilename2astModule(pathFilenameSource), sourceCallableIdentifier)
-	dataclassName: ast.expr | None = NodeTourist(be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(countNumbaTheorem2.astFunctionDef)
+	dataclassName: ast.expr | None = NodeTourist(Be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(countNumbaTheorem2.astFunctionDef)
 	if dataclassName is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclass_Identifier: ast_Identifier | None = NodeTourist(be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
+	dataclass_Identifier: ast_Identifier | None = NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
 	if dataclass_Identifier is None: raise raiseIfNoneGitHubIssueNumber3
 
 	dataclassLogicalPathModule = None
@@ -237,7 +238,7 @@ def numbaOnTheorem2(pathFilenameSource: PurePath):
 		if dataclassLogicalPathModule:
 			break
 	if dataclassLogicalPathModule is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclassInstanceIdentifier = NodeTourist(be.arg, Then.extractIt(DOT.arg)).captureLastMatch(countNumbaTheorem2.astFunctionDef)
+	dataclassInstanceIdentifier = NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(countNumbaTheorem2.astFunctionDef)
 	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
 	shatteredDataclass = shatter_dataclassesDOTdataclass(dataclassLogicalPathModule, dataclass_Identifier, dataclassInstanceIdentifier)
 
@@ -263,11 +264,11 @@ def numbaOnTheorem2(pathFilenameSource: PurePath):
 	logicalPath.append(pathFilename.stem)
 	moduleWithLogicalPath: str_nameDOTname = '.'.join(logicalPath)
 
-	astImportFrom: ast.ImportFrom = Make.ImportFrom(moduleWithLogicalPath, list_astAlias=[Make.alias(countNumbaTheorem2.astFunctionDef.name)])
+	astImportFrom: ast.ImportFrom = Make.ImportFrom(moduleWithLogicalPath, list_alias=[Make.alias(countNumbaTheorem2.astFunctionDef.name)])
 
 	return astImportFrom
 
-def makeUnRePackDataclass(astImportFrom: ast.ImportFrom):
+def makeUnRePackDataclass(astImportFrom: ast.ImportFrom) -> None:
 	moduleIdentifierHARDCODED: ast_Identifier = 'dataPacking'
 
 	algorithmSourceModule = algorithmSourceModuleHARDCODED
@@ -278,9 +279,9 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom):
 	moduleIdentifier = moduleIdentifierHARDCODED
 
 	doTheNeedful: IngredientsFunction = astModuleToIngredientsFunction(parseLogicalPath2astModule(logicalPathSourceModule), sourceCallableIdentifier)
-	dataclassName: ast.expr | None = NodeTourist(be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(doTheNeedful.astFunctionDef)
+	dataclassName: ast.expr | None = NodeTourist(Be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(doTheNeedful.astFunctionDef)
 	if dataclassName is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclass_Identifier: ast_Identifier | None = NodeTourist(be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
+	dataclass_Identifier: ast_Identifier | None = NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
 	if dataclass_Identifier is None: raise raiseIfNoneGitHubIssueNumber3
 
 	dataclassLogicalPathModule = None
@@ -292,7 +293,7 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom):
 		if dataclassLogicalPathModule:
 			break
 	if dataclassLogicalPathModule is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclassInstanceIdentifier = NodeTourist(be.arg, Then.extractIt(DOT.arg)).captureLastMatch(doTheNeedful.astFunctionDef)
+	dataclassInstanceIdentifier = NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(doTheNeedful.astFunctionDef)
 	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
 	shatteredDataclass = shatter_dataclassesDOTdataclass(dataclassLogicalPathModule, dataclass_Identifier, dataclassInstanceIdentifier)
 
@@ -302,12 +303,12 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom):
 	doTheNeedful = unpackDataclassCallFunctionRepackDataclass(doTheNeedful, targetCallableIdentifier, shatteredDataclass)
 	targetFunctionDef = extractFunctionDef(parseLogicalPath2astModule(astImportFrom.module), targetCallableIdentifier) # type: ignore
 	if targetFunctionDef is None: raise raiseIfNoneGitHubIssueNumber3
-	astTuple: ast.Tuple | None = NodeTourist(be.Return, Then.extractIt(DOT.value)).captureLastMatch(targetFunctionDef)
+	astTuple: ast.Tuple | None = NodeTourist(Be.Return, Then.extractIt(DOT.value)).captureLastMatch(targetFunctionDef)
 	if astTuple is None: raise raiseIfNoneGitHubIssueNumber3
 	astTuple.ctx = ast.Store()
 
-	findThis = ifThis.isAssignAndValueIs(ifThis.isCall_Identifier(targetCallableIdentifier))
-	doThat = Then.replaceWith(Make.Assign(listTargets=[astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts)))
+	findThis = IfThis.isAssignAndValueIs(IfThis.isCall_Identifier(targetCallableIdentifier))
+	doThat = Then.replaceWith(Make.Assign([astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts)))
 	NodeChanger(findThis, doThat).visit(doTheNeedful.astFunctionDef)
 
 	ingredientsModule = IngredientsModule(doTheNeedful)

mapFolding/someAssemblyRequired/__init__.py

@@ -47,26 +47,13 @@ test suite.
 from mapFolding.someAssemblyRequired._theTypes import (
 	ast_expr_Slice as ast_expr_Slice,
 	ast_Identifier as ast_Identifier,
-	astClassHasDOTbody as astClassHasDOTbody,
-	astClassHasDOTbody_expr as astClassHasDOTbody_expr,
-	astClassHasDOTbodyList_stmt as astClassHasDOTbodyList_stmt,
-	astClassHasDOTnameNotName as astClassHasDOTnameNotName,
-	astClassHasDOTnameNotNameAlways as astClassHasDOTnameNotNameAlways,
-	astClassHasDOTnameNotNameOptionally as astClassHasDOTnameNotNameOptionally,
-	astClassHasDOTtarget as astClassHasDOTtarget,
-	astClassHasDOTtarget_expr as astClassHasDOTtarget_expr,
-	astClassHasDOTtargetAttributeNameSubscript as astClassHasDOTtargetAttributeNameSubscript,
-	astClassHasDOTvalue as astClassHasDOTvalue,
-	astClassHasDOTvalue_expr as astClassHasDOTvalue_expr,
-	astClassHasDOTvalue_exprNone as astClassHasDOTvalue_exprNone,
 	ImaCallToName as ImaCallToName,
-	intORlist_ast_type_paramORstr_orNone as intORlist_ast_type_paramORstr_orNone,
-	intORstr_orNone as intORstr_orNone,
-	list_ast_type_paramORstr_orNone as list_ast_type_paramORstr_orNone,
 	NodeORattribute as NodeORattribute,
 	str_nameDOTname as str_nameDOTname,
 	个 as 个,
-	)
+)
+
+from mapFolding.someAssemblyRequired._astTypes import *  # noqa: F403
 
 from mapFolding.someAssemblyRequired._toolboxPython import (
 	importLogicalPath2Callable as importLogicalPath2Callable,
@@ -75,11 +62,15 @@ from mapFolding.someAssemblyRequired._toolboxPython import (
 	NodeTourist as NodeTourist,
 	parseLogicalPath2astModule as parseLogicalPath2astModule,
 	parsePathFilename2astModule as parsePathFilename2astModule,
-	)
+)
 
-from mapFolding.someAssemblyRequired._toolboxAntecedents import be as be, DOT as DOT, ifThis as ifThis
-from mapFolding.someAssemblyRequired._tool_Make import Make as Make
-from mapFolding.someAssemblyRequired._tool_Then import grab as grab, Then as Then
+from mapFolding.someAssemblyRequired._toolBe import Be as Be
+from mapFolding.someAssemblyRequired._toolDOT import DOT as DOT
+from mapFolding.someAssemblyRequired._toolGrab import Grab as Grab
+from mapFolding.someAssemblyRequired._toolMake import Make as Make
+
+from mapFolding.someAssemblyRequired._toolIfThis import IfThis as IfThis
+from mapFolding.someAssemblyRequired._toolThen import Then as Then
 
 from mapFolding.someAssemblyRequired._toolboxContainers import (
 	DeReConstructField2ast as DeReConstructField2ast,
@@ -94,4 +85,4 @@ from mapFolding.someAssemblyRequired._toolboxAST import (
 	astModuleToIngredientsFunction as astModuleToIngredientsFunction,
 	extractClassDef as extractClassDef,
 	extractFunctionDef as extractFunctionDef,
-	)
+)

mapFolding/someAssemblyRequired/_astTypes.py

@@ -0,0 +1,117 @@
+"""This file is generated automatically, so changes to this file will be lost."""
+from mapFolding import astDOTParamSpec, astDOTTryStar, astDOTTypeAlias, astDOTTypeVar, astDOTTypeVarTuple, astDOTtype_param
+from typing import Any, TypeAlias as typing_TypeAlias
+import ast
+intORstr: typing_TypeAlias = Any
+intORstrORtype_params: typing_TypeAlias = Any
+intORtype_params: typing_TypeAlias = Any
+hasDOTannotation_expr: typing_TypeAlias = ast.AnnAssign
+hasDOTannotation_exprOrNone: typing_TypeAlias = ast.arg
+hasDOTannotation: typing_TypeAlias = hasDOTannotation_expr | hasDOTannotation_exprOrNone
+hasDOTarg_Identifier: typing_TypeAlias = ast.arg
+hasDOTarg_IdentifierOrNone: typing_TypeAlias = ast.keyword
+hasDOTarg: typing_TypeAlias = hasDOTarg_Identifier | hasDOTarg_IdentifierOrNone
+hasDOTargs_arguments: typing_TypeAlias = ast.FunctionDef | ast.AsyncFunctionDef | ast.Lambda
+hasDOTargs_list_expr: typing_TypeAlias = ast.Call
+hasDOTargs_list_arg: typing_TypeAlias = ast.arguments
+hasDOTargs: typing_TypeAlias = hasDOTargs_arguments | hasDOTargs_list_expr | hasDOTargs_list_arg
+hasDOTargtypes: typing_TypeAlias = ast.FunctionType
+hasDOTasname: typing_TypeAlias = ast.alias
+hasDOTattr: typing_TypeAlias = ast.Attribute
+hasDOTbases: typing_TypeAlias = ast.ClassDef
+hasDOTbody_list_stmt: typing_TypeAlias = ast.Module | ast.Interactive | ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef | ast.For | ast.AsyncFor | ast.While | ast.If | ast.With | ast.AsyncWith | ast.Try | ast.ExceptHandler | astDOTTryStar | ast.match_case
+hasDOTbody_expr: typing_TypeAlias = ast.Expression | ast.Lambda | ast.IfExp
+hasDOTbody: typing_TypeAlias = hasDOTbody_list_stmt | hasDOTbody_expr
+hasDOTbound: typing_TypeAlias = astDOTTypeVar
+hasDOTcases: typing_TypeAlias = ast.Match
+hasDOTcause: typing_TypeAlias = ast.Raise
+hasDOTcls: typing_TypeAlias = ast.MatchClass
+hasDOTcomparators: typing_TypeAlias = ast.Compare
+hasDOTcontext_expr: typing_TypeAlias = ast.withitem
+hasDOTconversion: typing_TypeAlias = ast.FormattedValue
+hasDOTctx: typing_TypeAlias = ast.Attribute | ast.Subscript | ast.Starred | ast.Name | ast.List | ast.Tuple
+hasDOTdecorator_list: typing_TypeAlias = ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef
+hasDOTdefault_value: typing_TypeAlias = astDOTTypeVar | astDOTParamSpec | astDOTTypeVarTuple
+hasDOTdefaults: typing_TypeAlias = ast.arguments
+hasDOTelt: typing_TypeAlias = ast.ListComp | ast.SetComp | ast.GeneratorExp
+hasDOTelts: typing_TypeAlias = ast.Set | ast.List | ast.Tuple
+hasDOTexc: typing_TypeAlias = ast.Raise
+hasDOTfinalbody: typing_TypeAlias = ast.Try | astDOTTryStar
+hasDOTformat_spec: typing_TypeAlias = ast.FormattedValue
+hasDOTfunc: typing_TypeAlias = ast.Call
+hasDOTgenerators: typing_TypeAlias = ast.ListComp | ast.SetComp | ast.DictComp | ast.GeneratorExp
+hasDOTguard: typing_TypeAlias = ast.match_case
+hasDOThandlers: typing_TypeAlias = ast.Try | astDOTTryStar
+hasDOTid: typing_TypeAlias = ast.Name
+hasDOTifs: typing_TypeAlias = ast.comprehension
+hasDOTis_async: typing_TypeAlias = ast.comprehension
+hasDOTitems: typing_TypeAlias = ast.With | ast.AsyncWith
+hasDOTiter: typing_TypeAlias = ast.For | ast.AsyncFor | ast.comprehension
+hasDOTkey: typing_TypeAlias = ast.DictComp
+hasDOTkeys_list_exprOrNone: typing_TypeAlias = ast.Dict
+hasDOTkeys_list_expr: typing_TypeAlias = ast.MatchMapping
+hasDOTkeys: typing_TypeAlias = hasDOTkeys_list_exprOrNone | hasDOTkeys_list_expr
+hasDOTkeywords: typing_TypeAlias = ast.ClassDef | ast.Call
+hasDOTkind: typing_TypeAlias = ast.Constant
+hasDOTkw_defaults: typing_TypeAlias = ast.arguments
+hasDOTkwarg: typing_TypeAlias = ast.arguments
+hasDOTkwd_attrs: typing_TypeAlias = ast.MatchClass
+hasDOTkwd_patterns: typing_TypeAlias = ast.MatchClass
+hasDOTkwonlyargs: typing_TypeAlias = ast.arguments
+hasDOTleft: typing_TypeAlias = ast.BinOp | ast.Compare
+hasDOTlevel: typing_TypeAlias = ast.ImportFrom
+hasDOTlineno: typing_TypeAlias = ast.TypeIgnore
+hasDOTlower: typing_TypeAlias = ast.Slice
+hasDOTmodule: typing_TypeAlias = ast.ImportFrom
+hasDOTmsg: typing_TypeAlias = ast.Assert
+hasDOTname_Identifier: typing_TypeAlias = ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef | astDOTTypeVar | astDOTParamSpec | astDOTTypeVarTuple
+hasDOTname_IdentifierOrNone: typing_TypeAlias = ast.ExceptHandler | ast.MatchStar | ast.MatchAs
+hasDOTname_str: typing_TypeAlias = ast.alias
+hasDOTname_Name: typing_TypeAlias = astDOTTypeAlias
+hasDOTname: typing_TypeAlias = hasDOTname_Identifier | hasDOTname_IdentifierOrNone | hasDOTname_str | hasDOTname_Name
+hasDOTnames_list_alias: typing_TypeAlias = ast.Import | ast.ImportFrom
+hasDOTnames_list_Identifier: typing_TypeAlias = ast.Global | ast.Nonlocal
+hasDOTnames: typing_TypeAlias = hasDOTnames_list_alias | hasDOTnames_list_Identifier
+hasDOTop_operator: typing_TypeAlias = ast.AugAssign | ast.BinOp
+hasDOTop_boolop: typing_TypeAlias = ast.BoolOp
+hasDOTop_unaryop: typing_TypeAlias = ast.UnaryOp
+hasDOTop: typing_TypeAlias = hasDOTop_operator | hasDOTop_boolop | hasDOTop_unaryop
+hasDOToperand: typing_TypeAlias = ast.UnaryOp
+hasDOTops: typing_TypeAlias = ast.Compare
+hasDOToptional_vars: typing_TypeAlias = ast.withitem
+hasDOTorelse_list_stmt: typing_TypeAlias = ast.For | ast.AsyncFor | ast.While | ast.If | ast.Try | astDOTTryStar
+hasDOTorelse_expr: typing_TypeAlias = ast.IfExp
+hasDOTorelse: typing_TypeAlias = hasDOTorelse_list_stmt | hasDOTorelse_expr
+hasDOTpattern_pattern: typing_TypeAlias = ast.match_case
+hasDOTpattern_patternOrNone: typing_TypeAlias = ast.MatchAs
+hasDOTpattern: typing_TypeAlias = hasDOTpattern_pattern | hasDOTpattern_patternOrNone
+hasDOTpatterns: typing_TypeAlias = ast.MatchSequence | ast.MatchMapping | ast.MatchClass | ast.MatchOr
+hasDOTposonlyargs: typing_TypeAlias = ast.arguments
+hasDOTrest: typing_TypeAlias = ast.MatchMapping
+hasDOTreturns_expr: typing_TypeAlias = ast.FunctionType
+hasDOTreturns_exprOrNone: typing_TypeAlias = ast.FunctionDef | ast.AsyncFunctionDef
+hasDOTreturns: typing_TypeAlias = hasDOTreturns_expr | hasDOTreturns_exprOrNone
+hasDOTright: typing_TypeAlias = ast.BinOp
+hasDOTsimple: typing_TypeAlias = ast.AnnAssign
+hasDOTslice: typing_TypeAlias = ast.Subscript
+hasDOTstep: typing_TypeAlias = ast.Slice
+hasDOTsubject: typing_TypeAlias = ast.Match
+hasDOTtag: typing_TypeAlias = ast.TypeIgnore
+hasDOTtarget_NameOrAttributeOrSubscript: typing_TypeAlias = ast.AugAssign | ast.AnnAssign
+hasDOTtarget_expr: typing_TypeAlias = ast.For | ast.AsyncFor | ast.comprehension
+hasDOTtarget_Name: typing_TypeAlias = ast.NamedExpr
+hasDOTtarget: typing_TypeAlias = hasDOTtarget_NameOrAttributeOrSubscript | hasDOTtarget_expr | hasDOTtarget_Name
+hasDOTtargets: typing_TypeAlias = ast.Delete | ast.Assign
+hasDOTtest: typing_TypeAlias = ast.While | ast.If | ast.Assert | ast.IfExp
+hasDOTtype: typing_TypeAlias = ast.ExceptHandler
+hasDOTtype_comment: typing_TypeAlias = ast.FunctionDef | ast.AsyncFunctionDef | ast.Assign | ast.For | ast.AsyncFor | ast.With | ast.AsyncWith | ast.arg
+hasDOTtype_ignores: typing_TypeAlias = ast.Module
+hasDOTtype_params: typing_TypeAlias = ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef | astDOTTypeAlias
+hasDOTupper: typing_TypeAlias = ast.Slice
+hasDOTvalue_exprOrNone: typing_TypeAlias = ast.Return | ast.AnnAssign | ast.Yield
+hasDOTvalue_expr: typing_TypeAlias = ast.Assign | ast.AugAssign | ast.Expr | ast.NamedExpr | ast.DictComp | ast.Await | ast.YieldFrom | ast.FormattedValue | ast.Attribute | ast.Subscript | ast.Starred | ast.keyword | astDOTTypeAlias | ast.MatchValue
+hasDOTvalue_Any: typing_TypeAlias = ast.Constant
+hasDOTvalue_LiteralTrueFalseOrNone: typing_TypeAlias = ast.MatchSingleton
+hasDOTvalue: typing_TypeAlias = hasDOTvalue_exprOrNone | hasDOTvalue_expr | hasDOTvalue_Any | hasDOTvalue_LiteralTrueFalseOrNone
+hasDOTvalues: typing_TypeAlias = ast.BoolOp | ast.Dict | ast.JoinedStr
+hasDOTvararg: typing_TypeAlias = ast.arguments

mapFolding/someAssemblyRequired/_theTypes.py

@@ -4,38 +4,15 @@ import ast
 
 # TODO understand typing.
 
-stuPyd: typing_TypeAlias = str
-
-# NOTE An idea to subclass antecedents to effectively TypeGuard more than just the top level of the antecedent.
+# NOTE Prototype of an idea to subclass composable methods so that typing information
+# can extend beyond the top level of the ast node.
 class ImaCallToName(ast.Call):
-	func: ast.Name # pyright: ignore[reportIncompatibleVariableOverride]
-	# assert isinstance(ast.Call.func, ast.Name), "brinkmanship"
-	# func: ast.Name
-
-# Some common attributes of ast classes.
-astClassHasDOTbody_expr: typing_TypeAlias = ast.Expression | ast.IfExp | ast.Lambda
-astClassHasDOTbodyList_stmt: typing_TypeAlias = ast.AsyncFor | ast.AsyncWith | ast.ClassDef | ast.ExceptHandler | ast.For | ast.FunctionDef | ast.If | ast.Interactive | ast.match_case | ast.Module | ast.Try | astDOTTryStar | ast.While | ast.With
-astClassHasDOTbody: typing_TypeAlias = astClassHasDOTbody_expr | astClassHasDOTbodyList_stmt
-
-astClassHasDOTnameNotNameAlways: typing_TypeAlias = ast.alias | ast.AsyncFunctionDef | ast.ClassDef | ast.FunctionDef | astDOTParamSpec | astDOTTypeVar | astDOTTypeVarTuple
-astClassHasDOTnameNotNameOptionally: typing_TypeAlias = ast.ExceptHandler | ast.MatchAs | ast.MatchStar
-astClassHasDOTnameNotName: typing_TypeAlias = astClassHasDOTnameNotNameAlways | astClassHasDOTnameNotNameOptionally
-
-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
-
-astClassHasDOTvalue_expr: typing_TypeAlias = ast.Assign | ast.Attribute | ast.AugAssign | ast.Await | ast.DictComp | ast.Expr | ast.FormattedValue | ast.keyword | ast.MatchValue | ast.NamedExpr | ast.Starred | ast.Subscript | astDOTTypeAlias | ast.YieldFrom
-astClassHasDOTvalue_exprNone: typing_TypeAlias = ast.AnnAssign | ast.Return | ast.Yield
-astClassHasDOTvalue: typing_TypeAlias = ast.Constant | ast.MatchSingleton | astClassHasDOTvalue_expr | astClassHasDOTvalue_exprNone
+	func: ast.Name 	# pyright: ignore[reportIncompatibleVariableOverride]
 
 # Type hints through TypeAlias or type "hints" through the identifier name.
 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
-str_nameDOTname: typing_TypeAlias = stuPyd
+str_nameDOTname: typing_TypeAlias = str
 
 # Limited success with TypeVar.
 个 = typing_TypeVar('个', bound = ast.AST, covariant = True)