astToolkit 0.1.0__tar.gz → 0.1.2__tar.gz

{asttoolkit-0.1.0 → asttoolkit-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astToolkit
-Version: 0.1.0
+Version: 0.1.2
 Summary: AST manipulation and transformation tools for Python code
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0

{asttoolkit-0.1.0 → asttoolkit-0.1.2}/astToolkit/__init__.py

@@ -14,7 +14,6 @@ from astToolkit.theSSOT import FREAKOUT as FREAKOUT, The as The
 from astToolkit._types 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 个,

{asttoolkit-0.1.0 → asttoolkit-0.1.2}/astToolkit/_astTypes.py

@@ -114,4 +114,4 @@ 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
+hasDOTvararg: typing_TypeAlias = ast.arguments

{asttoolkit-0.1.0 → asttoolkit-0.1.2}/astToolkit/_toolBe.py

@@ -521,4 +521,4 @@ class Be:
 
     @staticmethod
     def YieldFrom(node: ast.AST) -> TypeGuard[ast.YieldFrom]:
-        return isinstance(node, ast.YieldFrom)
+        return isinstance(node, ast.YieldFrom)

{asttoolkit-0.1.0 → asttoolkit-0.1.2}/astToolkit/_toolDOT.py

@@ -1,7 +1,7 @@
 # ruff: noqa: F403, F405
 """This file is generated automatically, so changes to this file will be lost."""
-from collections.abc import Sequence
 from astToolkit._astTypes import *
+from collections.abc import Sequence
 from astToolkit import ast_Identifier, ast_expr_Slice, astDOTtype_param
 from typing import Any, Literal, overload
 import ast
@@ -489,4 +489,4 @@ class DOT:
 
     @staticmethod
     def vararg(node: hasDOTvararg) -> ast.arg | None:
-        return node.vararg
+        return node.vararg

{asttoolkit-0.1.0 → asttoolkit-0.1.2}/astToolkit/_toolGrab.py

@@ -1,9 +1,9 @@
 # ruff: noqa: F403, F405
 """This file is generated automatically, so changes to this file will be lost."""
-from collections.abc import Callable, Sequence
 from astToolkit._astTypes import *
 from astToolkit import astDOTParamSpec, astDOTTryStar, astDOTTypeAlias, astDOTTypeVar, astDOTTypeVarTuple, astDOTtype_param
-from astToolkit import ast_Identifier, ast_expr_Slice, NodeORattribute, ImaCallToName
+from astToolkit import ast_Identifier, ast_expr_Slice, NodeORattribute
+from collections.abc import Callable, Sequence
 from typing import Any, Literal
 import ast
 
@@ -23,7 +23,7 @@ class Grab:
     def annotationAttribute(action: Callable[[ast.expr | (ast.expr | None)], ast.expr | (ast.expr | None)]) -> Callable[[hasDOTannotation], hasDOTannotation]:
 
         def workhorse(node: hasDOTannotation) -> hasDOTannotation:
-            node.annotation = action(node.annotation)
+            node.annotation = action(node.annotation) # type: ignore[reportAttributeAccessIssue]
             return node
         return workhorse
 
@@ -31,7 +31,7 @@ class Grab:
     def argAttribute(action: Callable[[ast_Identifier | (ast_Identifier | None)], ast_Identifier | (ast_Identifier | None)]) -> Callable[[hasDOTarg], hasDOTarg]:
 
         def workhorse(node: hasDOTarg) -> hasDOTarg:
-            node.arg = action(node.arg)
+            node.arg = action(node.arg) # type: ignore[reportAttributeAccessIssue]
             return node
         return workhorse
 
@@ -39,7 +39,7 @@ class Grab:
     def argsAttribute(action: Callable[[ast.arguments | Sequence[ast.expr] | list[ast.arg]], ast.arguments | Sequence[ast.expr] | list[ast.arg]]) -> Callable[[hasDOTargs], hasDOTargs]:
 
         def workhorse(node: hasDOTargs) -> hasDOTargs:
-            node.args = action(node.args)
+            node.args = action(node.args) # type: ignore[reportAttributeAccessIssue]
             return node
         return workhorse
 
@@ -47,7 +47,7 @@ class Grab:
     def argtypesAttribute(action: Callable[[Sequence[ast.expr]], Sequence[ast.expr]]) -> Callable[[hasDOTargtypes], hasDOTargtypes]:
 
         def workhorse(node: hasDOTargtypes) -> hasDOTargtypes:
-            node.argtypes = action(node.argtypes)
+            node.argtypes = list(action(node.argtypes))
             return node
         return workhorse
 
@@ -71,7 +71,7 @@ class Grab:
     def basesAttribute(action: Callable[[Sequence[ast.expr]], Sequence[ast.expr]]) -> Callable[[hasDOTbases], hasDOTbases]:
 
         def workhorse(node: hasDOTbases) -> hasDOTbases:
-            node.bases = action(node.bases)
+            node.bases = list(action(node.bases))
             return node
         return workhorse
 
@@ -79,7 +79,7 @@ class Grab:
     def bodyAttribute(action: Callable[[Sequence[ast.stmt] | ast.expr], Sequence[ast.stmt] | ast.expr]) -> Callable[[hasDOTbody], hasDOTbody]:
 
         def workhorse(node: hasDOTbody) -> hasDOTbody:
-            node.body = action(node.body)
+            node.body = action(node.body) # type: ignore[reportAttributeAccessIssue]
             return node
         return workhorse
 
@@ -119,7 +119,7 @@ class Grab:
     def comparatorsAttribute(action: Callable[[Sequence[ast.expr]], Sequence[ast.expr]]) -> Callable[[hasDOTcomparators], hasDOTcomparators]:
 
         def workhorse(node: hasDOTcomparators) -> hasDOTcomparators:
-            node.comparators = action(node.comparators)
+            node.comparators = list(action(node.comparators))
             return node
         return workhorse
 
@@ -151,7 +151,7 @@ class Grab:
     def decorator_listAttribute(action: Callable[[Sequence[ast.expr]], Sequence[ast.expr]]) -> Callable[[hasDOTdecorator_list], hasDOTdecorator_list]:
 
         def workhorse(node: hasDOTdecorator_list) -> hasDOTdecorator_list:
-            node.decorator_list = action(node.decorator_list)
+            node.decorator_list = list(action(node.decorator_list))
             return node
         return workhorse
 
@@ -167,7 +167,7 @@ class Grab:
     def defaultsAttribute(action: Callable[[Sequence[ast.expr]], Sequence[ast.expr]]) -> Callable[[hasDOTdefaults], hasDOTdefaults]:
 
         def workhorse(node: hasDOTdefaults) -> hasDOTdefaults:
-            node.defaults = action(node.defaults)
+            node.defaults = list(action(node.defaults))
             return node
         return workhorse
 
@@ -183,7 +183,7 @@ class Grab:
     def eltsAttribute(action: Callable[[Sequence[ast.expr]], Sequence[ast.expr]]) -> Callable[[hasDOTelts], hasDOTelts]:
 
         def workhorse(node: hasDOTelts) -> hasDOTelts:
-            node.elts = action(node.elts)
+            node.elts = list(action(node.elts))
             return node
         return workhorse
 
@@ -199,7 +199,7 @@ class Grab:
     def finalbodyAttribute(action: Callable[[Sequence[ast.stmt]], Sequence[ast.stmt]]) -> Callable[[hasDOTfinalbody], hasDOTfinalbody]:
 
         def workhorse(node: hasDOTfinalbody) -> hasDOTfinalbody:
-            node.finalbody = action(node.finalbody)
+            node.finalbody = list(action(node.finalbody))
             return node
         return workhorse
 
@@ -255,7 +255,7 @@ class Grab:
     def ifsAttribute(action: Callable[[Sequence[ast.expr]], Sequence[ast.expr]]) -> Callable[[hasDOTifs], hasDOTifs]:
 
         def workhorse(node: hasDOTifs) -> hasDOTifs:
-            node.ifs = action(node.ifs)
+            node.ifs = list(action(node.ifs))
             return node
         return workhorse
 
@@ -295,7 +295,7 @@ class Grab:
     def keysAttribute(action: Callable[[Sequence[ast.expr | None] | Sequence[ast.expr]], Sequence[ast.expr | None] | Sequence[ast.expr]]) -> Callable[[hasDOTkeys], hasDOTkeys]:
 
         def workhorse(node: hasDOTkeys) -> hasDOTkeys:
-            node.keys = action(node.keys)
+            node.keys = list(action(node.keys)) # type: ignore[reportAttributeAccessIssue]
             return node
         return workhorse
 
@@ -319,7 +319,7 @@ class Grab:
     def kw_defaultsAttribute(action: Callable[[Sequence[ast.expr | None]], Sequence[ast.expr | None]]) -> Callable[[hasDOTkw_defaults], hasDOTkw_defaults]:
 
         def workhorse(node: hasDOTkw_defaults) -> hasDOTkw_defaults:
-            node.kw_defaults = action(node.kw_defaults)
+            node.kw_defaults = list(action(node.kw_defaults))
             return node
         return workhorse
 
@@ -343,7 +343,7 @@ class Grab:
     def kwd_patternsAttribute(action: Callable[[Sequence[ast.pattern]], Sequence[ast.pattern]]) -> Callable[[hasDOTkwd_patterns], hasDOTkwd_patterns]:
 
         def workhorse(node: hasDOTkwd_patterns) -> hasDOTkwd_patterns:
-            node.kwd_patterns = action(node.kwd_patterns)
+            node.kwd_patterns = list(action(node.kwd_patterns))
             return node
         return workhorse
 
@@ -407,7 +407,7 @@ class Grab:
     def nameAttribute(action: Callable[[ast_Identifier | (ast_Identifier | None) | ast_Identifier | ast.Name], ast_Identifier | (ast_Identifier | None) | ast_Identifier | ast.Name]) -> Callable[[hasDOTname], hasDOTname]:
 
         def workhorse(node: hasDOTname) -> hasDOTname:
-            node.name = action(node.name)
+            node.name = action(node.name) # type: ignore[reportAttributeAccessIssue]
             return node
         return workhorse
 
@@ -415,7 +415,7 @@ class Grab:
     def namesAttribute(action: Callable[[list[ast.alias] | list[ast_Identifier]], list[ast.alias] | list[ast_Identifier]]) -> Callable[[hasDOTnames], hasDOTnames]:
 
         def workhorse(node: hasDOTnames) -> hasDOTnames:
-            node.names = action(node.names)
+            node.names = action(node.names) # type: ignore[reportAttributeAccessIssue]
             return node
         return workhorse
 
@@ -423,7 +423,7 @@ class Grab:
     def opAttribute(action: Callable[[ast.operator | ast.boolop | ast.unaryop], ast.operator | ast.boolop | ast.unaryop]) -> Callable[[hasDOTop], hasDOTop]:
 
         def workhorse(node: hasDOTop) -> hasDOTop:
-            node.op = action(node.op)
+            node.op = action(node.op) # type: ignore[reportAttributeAccessIssue]
             return node
         return workhorse
 
@@ -439,7 +439,7 @@ class Grab:
     def opsAttribute(action: Callable[[Sequence[ast.cmpop]], Sequence[ast.cmpop]]) -> Callable[[hasDOTops], hasDOTops]:
 
         def workhorse(node: hasDOTops) -> hasDOTops:
-            node.ops = action(node.ops)
+            node.ops = list(action(node.ops))
             return node
         return workhorse
 
@@ -455,7 +455,7 @@ class Grab:
     def orelseAttribute(action: Callable[[Sequence[ast.stmt] | ast.expr], Sequence[ast.stmt] | ast.expr]) -> Callable[[hasDOTorelse], hasDOTorelse]:
 
         def workhorse(node: hasDOTorelse) -> hasDOTorelse:
-            node.orelse = action(node.orelse)
+            node.orelse = action(node.orelse) # type: ignore[reportAttributeAccessIssue]
             return node
         return workhorse
 
@@ -463,7 +463,7 @@ class Grab:
     def patternAttribute(action: Callable[[ast.pattern | (ast.pattern | None)], ast.pattern | (ast.pattern | None)]) -> Callable[[hasDOTpattern], hasDOTpattern]:
 
         def workhorse(node: hasDOTpattern) -> hasDOTpattern:
-            node.pattern = action(node.pattern)
+            node.pattern = action(node.pattern) # type: ignore[reportAttributeAccessIssue]
             return node
         return workhorse
 
@@ -471,7 +471,7 @@ class Grab:
     def patternsAttribute(action: Callable[[Sequence[ast.pattern]], Sequence[ast.pattern]]) -> Callable[[hasDOTpatterns], hasDOTpatterns]:
 
         def workhorse(node: hasDOTpatterns) -> hasDOTpatterns:
-            node.patterns = action(node.patterns)
+            node.patterns = list(action(node.patterns))
             return node
         return workhorse
 
@@ -495,7 +495,7 @@ class Grab:
     def returnsAttribute(action: Callable[[ast.expr | (ast.expr | None)], ast.expr | (ast.expr | None)]) -> Callable[[hasDOTreturns], hasDOTreturns]:
 
         def workhorse(node: hasDOTreturns) -> hasDOTreturns:
-            node.returns = action(node.returns)
+            node.returns = action(node.returns) # type: ignore[reportAttributeAccessIssue]
             return node
         return workhorse
 
@@ -551,7 +551,7 @@ class Grab:
     def targetAttribute(action: Callable[[ast.Name | ast.Attribute | ast.Subscript | ast.expr | ast.Name], ast.Name | ast.Attribute | ast.Subscript | ast.expr | ast.Name]) -> Callable[[hasDOTtarget], hasDOTtarget]:
 
         def workhorse(node: hasDOTtarget) -> hasDOTtarget:
-            node.target = action(node.target)
+            node.target = action(node.target) # type: ignore[reportAttributeAccessIssue]
             return node
         return workhorse
 
@@ -559,7 +559,7 @@ class Grab:
     def targetsAttribute(action: Callable[[Sequence[ast.expr]], Sequence[ast.expr]]) -> Callable[[hasDOTtargets], hasDOTtargets]:
 
         def workhorse(node: hasDOTtargets) -> hasDOTtargets:
-            node.targets = action(node.targets)
+            node.targets = list(action(node.targets))
             return node
         return workhorse
 
@@ -599,7 +599,7 @@ class Grab:
     def type_paramsAttribute(action: Callable[[Sequence[astDOTtype_param]], Sequence[astDOTtype_param]]) -> Callable[[hasDOTtype_params], hasDOTtype_params]:
 
         def workhorse(node: hasDOTtype_params) -> hasDOTtype_params:
-            node.type_params = action(node.type_params)
+            node.type_params = list(action(node.type_params))
             return node
         return workhorse
 
@@ -615,7 +615,7 @@ class Grab:
     def valueAttribute(action: Callable[[ast.expr | None | ast.expr | Any | (Literal[True, False] | None)], ast.expr | None | ast.expr | Any | (Literal[True, False] | None)]) -> Callable[[hasDOTvalue], hasDOTvalue]:
 
         def workhorse(node: hasDOTvalue) -> hasDOTvalue:
-            node.value = action(node.value)
+            node.value = action(node.value) # type: ignore[reportAttributeAccessIssue]
             return node
         return workhorse
 
@@ -623,7 +623,7 @@ class Grab:
     def valuesAttribute(action: Callable[[Sequence[ast.expr]], Sequence[ast.expr]]) -> Callable[[hasDOTvalues], hasDOTvalues]:
 
         def workhorse(node: hasDOTvalues) -> hasDOTvalues:
-            node.values = action(node.values)
+            node.values = list(action(node.values))
             return node
         return workhorse
 
@@ -642,12 +642,4 @@ class Grab:
             for action in listOfActions:
                 node = action(node)
             return node
-        return workhorse
-
-    @staticmethod
-    def funcDOTidAttribute(action: Callable[[ast_Identifier], Any]) -> Callable[[ImaCallToName], ImaCallToName]:
-
-        def workhorse(node: ImaCallToName) -> ImaCallToName:
-            node.func = Grab.idAttribute(action)(node.func)
-            return node
-        return workhorse
+        return workhorse

{asttoolkit-0.1.0 → asttoolkit-0.1.2}/astToolkit/_toolIfThis.py

@@ -20,8 +20,8 @@ they implement a declarative approach to AST manipulation that separates node id
 """
 
 from collections.abc import Callable
-from astToolkit import ast_Identifier, Be, DOT, ImaCallToName
-from typing import Any, TypeGuard
+from astToolkit import ast_Identifier, Be, DOT
+from typing import Any, TypeGuard, cast
 import ast
 
 class IfThis:
@@ -72,20 +72,16 @@ class IfThis:
 		def workhorse(node: ast.AST) -> TypeGuard[ast.Attribute]:
 			return Be.Attribute(node) and IfThis.isNestedName_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.isIdentifier(identifier)(DOT.attr(node))
 
-	@staticmethod
-	def isAttributeNamespace_IdentifierLessThanOrEqual(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 isAugAssignAndTargetIs(targetPredicate: Callable[[ast.expr], TypeGuard[ast.expr] | bool]) -> Callable[[ast.AST], TypeGuard[ast.AugAssign] | bool]:
 		def workhorse(node: ast.AST) -> TypeGuard[ast.AugAssign] | bool:
@@ -93,9 +89,9 @@ class IfThis:
 		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.isIdentifier(identifier)(DOT.id(DOT.func(node)))
+	def isCall_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Call] | bool]:
+		def workhorse(node: ast.AST) -> TypeGuard[ast.Call] | bool:
+			return IfThis.isCallToName(node) and IfThis.isIdentifier(identifier)(DOT.id(cast(ast.Name, DOT.func(node))))
 		return workhorse
 
 	@staticmethod
@@ -103,8 +99,9 @@ class IfThis:
 		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]:
+	def isCallToName(node: ast.AST) -> TypeGuard[ast.Call]:
 		return Be.Call(node) and Be.Name(DOT.func(node))
 
 	@staticmethod
@@ -131,6 +128,7 @@ class IfThis:
 	@staticmethod
 	def isName_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Name] | bool]:
 		return lambda node: Be.Name(node) and IfThis.isIdentifier(identifier)(DOT.id(node))
+
 	@staticmethod
 	def isNestedName_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Attribute | ast.Starred | ast.Subscript] | bool]:
 		""" `node` is `ast.Name`

{asttoolkit-0.1.0 → asttoolkit-0.1.2}/astToolkit/_toolMake.py

@@ -1,7 +1,7 @@
 """This file is generated automatically, so changes to this file will be lost."""
-from collections.abc import Sequence
 from astToolkit import astDOTParamSpec, astDOTTryStar, astDOTTypeAlias, astDOTTypeVar, astDOTTypeVarTuple, astDOTtype_param
 from astToolkit import ast_Identifier, ast_expr_Slice, intORstr, intORstrORtype_params, intORtype_params, str_nameDOTname
+from collections.abc import Sequence
 from typing import Any, Literal
 import ast
 
@@ -336,4 +336,4 @@ class Make:
 
     @staticmethod
     def YieldFrom(value: ast.expr, **keywordArguments: int) -> ast.YieldFrom:
-        return ast.YieldFrom(value, **keywordArguments)
+        return ast.YieldFrom(value, **keywordArguments)

{asttoolkit-0.1.0 → asttoolkit-0.1.2}/astToolkit/_types.py

@@ -6,8 +6,9 @@ import ast
 
 # 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]
+# To cover all cases, quantity of necessary classes = sum of (for each class: for each attribute: attribute * number of valid types). If an attribute has type ast.expr, for example, then there are 27 valid types just for that attribute. There would be thousands of subclasses like ImaCallToName.
+# class ImaCallToName(ast.Call):
+# 	func: ast.Name 	# pyright: ignore[reportIncompatibleVariableOverride]
 
 # Type hints through TypeAlias or type "hints" through the identifier name.
 ast_expr_Slice: typing_TypeAlias = ast.expr

{asttoolkit-0.1.0 → asttoolkit-0.1.2}/astToolkit/transformationTools.py

@@ -1,5 +1,5 @@
 from autoflake import fix_code as autoflake_fix_code
-from collections.abc import Mapping
+from collections.abc import Callable, Mapping
 from copy import deepcopy
 from astToolkit import (
 	ast_Identifier,
@@ -19,7 +19,7 @@ from astToolkit import FREAKOUT
 from Z0Z_tools import writeStringToHere
 from os import PathLike
 from pathlib import PurePath
-from typing import Any
+from typing import Any, cast
 import ast
 
 def makeDictionaryFunctionDef(module: ast.Module) -> dict[ast_Identifier, ast.FunctionDef]:
@@ -65,7 +65,7 @@ def inlineFunctionDef(identifierToInline: ast_Identifier, module: ast.Module) ->
 		raise ValueError(f"FunctionDefToInline not found in dictionaryIdentifier2FunctionDef: {identifierToInline = }") from ERRORmessage
 
 	listIdentifiersCalledFunctions: list[ast_Identifier] = []
-	findIdentifiersToInline = NodeTourist(findThis = IfThis.isCallToName, doThat = Grab.funcDOTidAttribute(Then.appendTo(listIdentifiersCalledFunctions)))
+	findIdentifiersToInline = NodeTourist(findThis = IfThis.isCallToName, doThat = Grab.funcAttribute(cast(Callable[[ast.expr], ast.expr], Grab.idAttribute(cast(Callable[[ast_Identifier], ast_Identifier], Then.appendTo(listIdentifiersCalledFunctions))))))
 	findIdentifiersToInline.visit(FunctionDefToInline)
 
 	dictionary4Inlining: dict[ast_Identifier, ast.FunctionDef] = {}
@@ -193,12 +193,12 @@ def removeUnusedParameters(ingredientsFunction: IngredientsFunction) -> Ingredie
 
 	return ingredientsFunction
 
-def Z0Z_lameFindReplace(astTree: 个, mappingFindReplaceNodes: Mapping[ast.AST, ast.AST]) -> 个:
+def unparseFindReplace(astTree: 个, mappingFindReplaceNodes: Mapping[ast.AST, ast.AST]) -> 个:
 	"""
 	Recursively replace AST nodes based on a mapping of find-replace pairs.
 
 	This function applies brute-force node replacement throughout an AST tree
-	by comparing textual representations of nodes. While not the most efficient
+	by comparing textual representations of nodes. While not the most semantic
 	approach, it provides a reliable way to replace complex nested structures
 	when more precise targeting methods are difficult to implement.
 
@@ -211,7 +211,7 @@ def Z0Z_lameFindReplace(astTree: 个, mappingFindReplaceNodes: Mapping[ast.AST,
 		mappingFindReplaceNodes: A mapping from source nodes to replacement nodes.
 
 	Returns:
-		The modified AST structure with all matching nodes replaced.
+		newTree: The modified AST structure with all matching nodes replaced.
 	"""
 	keepGoing = True
 	newTree = deepcopy(astTree)

{asttoolkit-0.1.0 → asttoolkit-0.1.2}/astToolkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astToolkit
-Version: 0.1.0
+Version: 0.1.2
 Summary: AST manipulation and transformation tools for Python code
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0

{asttoolkit-0.1.0 → asttoolkit-0.1.2}/pyproject.toml

@@ -32,7 +32,7 @@ optional-dependencies = { testing = [
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"
 urls = { Donate = "https://www.patreon.com/integrated", Homepage = "https://github.com/hunterhogan/astToolkit", Issues = "https://github.com/hunterhogan/astToolkit/issues", Repository = "https://github.com/hunterhogan/astToolkit.git" }
-version = "0.1.0"
+version = "0.1.2"
 
 [tool.coverage]
 report = { exclude_lines = [

{asttoolkit-0.1.0 → asttoolkit-0.1.2}/toolFactory/Z0Z_hardcoded.py

@@ -2,9 +2,12 @@ from pathlib import Path
 from typing import TypeAlias as typing_TypeAlias
 
 ast_Identifier: typing_TypeAlias = str
+fileExtension: str = '.py'
 packageName: ast_Identifier = 'astToolkit'
-pathPackage = Path('/apps') / packageName
-pathTypeshed = pathPackage / 'typeshed/stdlib'
+pathRoot = Path('/apps') / packageName
+pathPackage = pathRoot / packageName
+pathTypeshed = pathRoot / 'typeshed/stdlib'
+str_nameDOTname: typing_TypeAlias = str
 sys_version_infoMinimum: tuple[int, int] = (3, 10)
 sys_version_infoTarget: tuple[int, int] = (3, 13)
 

{asttoolkit-0.1.0 → asttoolkit-0.1.2}/toolFactory/__init__.py

@@ -1,9 +1,11 @@
 from toolFactory.Z0Z_hardcoded import (
 	ast_Identifier as ast_Identifier,
+	fileExtension as fileExtension,
 	FREAKOUT as FREAKOUT,
 	packageName as packageName,
 	pathPackage as pathPackage,
 	pathTypeshed as pathTypeshed,
+	str_nameDOTname as str_nameDOTname,
 	sys_version_infoMinimum as sys_version_infoMinimum,
 	sys_version_infoTarget as sys_version_infoTarget,
 	)

{asttoolkit-0.1.0 → asttoolkit-0.1.2}/toolFactory/astFactory.py

@@ -1,8 +1,7 @@
-from astToolkit import str_nameDOTname, The
 from pathlib import PurePosixPath
 from string import ascii_letters
-from toolFactory import ast_Identifier, list_astDOTnew, sys_version_infoTarget
-from toolFactory.astFactory_annex import handmadeMethodsGrab, handmadeTypeAlias_astTypes, MakeAttributeFunctionDef, MakeImportFunctionDef
+from toolFactory import ast_Identifier, fileExtension, list_astDOTnew, pathPackage, str_nameDOTname, sys_version_infoTarget
+from toolFactory.astFactory_annex import handmadeMethodsGrab, handmadeTypeAlias_astTypes, listPylanceErrors, MakeAttributeFunctionDef, MakeImportFunctionDef
 from toolFactory.docstrings import docstringWarning, ClassDefDocstringBe, ClassDefDocstringDOT, ClassDefDocstringGrab, ClassDefDocstringMake
 from typing import cast, TypedDict
 from Z0Z_tools import writeStringToHere
@@ -69,13 +68,25 @@ class Prepend_ast2astClasses(ast.NodeTransformer):
 			return self.dictionarySubstitutions[node.id]
 		return node
 
-def makeTools(astStubFile: ast.AST, logicalPathInfix: str_nameDOTname = None) -> None:
+def makeTools(astStubFile: ast.AST) -> None:
 	def writeModule(astModule: ast.Module, moduleIdentifier: ast_Identifier) -> None:
 		ast.fix_missing_locations(astModule)
 		pythonSource: str = ast.unparse(astModule)
 		if 'Grab' in moduleIdentifier or 'DOT' in moduleIdentifier:
 			pythonSource = "# ruff: noqa: F403, F405\n" + pythonSource
-		pathFilenameModule = PurePosixPath(The.pathPackage, moduleIdentifier + The.fileExtension)
+		if 'Grab' in moduleIdentifier:
+			listTypeIgnore: list[ast.TypeIgnore] = []
+			tag = '[reportAttributeAccessIssue]'
+			for attribute in listPylanceErrors:
+				for lineno, line in enumerate(pythonSource.splitlines()):
+					if 'node.'+attribute in line:
+						listTypeIgnore.append(ast.TypeIgnore(lineno+1, tag))
+						break
+			astModule = ast.parse(pythonSource)
+			astModule.type_ignores.extend(listTypeIgnore)
+			pythonSource: str = ast.unparse(astModule)
+			pythonSource = "# ruff: noqa: F403, F405\n" + pythonSource
+		pathFilenameModule = PurePosixPath(pathPackage, moduleIdentifier + fileExtension)
 		writeStringToHere(pythonSource, pathFilenameModule)
 
 	# Create each ClassDef and add directly to it instead of creating unnecessary intermediate structures.
@@ -373,6 +384,13 @@ def makeTools(astStubFile: ast.AST, logicalPathInfix: str_nameDOTname = None) ->
 					, returns=attributeAnnotationAsAST
 				))
 
+		# `astTypesModule`: When one attribute has multiple return types
+		if list_hasDOTNameTypeAliasAnnotations:
+			astAnnAssignValue = list_hasDOTNameTypeAliasAnnotations[0]
+			for index in range(1, len(list_hasDOTNameTypeAliasAnnotations)):
+				astAnnAssignValue = ast.BinOp(left=astAnnAssignValue, op=ast.BitOr(), right=list_hasDOTNameTypeAliasAnnotations[index])
+			astTypesModule.body.append(ast.AnnAssign(hasDOTName_Store, typing_TypeAliasName, astAnnAssignValue, 1))
+
 		ClassDefDOT.body.append(ast.FunctionDef(name=attributeIdentifier
 				, args=ast.arguments(posonlyargs=[], args=[ast.arg(arg='node', annotation=hasDOTName_Load)], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[])
 				, body=[ast.Return(value=ast.Attribute(value=ast.Name('node', ast.Load()), attr=attributeIdentifier, ctx=ast.Load()))]
@@ -380,6 +398,10 @@ def makeTools(astStubFile: ast.AST, logicalPathInfix: str_nameDOTname = None) ->
 				, returns=attributeAnnotationUnifiedAsAST
 			))
 
+		astAssignValue = ast.Call(ast.Name('action', ast.Load()), args=[ast.Attribute(ast.Name('node', ast.Load()), attr=attributeIdentifier, ctx=ast.Load())])
+		if (isinstance(attributeAnnotationUnifiedAsAST, ast.Subscript) and isinstance(attributeAnnotationUnifiedAsAST.value, ast.Name) and attributeAnnotationUnifiedAsAST.value.id == 'Sequence'
+		or isinstance(attributeAnnotationUnifiedAsAST, ast.BinOp) and isinstance(attributeAnnotationUnifiedAsAST.right, ast.Subscript) and isinstance(attributeAnnotationUnifiedAsAST.right.value, ast.Name) and attributeAnnotationUnifiedAsAST.right.value.id == 'Sequence'):
+			astAssignValue = ast.Call(ast.Name('list', ctx=ast.Load()), args=[ast.Call(ast.Name('action', ast.Load()), args=[ast.Attribute(ast.Name('node', ast.Load()), attr=attributeIdentifier, ctx=ast.Load())])])
 		ClassDefGrab.body.append(ast.FunctionDef(name=attributeIdentifier + 'Attribute'
 			, args=ast.arguments(posonlyargs=[]
 				, args=[ast.arg('action'
@@ -392,20 +414,13 @@ def makeTools(astStubFile: ast.AST, logicalPathInfix: str_nameDOTname = None) ->
 			, body=[ast.FunctionDef(name='workhorse',
 						args=ast.arguments(args=[ast.arg('node', hasDOTName_Load)]),
 					body=[ast.Assign(targets=[ast.Attribute(ast.Name('node', ast.Load()), attr=attributeIdentifier, ctx=ast.Store())],
-						value=ast.Call(ast.Name('action', ast.Load()), args=[ast.Attribute(ast.Name('node', ast.Load()), attr=attributeIdentifier, ctx=ast.Load())]))
+						value = astAssignValue)
 						, ast.Return(ast.Name('node', ast.Load()))],
 						returns=hasDOTName_Load),
 			ast.Return(ast.Name('workhorse', ctx=ast.Load()))]
 			, decorator_list=[staticmethodName], type_comment=None
 			, returns=ast.Subscript(ast.Name('Callable', ast.Load()), ast.Tuple([ast.List([hasDOTName_Load], ast.Load()), hasDOTName_Load], ast.Load()), ast.Load())))
 
-		# `astTypesModule`: When one attribute has multiple return types
-		if list_hasDOTNameTypeAliasAnnotations:
-			astAnnAssignValue = list_hasDOTNameTypeAliasAnnotations[0]
-			for index in range(1, len(list_hasDOTNameTypeAliasAnnotations)):
-				astAnnAssignValue = ast.BinOp(left=astAnnAssignValue, op=ast.BitOr(), right=list_hasDOTNameTypeAliasAnnotations[index])
-			astTypesModule.body.append(ast.AnnAssign(hasDOTName_Store, typing_TypeAliasName, astAnnAssignValue, 1))
-
 	writeModule(astTypesModule, '_astTypes')
 
 	ClassDefBe.body.insert(0, ast.Expr(value=ast.Constant(value=ClassDefDocstringBe)))
@@ -428,7 +443,8 @@ def makeTools(astStubFile: ast.AST, logicalPathInfix: str_nameDOTname = None) ->
 
 	writeModule(ast.Module(
 		body=[ast.Expr(ast.Constant(docstringWarning))
-			, ast.ImportFrom('collections.abc', [ast.alias('Sequence')], 0)			, ast.ImportFrom('astToolkit._astTypes', [ast.alias('*')], 0)
+			, ast.ImportFrom('astToolkit._astTypes', [ast.alias('*')], 0)
+			, ast.ImportFrom('collections.abc', [ast.alias('Sequence')], 0)
 			, ast.ImportFrom('astToolkit', [ast.alias(identifier) for identifier in ['ast_Identifier', 'ast_expr_Slice', 'astDOTtype_param']], 0)
 			, ast.ImportFrom('typing', [ast.alias(identifier) for identifier in ['Any', 'Literal', 'overload']], 0)
 			, ast.Import([ast.alias('ast')])
@@ -440,9 +456,10 @@ def makeTools(astStubFile: ast.AST, logicalPathInfix: str_nameDOTname = None) ->
 
 	writeModule(ast.Module(
 		body=[ast.Expr(ast.Constant(docstringWarning))
-			, ast.ImportFrom('collections.abc', [ast.alias('Callable'), ast.alias('Sequence')], 0)
-			, astImportFromClassNewInPythonVersion			, ast.ImportFrom('astToolkit', [ast.alias(identifier) for identifier in ['ast_Identifier', 'ast_expr_Slice', 'NodeORattribute', 'ImaCallToName']], 0)
 			, ast.ImportFrom('astToolkit._astTypes', [ast.alias('*')], 0)
+			, astImportFromClassNewInPythonVersion
+			, ast.ImportFrom('astToolkit', [ast.alias(identifier) for identifier in ['ast_Identifier', 'ast_expr_Slice', 'NodeORattribute']], 0)
+			, ast.ImportFrom('collections.abc', [ast.alias('Callable'), ast.alias('Sequence')], 0)
 			, ast.ImportFrom('typing', [ast.alias('Any'), ast.alias('Literal')], 0)
 			, ast.Import([ast.alias('ast')])
 			, ClassDefGrab
@@ -453,9 +470,9 @@ def makeTools(astStubFile: ast.AST, logicalPathInfix: str_nameDOTname = None) ->
 
 	writeModule(ast.Module(
 		body=[ast.Expr(ast.Constant(docstringWarning))
-			, ast.ImportFrom('collections.abc', [ast.alias('Sequence')], 0)
 			, astImportFromClassNewInPythonVersion
 			, ast.ImportFrom('astToolkit', [ast.alias(identifier) for identifier in ['ast_Identifier', 'ast_expr_Slice', 'intORstr', 'intORstrORtype_params', 'intORtype_params', 'str_nameDOTname']], 0)
+			, ast.ImportFrom('collections.abc', [ast.alias('Sequence')], 0)
 			, ast.ImportFrom('typing', [ast.alias('Any'), ast.alias('Literal')], 0)
 			, ast.Import([ast.alias('ast')])
 			, ClassDefMake

{asttoolkit-0.1.0 → asttoolkit-0.1.2}/toolFactory/astFactory_annex.py

@@ -21,16 +21,8 @@ def andDoAllOf(listOfActions: list[Callable[[NodeORattribute], NodeORattribute]]
 	return workhorse
 """
 
-Grab_funcDOTidAttribute: str ="""@staticmethod
-def funcDOTidAttribute(action: Callable[[ast_Identifier], Any]) -> Callable[[ImaCallToName], ImaCallToName]:
-	def workhorse(node: ImaCallToName) -> ImaCallToName:
-		node.func = Grab.idAttribute(action)(node.func)
-		return node
-	return workhorse
-"""
-
 handmadeMethodsGrab: list[ast.FunctionDef] = []
-for string in [Grab_andDoAllOf, Grab_funcDOTidAttribute]:
+for string in [Grab_andDoAllOf]:
 	astModule = ast.parse(string)
 	for node in ast.iter_child_nodes(astModule):
 		if isinstance(node, ast.FunctionDef):
@@ -55,9 +47,16 @@ MakeAttributeFunctionDef: ast.FunctionDef = ast.FunctionDef(
 
 MakeImportFunctionDef: ast.FunctionDef = ast.FunctionDef(name='Import', args=ast.arguments(args=[ast.arg(arg='moduleWithLogicalPath', annotation=ast.Name(id='str_nameDOTname', ctx=ast.Load())), ast.arg(arg='asName', annotation=ast.BinOp(left=ast.Name(id='ast_Identifier', ctx=ast.Load()), op=ast.BitOr(), right=ast.Constant(value=None)))], kwarg=ast.arg(arg='keywordArguments', annotation=ast.Name(id='int', ctx=ast.Load())), defaults=[ast.Constant(value=None)]), body=[ast.Return(value=ast.Call(func=ast.Attribute(value=ast.Name(id='ast', ctx=ast.Load()), attr='Import', ctx=ast.Load()), keywords=[ast.keyword(arg='names', value=ast.List(elts=[ast.Call(func=ast.Attribute(value=ast.Name(id='Make', ctx=ast.Load()), attr='alias', ctx=ast.Load()), args=[ast.Name(id='moduleWithLogicalPath', ctx=ast.Load()), ast.Name(id='asName', ctx=ast.Load())])], ctx=ast.Load())), ast.keyword(value=ast.Name(id='keywordArguments', ctx=ast.Load()))]))], decorator_list=[ast.Name(id='staticmethod', ctx=ast.Load())], returns=ast.Attribute(value=ast.Name(id='ast', ctx=ast.Load()), attr='Import', ctx=ast.Load()))
 
+listPylanceErrors: list[str] = ['annotation', 'arg', 'args', 'body', 'keys', 'name', 'names', 'op', 'orelse', 'pattern', 'returns', 'target', 'value',]
+
 # ww='''
-# list(targets)
+# def argAttribute(action: Callable[[ast_Identifier | (ast_Identifier | None)], ast_Identifier | (ast_Identifier | None)]) -> Callable[[hasDOTarg], hasDOTarg]:
+
+# 	def workhorse(node: hasDOTarg) -> hasDOTarg:
+# 		node.arg = action(node.arg) # type: ignore[reportAttributeAccessIssue]
+# 		return node
+# 	return workhorse
 # '''
 
-# print(ast.dump(ast.parse(ww), indent=4))
+# print(ast.dump(ast.parse(ww, type_comments=True), indent=4))
 # from ast import *