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

mapFolding/someAssemblyRequired/_toolMake.py

@@ -1,339 +0,0 @@
-"""This file is generated automatically, so changes to this file will be lost."""
-from collections.abc import Sequence
-from mapFolding import astDOTParamSpec, astDOTTryStar, astDOTTypeAlias, astDOTTypeVar, astDOTTypeVarTuple, astDOTtype_param
-from mapFolding.someAssemblyRequired import ast_Identifier, ast_expr_Slice, intORstr, intORstrORtype_params, intORtype_params, str_nameDOTname
-from typing import Any, Literal
-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, **keywordArguments: int) -> ast.alias:
-        return ast.alias(name, asName, **keywordArguments)
-
-    @staticmethod
-    def AnnAssign(target: ast.Name | ast.Attribute | ast.Subscript, annotation: ast.expr, value: ast.expr | None, **keywordArguments: int) -> ast.AnnAssign:
-        return ast.AnnAssign(target, annotation, value, **keywordArguments, simple=int(isinstance(target, ast.Name)))
-
-    @staticmethod
-    def arg(arg: ast_Identifier, annotation: ast.expr | None, **keywordArguments: intORstr) -> ast.arg:
-        return ast.arg(arg, annotation, **keywordArguments)
-
-    @staticmethod
-    def arguments(posonlyargs: list[ast.arg]=[], args: list[ast.arg]=[], vararg: ast.arg | None=None, kwonlyargs: list[ast.arg]=[], kw_defaults: Sequence[ast.expr | None]=[None], kwarg: ast.arg | None=None, defaults: Sequence[ast.expr]=[], **keywordArguments: int) -> ast.arguments:
-        return ast.arguments(posonlyargs, args, vararg, kwonlyargs, list(kw_defaults), kwarg, list(defaults), **keywordArguments)
-
-    @staticmethod
-    def Assert(test: ast.expr, msg: ast.expr | None, **keywordArguments: int) -> ast.Assert:
-        return ast.Assert(test, msg, **keywordArguments)
-
-    @staticmethod
-    def Assign(targets: Sequence[ast.expr], value: ast.expr, **keywordArguments: intORstr) -> ast.Assign:
-        return ast.Assign(list(targets), value, **keywordArguments)
-
-    @staticmethod
-    def AsyncFor(target: ast.expr, iter: ast.expr, body: Sequence[ast.stmt], orElse: Sequence[ast.stmt]=[], **keywordArguments: intORstr) -> ast.AsyncFor:
-        return ast.AsyncFor(target, iter, list(body), list(orElse), **keywordArguments)
-
-    @staticmethod
-    def AsyncFunctionDef(name: ast_Identifier, args: ast.arguments, body: Sequence[ast.stmt], decorator_list: Sequence[ast.expr]=[], returns: ast.expr | None=None, **keywordArguments: intORstrORtype_params) -> ast.AsyncFunctionDef:
-        return ast.AsyncFunctionDef(name, args, list(body), list(decorator_list), returns, **keywordArguments)
-
-    @staticmethod
-    def AsyncWith(items: list[ast.withitem], body: Sequence[ast.stmt], **keywordArguments: intORstr) -> ast.AsyncWith:
-        return ast.AsyncWith(items, list(body), **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 (e.g., `ast.Name`.)
-		attribute: an `ast_Identifier` after a dot `.`; you can pass multiple `attribute` and they will be chained together.
-	"""
-
-        def addDOTattribute(chain: ast.expr, 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
-    def AugAssign(target: ast.Name | ast.Attribute | ast.Subscript, op: ast.operator, value: ast.expr, **keywordArguments: int) -> ast.AugAssign:
-        return ast.AugAssign(target, op, value, **keywordArguments)
-
-    @staticmethod
-    def Await(value: ast.expr, **keywordArguments: int) -> ast.Await:
-        return ast.Await(value, **keywordArguments)
-
-    @staticmethod
-    def BinOp(left: ast.expr, op: ast.operator, right: ast.expr, **keywordArguments: int) -> ast.BinOp:
-        return ast.BinOp(left, op, right, **keywordArguments)
-
-    @staticmethod
-    def BoolOp(op: ast.boolop, values: Sequence[ast.expr], **keywordArguments: int) -> ast.BoolOp:
-        return ast.BoolOp(op, list(values), **keywordArguments)
-
-    @staticmethod
-    def Call(callee: ast.expr, args: Sequence[ast.expr]=[], list_keyword: list[ast.keyword]=[], **keywordArguments: int) -> ast.Call:
-        return ast.Call(callee, list(args), list_keyword, **keywordArguments)
-
-    @staticmethod
-    def ClassDef(name: ast_Identifier, bases: Sequence[ast.expr], list_keyword: list[ast.keyword]=[], body: Sequence[ast.stmt]=[], decorator_list: Sequence[ast.expr]=[], **keywordArguments: intORtype_params) -> ast.ClassDef:
-        return ast.ClassDef(name, list(bases), list_keyword, list(body), list(decorator_list), **keywordArguments)
-
-    @staticmethod
-    def Compare(left: ast.expr, ops: Sequence[ast.cmpop], comparators: Sequence[ast.expr], **keywordArguments: int) -> ast.Compare:
-        return ast.Compare(left, list(ops), list(comparators), **keywordArguments)
-
-    @staticmethod
-    def comprehension(target: ast.expr, iter: ast.expr, ifs: Sequence[ast.expr], is_async: int, **keywordArguments: int) -> ast.comprehension:
-        return ast.comprehension(target, iter, list(ifs), is_async, **keywordArguments)
-
-    @staticmethod
-    def Constant(value: Any, **keywordArguments: intORstr) -> ast.Constant:
-        return ast.Constant(value, **keywordArguments)
-
-    @staticmethod
-    def Delete(targets: Sequence[ast.expr], **keywordArguments: int) -> ast.Delete:
-        return ast.Delete(list(targets), **keywordArguments)
-
-    @staticmethod
-    def Dict(keys: Sequence[ast.expr | None], values: Sequence[ast.expr], **keywordArguments: int) -> ast.Dict:
-        return ast.Dict(list(keys), list(values), **keywordArguments)
-
-    @staticmethod
-    def DictComp(key: ast.expr, value: ast.expr, generators: list[ast.comprehension], **keywordArguments: int) -> ast.DictComp:
-        return ast.DictComp(key, value, generators, **keywordArguments)
-
-    @staticmethod
-    def ExceptHandler(type: ast.expr | None, name: ast_Identifier | None, body: Sequence[ast.stmt], **keywordArguments: int) -> ast.ExceptHandler:
-        return ast.ExceptHandler(type, name, list(body), **keywordArguments)
-
-    @staticmethod
-    def Expr(value: ast.expr, **keywordArguments: int) -> ast.Expr:
-        return ast.Expr(value, **keywordArguments)
-
-    @staticmethod
-    def Expression(body: ast.expr) -> ast.Expression:
-        return ast.Expression(body)
-
-    @staticmethod
-    def For(target: ast.expr, iter: ast.expr, body: Sequence[ast.stmt], orElse: Sequence[ast.stmt]=[], **keywordArguments: intORstr) -> ast.For:
-        return ast.For(target, iter, list(body), list(orElse), **keywordArguments)
-
-    @staticmethod
-    def FormattedValue(value: ast.expr, conversion: int, format_spec: ast.expr | None, **keywordArguments: int) -> ast.FormattedValue:
-        return ast.FormattedValue(value, conversion, format_spec, **keywordArguments)
-
-    @staticmethod
-    def FunctionDef(name: ast_Identifier, args: ast.arguments, body: Sequence[ast.stmt], decorator_list: Sequence[ast.expr]=[], returns: ast.expr | None=None, **keywordArguments: intORstrORtype_params) -> ast.FunctionDef:
-        return ast.FunctionDef(name, args, list(body), list(decorator_list), returns, **keywordArguments)
-
-    @staticmethod
-    def FunctionType(argtypes: Sequence[ast.expr], returns: ast.expr) -> ast.FunctionType:
-        return ast.FunctionType(list(argtypes), returns)
-
-    @staticmethod
-    def GeneratorExp(elt: ast.expr, generators: list[ast.comprehension], **keywordArguments: int) -> ast.GeneratorExp:
-        return ast.GeneratorExp(elt, generators, **keywordArguments)
-
-    @staticmethod
-    def Global(names: list[ast_Identifier], **keywordArguments: int) -> ast.Global:
-        return ast.Global(names, **keywordArguments)
-
-    @staticmethod
-    def If(test: ast.expr, body: Sequence[ast.stmt], orElse: Sequence[ast.stmt]=[], **keywordArguments: int) -> ast.If:
-        return ast.If(test, list(body), list(orElse), **keywordArguments)
-
-    @staticmethod
-    def IfExp(test: ast.expr, body: ast.expr, orElse: ast.expr, **keywordArguments: int) -> ast.IfExp:
-        return ast.IfExp(test, body, orElse, **keywordArguments)
-
-    @staticmethod
-    def Import(moduleWithLogicalPath: str_nameDOTname, asName: ast_Identifier | None=None, **keywordArguments: int) -> ast.Import:
-        return ast.Import(names=[Make.alias(moduleWithLogicalPath, asName)], **keywordArguments)
-
-    @staticmethod
-    def ImportFrom(module: ast_Identifier | None, list_alias: list[ast.alias], **keywordArguments: int) -> ast.ImportFrom:
-        return ast.ImportFrom(module, list_alias, **keywordArguments, level=0)
-
-    @staticmethod
-    def Interactive(body: Sequence[ast.stmt]) -> ast.Interactive:
-        return ast.Interactive(list(body))
-
-    @staticmethod
-    def JoinedStr(values: Sequence[ast.expr], **keywordArguments: int) -> ast.JoinedStr:
-        return ast.JoinedStr(list(values), **keywordArguments)
-
-    @staticmethod
-    def keyword(arg: ast_Identifier | None, value: ast.expr, **keywordArguments: int) -> ast.keyword:
-        return ast.keyword(arg, value, **keywordArguments)
-
-    @staticmethod
-    def Lambda(args: ast.arguments, body: ast.expr, **keywordArguments: int) -> ast.Lambda:
-        return ast.Lambda(args, body, **keywordArguments)
-
-    @staticmethod
-    def List(elts: Sequence[ast.expr], context: ast.expr_context=ast.Load(), **keywordArguments: int) -> ast.List:
-        return ast.List(list(elts), context, **keywordArguments)
-
-    @staticmethod
-    def ListComp(elt: ast.expr, generators: list[ast.comprehension], **keywordArguments: int) -> ast.ListComp:
-        return ast.ListComp(elt, generators, **keywordArguments)
-
-    @staticmethod
-    def Match(subject: ast.expr, cases: list[ast.match_case], **keywordArguments: int) -> ast.Match:
-        return ast.Match(subject, cases, **keywordArguments)
-
-    @staticmethod
-    def match_case(pattern: ast.pattern, guard: ast.expr | None, body: Sequence[ast.stmt], **keywordArguments: int) -> ast.match_case:
-        return ast.match_case(pattern, guard, list(body), **keywordArguments)
-
-    @staticmethod
-    def MatchAs(pattern: ast.pattern | None, name: ast_Identifier | None, **keywordArguments: int) -> ast.MatchAs:
-        return ast.MatchAs(pattern, name, **keywordArguments)
-
-    @staticmethod
-    def MatchClass(cls: ast.expr, patterns: Sequence[ast.pattern], kwd_attrs: list[ast_Identifier], kwd_patterns: Sequence[ast.pattern], **keywordArguments: int) -> ast.MatchClass:
-        return ast.MatchClass(cls, list(patterns), kwd_attrs, list(kwd_patterns), **keywordArguments)
-
-    @staticmethod
-    def MatchMapping(keys: Sequence[ast.expr], patterns: Sequence[ast.pattern], rest: ast_Identifier | None, **keywordArguments: int) -> ast.MatchMapping:
-        return ast.MatchMapping(list(keys), list(patterns), rest, **keywordArguments)
-
-    @staticmethod
-    def MatchOr(patterns: Sequence[ast.pattern], **keywordArguments: int) -> ast.MatchOr:
-        return ast.MatchOr(list(patterns), **keywordArguments)
-
-    @staticmethod
-    def MatchSequence(patterns: Sequence[ast.pattern], **keywordArguments: int) -> ast.MatchSequence:
-        return ast.MatchSequence(list(patterns), **keywordArguments)
-
-    @staticmethod
-    def MatchSingleton(value: Literal[True, False] | None, **keywordArguments: int) -> ast.MatchSingleton:
-        return ast.MatchSingleton(value, **keywordArguments)
-
-    @staticmethod
-    def MatchStar(name: ast_Identifier | None, **keywordArguments: int) -> ast.MatchStar:
-        return ast.MatchStar(name, **keywordArguments)
-
-    @staticmethod
-    def MatchValue(value: ast.expr, **keywordArguments: int) -> ast.MatchValue:
-        return ast.MatchValue(value, **keywordArguments)
-
-    @staticmethod
-    def Module(body: Sequence[ast.stmt], type_ignores: list[ast.TypeIgnore]=[]) -> ast.Module:
-        return ast.Module(list(body), type_ignores)
-
-    @staticmethod
-    def Name(id: ast_Identifier, context: ast.expr_context=ast.Load(), **keywordArguments: int) -> ast.Name:
-        return ast.Name(id, context, **keywordArguments)
-
-    @staticmethod
-    def NamedExpr(target: ast.Name, value: ast.expr, **keywordArguments: int) -> ast.NamedExpr:
-        return ast.NamedExpr(target, value, **keywordArguments)
-
-    @staticmethod
-    def Nonlocal(names: list[ast_Identifier], **keywordArguments: int) -> ast.Nonlocal:
-        return ast.Nonlocal(names, **keywordArguments)
-
-    @staticmethod
-    def ParamSpec(name: ast_Identifier, default_value: ast.expr | None, **keywordArguments: int) -> astDOTParamSpec:
-        return astDOTParamSpec(name, default_value, **keywordArguments)
-
-    @staticmethod
-    def Raise(exc: ast.expr | None, cause: ast.expr | None, **keywordArguments: int) -> ast.Raise:
-        return ast.Raise(exc, cause, **keywordArguments)
-
-    @staticmethod
-    def Return(value: ast.expr | None, **keywordArguments: int) -> ast.Return:
-        return ast.Return(value, **keywordArguments)
-
-    @staticmethod
-    def Set(elts: Sequence[ast.expr], **keywordArguments: int) -> ast.Set:
-        return ast.Set(list(elts), **keywordArguments)
-
-    @staticmethod
-    def SetComp(elt: ast.expr, generators: list[ast.comprehension], **keywordArguments: int) -> ast.SetComp:
-        return ast.SetComp(elt, generators, **keywordArguments)
-
-    @staticmethod
-    def Slice(lower: ast.expr | None, upper: ast.expr | None, step: ast.expr | None, **keywordArguments: int) -> ast.Slice:
-        return ast.Slice(lower, upper, step, **keywordArguments)
-
-    @staticmethod
-    def Starred(value: ast.expr, context: ast.expr_context=ast.Load(), **keywordArguments: int) -> ast.Starred:
-        return ast.Starred(value, context, **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 Try(body: Sequence[ast.stmt], handlers: list[ast.ExceptHandler], orElse: Sequence[ast.stmt], finalbody: Sequence[ast.stmt]=[], **keywordArguments: int) -> ast.Try:
-        return ast.Try(list(body), handlers, list(orElse), list(finalbody), **keywordArguments)
-
-    @staticmethod
-    def TryStar(body: Sequence[ast.stmt], handlers: list[ast.ExceptHandler], orElse: Sequence[ast.stmt], finalbody: Sequence[ast.stmt]=[], **keywordArguments: int) -> astDOTTryStar:
-        return astDOTTryStar(list(body), handlers, list(orElse), list(finalbody), **keywordArguments)
-
-    @staticmethod
-    def Tuple(elts: Sequence[ast.expr], context: ast.expr_context=ast.Load(), **keywordArguments: int) -> ast.Tuple:
-        return ast.Tuple(list(elts), context, **keywordArguments)
-
-    @staticmethod
-    def TypeAlias(name: ast.Name, type_params: Sequence[astDOTtype_param], value: ast.expr, **keywordArguments: int) -> astDOTTypeAlias:
-        return astDOTTypeAlias(name, list(type_params), value, **keywordArguments)
-
-    @staticmethod
-    def TypeIgnore(lineno: int, tag: ast_Identifier, **keywordArguments: int) -> ast.TypeIgnore:
-        return ast.TypeIgnore(lineno, tag, **keywordArguments)
-
-    @staticmethod
-    def TypeVar(name: ast_Identifier, bound: ast.expr | None, default_value: ast.expr | None, **keywordArguments: int) -> astDOTTypeVar:
-        return astDOTTypeVar(name, bound, default_value, **keywordArguments)
-
-    @staticmethod
-    def TypeVarTuple(name: ast_Identifier, default_value: ast.expr | None, **keywordArguments: int) -> astDOTTypeVarTuple:
-        return astDOTTypeVarTuple(name, default_value, **keywordArguments)
-
-    @staticmethod
-    def UnaryOp(op: ast.unaryop, operand: ast.expr, **keywordArguments: int) -> ast.UnaryOp:
-        return ast.UnaryOp(op, operand, **keywordArguments)
-
-    @staticmethod
-    def While(test: ast.expr, body: Sequence[ast.stmt], orElse: Sequence[ast.stmt]=[], **keywordArguments: int) -> ast.While:
-        return ast.While(test, list(body), list(orElse), **keywordArguments)
-
-    @staticmethod
-    def With(items: list[ast.withitem], body: Sequence[ast.stmt], **keywordArguments: intORstr) -> ast.With:
-        return ast.With(items, list(body), **keywordArguments)
-
-    @staticmethod
-    def withitem(context_expr: ast.expr, optional_vars: ast.expr | None, **keywordArguments: int) -> ast.withitem:
-        return ast.withitem(context_expr, optional_vars, **keywordArguments)
-
-    @staticmethod
-    def Yield(value: ast.expr | None, **keywordArguments: int) -> ast.Yield:
-        return ast.Yield(value, **keywordArguments)
-
-    @staticmethod
-    def YieldFrom(value: ast.expr, **keywordArguments: int) -> ast.YieldFrom:
-        return ast.YieldFrom(value, **keywordArguments)

mapFolding/someAssemblyRequired/_toolThen.py

@@ -1,63 +0,0 @@
-"""
-AST Node Transformation Actions for Python Code Manipulation
-
-This module provides the Then class with static methods for generating callable action functions that specify what to do
-with AST nodes that match predicates. These action functions are used primarily with NodeChanger and NodeTourist to
-transform or extract information from AST nodes.
-
-The module also contains the grab class that provides functions for modifying specific attributes of AST nodes while
-preserving their structure, enabling fine-grained control when transforming AST structures.
-
-Together, these classes provide a complete system for manipulating AST nodes once they have been identified using
-predicate functions from ifThis.
-"""
-
-from collections.abc import Callable, Sequence
-from mapFolding.someAssemblyRequired import ast_Identifier, NodeORattribute
-from typing import Any
-import ast
-
-class Then:
-	"""
-	Provide action functions that specify what to do with AST nodes that match predicates.
-
-	The Then class contains static methods that generate action functions used with NodeChanger and NodeTourist to
-	transform or extract information from AST nodes that match specific predicates. These actions include node
-	replacement, insertion, extraction, and collection operations.
-
-	When paired with predicates from the ifThis class, Then methods complete the pattern-matching-and-action workflow
-	for AST manipulation.
-	"""
-	@staticmethod
-	def appendTo(listOfAny: list[Any]) -> Callable[[ast.AST | ast_Identifier], ast.AST | ast_Identifier]:
-		def workhorse(node: ast.AST | ast_Identifier) -> ast.AST | ast_Identifier:
-			listOfAny.append(node)
-			return node
-		return workhorse
-
-	@staticmethod
-	def extractIt(node: NodeORattribute) -> NodeORattribute:
-		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(_removeMe: ast.AST) -> None:
-		return None
-
-	@staticmethod
-	def replaceWith(astAST: NodeORattribute) -> Callable[[NodeORattribute], NodeORattribute]:
-		return lambda _replaceMe: astAST
-
-	@staticmethod
-	def updateKeyValueIn(key: Callable[..., Any], value: Callable[..., Any], dictionary: dict[Any, Any]) -> Callable[[ast.AST], dict[Any, Any]]:
-		def workhorse(node: ast.AST) -> dict[Any, Any]:
-			dictionary.setdefault(key(node), value(node))
-			return dictionary
-		return workhorse

mapFolding/someAssemblyRequired/_toolboxAST.py

@@ -1,57 +0,0 @@
-from mapFolding.someAssemblyRequired import ast_Identifier, IfThis, IngredientsFunction, LedgerOfImports, NodeTourist, Then
-from mapFolding.theSSOT import raiseIfNoneGitHubIssueNumber3
-import ast
-
-def astModuleToIngredientsFunction(astModule: ast.AST, identifierFunctionDef: ast_Identifier) -> IngredientsFunction:
-	"""
-	Extract a function definition from an AST module and create an `IngredientsFunction`.
-
-	This function finds a function definition with the specified identifier in the given AST module, extracts it, and
-	stores all module imports in the `LedgerOfImports`.
-
-	Parameters:
-		astModule: The AST module containing the function definition.
-		identifierFunctionDef: The name of the function to extract.
-
-	Returns:
-		ingredientsFunction: `IngredientsFunction` object containing the `ast.FunctionDef` and _all_ imports from the
-		source module.
-
-	Raises:
-		raiseIfNoneGitHubIssueNumber3: If the function definition is not found.
-	"""
-	astFunctionDef = extractFunctionDef(astModule, identifierFunctionDef)
-	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
-	return IngredientsFunction(astFunctionDef, LedgerOfImports(astModule))
-
-def extractClassDef(module: ast.AST, identifier: ast_Identifier) -> ast.ClassDef | None:
-	"""
-	Extract a class definition with a specific name from an AST module.
-
-	This function searches through an AST module for a class definition that matches the provided identifier and returns
-	it if found.
-
-	Parameters:
-		module: The AST module to search within.
-		identifier: The name of the class to find.
-
-	Returns:
-		astClassDef|None: The matching class definition AST node, or `None` if not found.
-	"""
-	return NodeTourist(IfThis.isClassDef_Identifier(identifier), Then.extractIt).captureLastMatch(module)
-
-def extractFunctionDef(module: ast.AST, identifier: ast_Identifier) -> ast.FunctionDef | None:
-	"""
-	Extract a function definition with a specific name from an AST module.
-
-	This function searches through an AST module for a function definition that matches the provided identifier and
-	returns it if found.
-
-	Parameters:
-		module: The AST module to search within.
-		identifier: The name of the function to find.
-
-	Returns:
-		astFunctionDef|None: The matching function definition AST node, or `None` if not found.
-	"""
-	return NodeTourist(IfThis.isFunctionDef_Identifier(identifier), Then.extractIt).captureLastMatch(module)

mapFolding/someAssemblyRequired/_toolboxPython.py

@@ -1,188 +0,0 @@
-"""
-Core AST Traversal and Transformation Utilities for Python Code Manipulation
-
-This module provides the foundation for traversing and modifying Python Abstract Syntax Trees (ASTs). It contains two
-primary classes:
-
-1. NodeTourist: Implements the visitor pattern to traverse an AST and extract information from nodes that match specific
-	predicates without modifying the AST.
-
-2. NodeChanger: Extends ast.NodeTransformer to selectively transform AST nodes that match specific predicates, enabling
-	targeted code modifications.
-
-The module also provides utilities for importing modules, loading callables from files, and parsing Python code into AST
-structures, creating a complete workflow for code analysis and transformation.
-"""
-
-from collections.abc import Callable
-from inspect import getsource as inspect_getsource
-from mapFolding.someAssemblyRequired import ast_Identifier, str_nameDOTname
-from os import PathLike
-from pathlib import Path, PurePath
-from types import ModuleType
-from typing import Any, Literal
-import ast
-import importlib
-import importlib.util
-
-# TODO Identify the logic that narrows the type and can help the user during static type checking.
-
-class NodeTourist(ast.NodeVisitor):
-	"""
-	Visit and extract information from AST nodes that match a predicate.
-
-	NodeTourist implements the visitor pattern to traverse an AST, applying a predicate function to each node and
-	capturing nodes or their attributes when they match. Unlike NodeChanger, it doesn't modify the AST but collects
-	information during traversal.
-
-	This class is particularly useful for analyzing AST structures, extracting specific nodes or node properties, and
-	gathering information about code patterns.
-	"""
-	def __init__(self, findThis: Callable[..., Any], doThat: Callable[..., Any]) -> None:
-		self.findThis = findThis
-		self.doThat = doThat
-		self.nodeCaptured: Any | None = None
-
-	def visit(self, node: ast.AST) -> None:
-		if self.findThis(node):
-			nodeActionReturn = self.doThat(node)
-			if nodeActionReturn is not None:
-				self.nodeCaptured = nodeActionReturn
-		self.generic_visit(node)
-
-	def captureLastMatch(self, node: ast.AST) -> Any | None:
-		self.nodeCaptured = None
-		self.visit(node)
-		return self.nodeCaptured
-
-class NodeChanger(ast.NodeTransformer):
-	"""
-	Transform AST nodes that match a predicate by applying a transformation function.
-
-	NodeChanger is an AST node transformer that applies a targeted transformation to nodes matching a specific
-	predicate. It traverses the AST and only modifies nodes that satisfy the predicate condition, leaving other nodes
-	unchanged.
-
-	This class extends ast.NodeTransformer and implements the visitor pattern to systematically process and transform an
-	AST tree.
-	"""
-	def __init__(self, findThis: Callable[..., Any], doThat: Callable[..., Any]) -> None:
-		self.findThis = findThis
-		self.doThat = doThat
-
-	def visit(self, node: ast.AST) -> ast.AST:
-		if self.findThis(node):
-			return self.doThat(node)
-		return super().visit(node)
-
-def importLogicalPath2Callable(logicalPathModule: str_nameDOTname, identifier: ast_Identifier, packageIdentifierIfRelative: ast_Identifier | None = None) -> Callable[..., Any]:
-	"""
-	Import a callable object (function or class) from a module based on its logical path.
-
-	This function imports a module using `importlib.import_module()` and then retrieves a specific attribute (function,
-	class, or other object) from that module.
-
-	Parameters
-	----------
-	logicalPathModule
-		The logical path to the module, using dot notation (e.g., 'package.subpackage.module').
-	identifier
-		The name of the callable object to retrieve from the module.
-	packageIdentifierIfRelative : None
-		The package name to use as the anchor point if `logicalPathModule` is a relative import. If None, absolute
-		import is assumed.
-
-	Returns
-	-------
-	Callable[..., Any]
-		The callable object (function, class, etc.) retrieved from the module.
-	"""
-	moduleImported: ModuleType = importlib.import_module(logicalPathModule, packageIdentifierIfRelative)
-	return getattr(moduleImported, identifier)
-
-def importPathFilename2Callable(pathFilename: PathLike[Any] | PurePath, identifier: ast_Identifier, moduleIdentifier: ast_Identifier | None = None) -> Callable[..., Any]:
-	"""
-	Load a callable (function, class, etc.) from a Python file.
-
-	This function imports a specified Python file as a module, extracts a callable object from it by name, and returns
-	that callable.
-
-	Parameters
-	----------
-	pathFilename
-		Path to the Python file to import.
-	identifier
-		Name of the callable to extract from the imported module.
-	moduleIdentifier
-		Name to use for the imported module. If None, the filename stem is used.
-
-	Returns
-	-------
-	Callable[..., Any]
-		The callable object extracted from the imported module.
-
-	Raises
-	------
-	ImportError
-		If the file cannot be imported or the importlib specification is invalid.
-	AttributeError
-		If the identifier does not exist in the imported module.
-	"""
-	pathFilename = Path(pathFilename)
-
-	importlibSpecification = importlib.util.spec_from_file_location(moduleIdentifier or pathFilename.stem, pathFilename)
-	if importlibSpecification is None or importlibSpecification.loader is None: raise ImportError(f"I received\n\t`{pathFilename = }`,\n\t`{identifier = }`, and\n\t`{moduleIdentifier = }`.\n\tAfter loading, \n\t`importlibSpecification` {'is `None`' if importlibSpecification is None else 'has a value'} and\n\t`importlibSpecification.loader` is unknown.")
-
-	moduleImported_jk_hahaha: ModuleType = importlib.util.module_from_spec(importlibSpecification)
-	importlibSpecification.loader.exec_module(moduleImported_jk_hahaha)
-	return getattr(moduleImported_jk_hahaha, identifier)
-
-def parseLogicalPath2astModule(logicalPathModule: str_nameDOTname, packageIdentifierIfRelative: ast_Identifier | None = None, mode: Literal['exec'] = 'exec') -> ast.Module:
-	"""
-	Parse a logical Python module path into an `ast.Module`.
-
-	This function imports a module using its logical path (e.g., 'package.subpackage.module') and converts its source
-	code into an Abstract Syntax Tree (AST) Module object.
-
-	Parameters
-	----------
-	logicalPathModule
-		The logical path to the module using dot notation (e.g., 'package.module').
-	packageIdentifierIfRelative : None
-		The package identifier to use if the module path is relative, defaults to None.
-	mode : Literal['exec']
-		The mode parameter for `ast.parse`. Default is `Literal['exec']`. Options are `Literal['exec']`, `"exec"` (which
-		is _not_ the same as `Literal['exec']`), `Literal['eval']`, `Literal['func_type']`, `Literal['single']`. See
-		`ast.parse` documentation for some details and much confusion.
-
-	Returns
-	-------
-	astModule
-		An AST Module object representing the parsed source code of the imported module.
-	"""
-	moduleImported: ModuleType = importlib.import_module(logicalPathModule, packageIdentifierIfRelative)
-	sourcePython: str = inspect_getsource(moduleImported)
-	return ast.parse(sourcePython, mode)
-
-def parsePathFilename2astModule(pathFilename: PathLike[Any] | PurePath, mode: Literal['exec'] = 'exec') -> ast.Module:
-	"""
-	Parse a file from a given path into an `ast.Module`.
-
-	This function reads the content of a file specified by `pathFilename` and parses it into an Abstract Syntax Tree
-	(AST) Module using Python's ast module.
-
-	Parameters
-	----------
-	pathFilename
-		The path to the file to be parsed. Can be a string path, PathLike object, or PurePath object.
-	mode : Literal['exec']
-		The mode parameter for `ast.parse`. Default is `Literal['exec']`. Options are `Literal['exec']`, `"exec"` (which
-		is _not_ the same as `Literal['exec']`), `Literal['eval']`, `Literal['func_type']`, `Literal['single']`. See
-		`ast.parse` documentation for some details and much confusion.
-
-	Returns
-	-------
-	astModule
-		The parsed abstract syntax tree module.
-	"""
-	return ast.parse(Path(pathFilename).read_text(), mode)