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

mapFolding/__init__.py

@@ -47,38 +47,22 @@ foundation for exploring advanced code transformation techniques.
 from typing import Any, TypeAlias
 import sys
 
-stuPyd: TypeAlias = Any
-
-if sys.version_info >= (3, 12):
-	from ast import (
-		ParamSpec as astDOTParamSpec,
-		type_param as astDOTtype_param,
-		TypeAlias as astDOTTypeAlias,
-		TypeVar as astDOTTypeVar,
-		TypeVarTuple as astDOTTypeVarTuple,
-	)
-else:
-	astDOTParamSpec: TypeAlias = stuPyd
-	astDOTtype_param: TypeAlias = stuPyd
-	astDOTTypeAlias: TypeAlias = stuPyd
-	astDOTTypeVar: TypeAlias = stuPyd
-	astDOTTypeVarTuple: TypeAlias = stuPyd
+yourPythonIsOld: TypeAlias = Any
+# ruff: noqa: E402
 
 if sys.version_info >= (3, 11):
-	from ast import TryStar as astDOTTryStar
 	from typing import TypedDict as TypedDict
 	from typing import NotRequired as NotRequired
 else:
-	astDOTTryStar: TypeAlias = stuPyd
 	try:
 		from typing_extensions import TypedDict as TypedDict
 		from typing_extensions import NotRequired as NotRequired
 	except Exception:
-		TypedDict = dict[stuPyd, stuPyd]
+		TypedDict = dict[yourPythonIsOld, yourPythonIsOld]
 		from collections.abc import Iterable
 		NotRequired: TypeAlias = Iterable
 
-from mapFolding.datatypes import (  # noqa: E402
+from mapFolding.datatypes import (
 	Array1DElephino as Array1DElephino,
 	Array1DFoldsTotal as Array1DFoldsTotal,
 	Array1DLeavesTotal as Array1DLeavesTotal,
@@ -92,18 +76,18 @@ from mapFolding.datatypes import (  # noqa: E402
 	NumPyLeavesTotal as NumPyLeavesTotal,
 )
 
-from mapFolding.theSSOT import (  # noqa: E402
+from mapFolding.theSSOT import (
 	ComputationState as ComputationState,
 	raiseIfNoneGitHubIssueNumber3 as raiseIfNoneGitHubIssueNumber3,
 	The as The,
 )
 
-from mapFolding.theDao import (  # noqa: E402
+from mapFolding.theDao import (
 	countInitialize as countInitialize,
 	doTheNeedful as doTheNeedful,
 )
 
-from mapFolding.beDRY import (  # noqa: E402
+from mapFolding.beDRY import (
 	getLeavesTotal as getLeavesTotal,
 	getTaskDivisions as getTaskDivisions,
 	outfitCountFolds as outfitCountFolds,
@@ -111,17 +95,18 @@ from mapFolding.beDRY import (  # noqa: E402
 	validateListDimensions as validateListDimensions,
 )
 
-from mapFolding.toolboxFilesystem import (  # noqa: E402
+from mapFolding.toolboxFilesystem import (
 	getPathFilenameFoldsTotal as getPathFilenameFoldsTotal,
 	getPathRootJobDEFAULT as getPathRootJobDEFAULT,
 	saveFoldsTotal as saveFoldsTotal,
 	saveFoldsTotalFAILearly as saveFoldsTotalFAILearly,
-	writeStringToHere as writeStringToHere,
 )
 
-from mapFolding.basecamp import countFolds as countFolds  # noqa: E402
+from Z0Z_tools import writeStringToHere as writeStringToHere
+
+from mapFolding.basecamp import countFolds as countFolds
 
-from mapFolding.oeis import (  # noqa: E402
+from mapFolding.oeis import (
 	clearOEIScache as clearOEIScache,
 	getFoldsTotalKnown as getFoldsTotalKnown,
 	getOEISids as getOEISids,

mapFolding/someAssemblyRequired/Z0Z_makeSomeModules.py

@@ -9,24 +9,24 @@ from mapFolding.someAssemblyRequired import (
 	IfThis,
 	IngredientsFunction,
 	IngredientsModule,
+	inlineFunctionDef,
 	LedgerOfImports,
 	Make,
 	NodeChanger,
 	NodeTourist,
 	parseLogicalPath2astModule,
 	parsePathFilename2astModule,
-	Then,
+	removeUnusedParameters,
 	str_nameDOTname,
+	Then,
+	write_astModule,
 )
 from mapFolding.someAssemblyRequired.toolboxNumba import decorateCallableWithNumba, parametersNumbaLight
 from mapFolding.someAssemblyRequired.transformationTools import (
-	inlineFunctionDef,
 	removeDataclassFromFunction,
-	removeUnusedParameters,
 	shatter_dataclassesDOTdataclass,
 	unpackDataclassCallFunctionRepackDataclass,
-	write_astModule,
-	)
+)
 from pathlib import PurePath
 import ast
 
@@ -58,10 +58,7 @@ def makeInitializeGroupsOfFolds() -> None:
 	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
-	]))
+	doThat = Grab.testAttribute(Grab.andDoAllOf([ Grab.opsAttribute(Then.replaceWith([ast.Eq()])), Grab.leftAttribute(Grab.attrAttribute(Then.replaceWith(theCountingIdentifier))) ])) # type: ignore
 	NodeChanger(findThis, doThat).visit(countInitializeIngredients.astFunctionDef.body[0])
 
 	ingredientsModule = IngredientsModule(countInitializeIngredients)
@@ -171,7 +168,7 @@ def makeTheorem2() -> PurePath:
 	doThat = Then.removeIt
 	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
 
-	findThis = IfThis.isAttributeNamespace_IdentifierLessThanOrEqual(dataclassInstanceIdentifier, 'leaf1ndex')
+	findThis = IfThis.isAttributeNamespace_IdentifierLessThanOrEqual0(dataclassInstanceIdentifier, 'leaf1ndex')
 	doThat = Then.removeIt
 	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
 
@@ -301,7 +298,8 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom) -> None:
 	doTheNeedful.imports.addAst(astImportFrom)
 	targetCallableIdentifier = astImportFrom.names[0].name
 	doTheNeedful = unpackDataclassCallFunctionRepackDataclass(doTheNeedful, targetCallableIdentifier, shatteredDataclass)
-	targetFunctionDef = extractFunctionDef(parseLogicalPath2astModule(astImportFrom.module), targetCallableIdentifier) # type: ignore
+	if astImportFrom.module is None: raise raiseIfNoneGitHubIssueNumber3
+	targetFunctionDef = extractFunctionDef(parseLogicalPath2astModule(astImportFrom.module), targetCallableIdentifier)
 	if targetFunctionDef is None: raise raiseIfNoneGitHubIssueNumber3
 	astTuple: ast.Tuple | None = NodeTourist(Be.Return, Then.extractIt(DOT.value)).captureLastMatch(targetFunctionDef)
 	if astTuple is None: raise raiseIfNoneGitHubIssueNumber3

mapFolding/someAssemblyRequired/__init__.py

@@ -44,45 +44,41 @@ optimizations - while maintaining the ability to verify correctness at each tran
 test suite.
 """
 
-from mapFolding.someAssemblyRequired._theTypes import (
+from astToolkit import (
 	ast_expr_Slice as ast_expr_Slice,
 	ast_Identifier as ast_Identifier,
-	ImaCallToName as ImaCallToName,
-	NodeORattribute as NodeORattribute,
-	str_nameDOTname as str_nameDOTname,
-	个 as 个,
-)
-
-from mapFolding.someAssemblyRequired._astTypes import *  # noqa: F403
-
-from mapFolding.someAssemblyRequired._toolboxPython import (
+	astModuleToIngredientsFunction as astModuleToIngredientsFunction,
+	Be as Be,
+	DOT as DOT,
+	extractClassDef as extractClassDef,
+	extractFunctionDef as extractFunctionDef,
+	Grab as Grab,
 	importLogicalPath2Callable as importLogicalPath2Callable,
 	importPathFilename2Callable as importPathFilename2Callable,
+	IngredientsFunction as IngredientsFunction,
+	IngredientsModule as IngredientsModule,
+	LedgerOfImports as LedgerOfImports,
+	Make as Make,
 	NodeChanger as NodeChanger,
+	NodeORattribute as NodeORattribute,
 	NodeTourist as NodeTourist,
 	parseLogicalPath2astModule as parseLogicalPath2astModule,
 	parsePathFilename2astModule as parsePathFilename2astModule,
+	str_nameDOTname as str_nameDOTname,
+	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 astToolkit.transformationTools import (
+	inlineFunctionDef as inlineFunctionDef,
+	removeUnusedParameters as removeUnusedParameters,
+	unparseFindReplace as unparseFindReplace,
+	write_astModule as write_astModule,
+)
 
 from mapFolding.someAssemblyRequired._toolIfThis import IfThis as IfThis
-from mapFolding.someAssemblyRequired._toolThen import Then as Then
 
 from mapFolding.someAssemblyRequired._toolboxContainers import (
 	DeReConstructField2ast as DeReConstructField2ast,
-	IngredientsFunction as IngredientsFunction,
-	IngredientsModule as IngredientsModule,
-	LedgerOfImports as LedgerOfImports,
 	RecipeSynthesizeFlow as RecipeSynthesizeFlow,
 	ShatteredDataclass as ShatteredDataclass,
 )
-
-from mapFolding.someAssemblyRequired._toolboxAST import (
-	astModuleToIngredientsFunction as astModuleToIngredientsFunction,
-	extractClassDef as extractClassDef,
-	extractFunctionDef as extractFunctionDef,
-)

mapFolding/someAssemblyRequired/_toolIfThis.py

@@ -19,17 +19,13 @@ they implement a declarative approach to AST manipulation that separates node id
 (be), and data access (DOT).
 """
 
+from astToolkit import IfThis as astToolkit_IfThis
 from collections.abc import Callable
-from mapFolding.someAssemblyRequired import (
-	ast_Identifier,
-	Be,
-	DOT,
-	ImaCallToName,
-)
-from typing import Any, TypeGuard
+from mapFolding.someAssemblyRequired import ast_Identifier, Be
+from typing import TypeGuard
 import ast
 
-class IfThis:
+class IfThis(astToolkit_IfThis):
 	"""
 	Provide predicate functions for matching and filtering AST nodes based on various criteria.
 
@@ -40,75 +36,12 @@ class IfThis:
 	The class provides predicates for matching various node types, attributes, identifiers, and structural patterns,
 	enabling precise targeting of AST elements for analysis or transformation.
 	"""
-	@staticmethod
-	def _Identifier(identifier: ast_Identifier) -> Callable[[ast_Identifier | None], TypeGuard[ast_Identifier] | bool]:
-		return lambda node: node == identifier
-	@staticmethod
-	def _nested_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Attribute | ast.Starred | ast.Subscript] | bool]:
-		def workhorse(node: ast.AST) -> TypeGuard[ast.Attribute | ast.Starred | ast.Subscript] | 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 is_arg_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.arg] | bool]:
-		"""see also `isArgument_Identifier`"""
-		return lambda node: Be.arg(node) and IfThis._Identifier(identifier)(DOT.arg(node))
-	@staticmethod
-	def is_keyword_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.keyword] | bool]:
-		"""see also `isArgument_Identifier`"""
-		return lambda node: Be.keyword(node) and IfThis._Identifier(identifier)(DOT.arg(node))
-
-	@staticmethod
-	def isAnnAssign_targetIs(targetPredicate: Callable[[ast.expr], TypeGuard[ast.expr] | bool]) -> Callable[[ast.AST], TypeGuard[ast.AnnAssign] | bool]:
-		def workhorse(node: ast.AST) -> TypeGuard[ast.AnnAssign] | bool:
-			return Be.AnnAssign(node) and targetPredicate(DOT.target(node))
-		return workhorse
-
-	@staticmethod
-	def isArgument_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.arg | ast.keyword] | bool]:
-		return lambda node: (Be.arg(node) or Be.keyword(node)) and IfThis._Identifier(identifier)(DOT.arg(node))
-
-	@staticmethod
-	def isAssignAndTargets0Is(targets0Predicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], TypeGuard[ast.AnnAssign] | bool]:
-		"""node is Assign and node.targets[0] matches `targets0Predicate`."""
-		return lambda node: Be.Assign(node) and targets0Predicate(node.targets[0])
-	@staticmethod
-	def isAssignAndValueIs(valuePredicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], TypeGuard[ast.Assign] | bool]:
-		"""node is ast.Assign and node.value matches `valuePredicate`. """
-		return lambda node: Be.Assign(node) and valuePredicate(DOT.value(node))
-
-	@staticmethod
-	def isAttribute_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Attribute] | bool]:
-		"""node is `ast.Attribute` and the top-level `ast.Name` is `identifier`"""
-		def workhorse(node: ast.AST) -> TypeGuard[ast.Attribute]:
-			return Be.Attribute(node) and IfThis._nested_Identifier(identifier)(DOT.value(node))
-		return workhorse
-	@staticmethod
-	def isAttributeName(node: ast.AST) -> TypeGuard[ast.Attribute]:
-		""" Displayed as Name.attribute."""
-		return Be.Attribute(node) and Be.Name(DOT.value(node))
-	@staticmethod
-	def isAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Attribute] | bool]:
-		return lambda node: IfThis.isAttributeName(node) and IfThis.isName_Identifier(namespace)(DOT.value(node)) and IfThis._Identifier(identifier)(DOT.attr(node))
-
 	@staticmethod
 	def isAttributeNamespace_IdentifierGreaterThan0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Compare] | bool]:
 		return lambda node: (Be.Compare(node)
 					and IfThis.isAttributeNamespace_Identifier(namespace, identifier)(node.left)
 					and Be.Gt(node.ops[0])
 					and IfThis.isConstant_value(0)(node.comparators[0]))
-
-	@staticmethod
-	def isUnaryNotAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.UnaryOp] | bool]:
-		return lambda node: (Be.UnaryOp(node)
-					and Be.Not(node.op)
-					and IfThis.isAttributeNamespace_Identifier(namespace, identifier)(node.operand))
-
-	@staticmethod
-	def isIfUnaryNotAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.If] | bool]:
-		return lambda node: (Be.If(node)
-					and IfThis.isUnaryNotAttributeNamespace_Identifier(namespace, identifier)(node.test))
-
 	@staticmethod
 	def isIfAttributeNamespace_IdentifierGreaterThan0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.If] | bool]:
 		return lambda node: (Be.If(node)
@@ -120,74 +53,7 @@ class IfThis:
 					and IfThis.isAttributeNamespace_IdentifierGreaterThan0(namespace, identifier)(node.test))
 
 	@staticmethod
-	def isAttributeNamespace_IdentifierLessThanOrEqual(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Compare] | bool]:
+	def isAttributeNamespace_IdentifierLessThanOrEqual0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Compare] | bool]:
 		return lambda node: (Be.Compare(node)
 					and IfThis.isAttributeNamespace_Identifier(namespace, identifier)(node.left)
 					and Be.LtE(node.ops[0]))
-
-	@staticmethod
-	def isAugAssign_targetIs(targetPredicate: Callable[[ast.expr], TypeGuard[ast.expr] | bool]) -> Callable[[ast.AST], TypeGuard[ast.AugAssign] | bool]:
-		def workhorse(node: ast.AST) -> TypeGuard[ast.AugAssign] | bool:
-			return Be.AugAssign(node) and targetPredicate(DOT.target(node))
-		return workhorse
-
-	@staticmethod
-	def isCall_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ImaCallToName] | bool]:
-		def workhorse(node: ast.AST) -> TypeGuard[ImaCallToName] | bool:
-			return IfThis.isCallToName(node) and IfThis._Identifier(identifier)(DOT.id(DOT.func(node)))
-		return workhorse
-
-	@staticmethod
-	def isCallAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Call] | bool]:
-		def workhorse(node: ast.AST) -> TypeGuard[ast.Call] | bool:
-			return Be.Call(node) and IfThis.isAttributeNamespace_Identifier(namespace, identifier)(DOT.func(node))
-		return workhorse
-	@staticmethod
-	def isCallToName(node: ast.AST) -> TypeGuard[ImaCallToName]:
-		return Be.Call(node) and Be.Name(DOT.func(node))
-
-	@staticmethod
-	def isClassDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.ClassDef] | bool]:
-		return lambda node: Be.ClassDef(node) and IfThis._Identifier(identifier)(DOT.name(node))
-
-	@staticmethod
-	def isConstant_value(value: Any) -> Callable[[ast.AST], TypeGuard[ast.Constant] | bool]:
-		return lambda node: Be.Constant(node) and DOT.value(node) == value
-
-	@staticmethod
-	def isFunctionDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.FunctionDef] | bool]:
-		return lambda node: Be.FunctionDef(node) and IfThis._Identifier(identifier)(DOT.name(node))
-
-	@staticmethod
-	def isName_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Name] | bool]:
-		return lambda node: Be.Name(node) and IfThis._Identifier(identifier)(DOT.id(node))
-
-	@staticmethod
-	def isStarred_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Starred] | bool]:
-		"""node is `ast.Starred` and the top-level `ast.Name` is `identifier`"""
-		def workhorse(node: ast.AST) -> TypeGuard[ast.Starred]:
-			return Be.Starred(node) and IfThis._nested_Identifier(identifier)(DOT.value(node))
-		return workhorse
-	@staticmethod
-	def isSubscript_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Subscript] | bool]:
-		"""node is `ast.Subscript` and the top-level `ast.Name` is `identifier`"""
-		def workhorse(node: ast.AST) -> TypeGuard[ast.Subscript]:
-			return Be.Subscript(node) and IfThis._nested_Identifier(identifier)(DOT.value(node))
-		return workhorse
-
-	@staticmethod
-	def matchesMeButNotAnyDescendant(predicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], bool]:
-		return lambda node: predicate(node) and IfThis.matchesNoDescendant(predicate)(node)
-	@staticmethod
-	def matchesNoDescendant(predicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], bool]:
-		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 Z0Z_unparseIs(astAST: ast.AST) -> Callable[[ast.AST], bool]:
-		def workhorse(node: ast.AST) -> bool: return ast.unparse(node) == ast.unparse(astAST)
-		return workhorse