astToolkit 0.1.4__tar.gz → 0.2.0__tar.gz

{asttoolkit-0.1.4 → asttoolkit-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astToolkit
-Version: 0.1.4
+Version: 0.2.0
 Summary: A powerfully composable, type-safe toolkit for Python abstract syntax tree (AST) manipulation, analysis, transformation, and code generation with a layered architecture designed for building sophisticated code processing assembly-lines.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0

{asttoolkit-0.1.4 → asttoolkit-0.2.0}/astToolkit/__init__.py

@@ -13,6 +13,7 @@ from astToolkit._types import (
 	NodeORattribute as NodeORattribute,
 	str_nameDOTname as str_nameDOTname,
 	个 as 个,
+	个return as 个return,
 )
 
 from astToolkit._toolkitNodeVisitor import (

{asttoolkit-0.1.4 → asttoolkit-0.2.0}/astToolkit/_toolIfThis.py

@@ -44,12 +44,6 @@ class IfThis:
 		"""see also `isArgument_Identifier`"""
 		return lambda node: Be.keyword(node) and IfThis.isIdentifier(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.isIdentifier(identifier)(DOT.arg(node))
@@ -58,10 +52,6 @@ class IfThis:
 	def isAssignAndTargets0Is(targets0Predicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], TypeGuard[ast.AnnAssign] | bool]:
 		""" `node` is `ast.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]:
@@ -82,12 +72,6 @@ class IfThis:
 	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 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:
-			return Be.AugAssign(node) and targetPredicate(DOT.target(node))
-		return workhorse
-
 	@staticmethod
 	def isCall_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Call] | bool]:
 		def workhorse(node: ast.AST) -> TypeGuard[ast.Call] | bool:

{asttoolkit-0.1.4 → asttoolkit-0.2.0}/astToolkit/_toolkitNodeVisitor.py

@@ -15,12 +15,13 @@ structures, creating a complete workflow for code analysis and transformation.
 """
 
 from collections.abc import Callable
-from typing import Any
+from typing import Any, cast, Generic, TypeGuard, TypeVar
 import ast
+from astToolkit import NodeORattribute, 个, 个return
 
 # TODO Identify the logic that narrows the type and can help the user during static type checking.
 
-class NodeTourist(ast.NodeVisitor):
+class NodeTourist(ast.NodeVisitor, Generic[个, 个return]):
 	"""
 	Visit and extract information from AST nodes that match a predicate.
 
@@ -31,19 +32,18 @@ class NodeTourist(ast.NodeVisitor):
 	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:
+	def __init__(self, findThis: Callable[[ast.AST], TypeGuard[个] | bool], doThat: Callable[[个], 个return]) -> None:
 		self.findThis = findThis
 		self.doThat = doThat
-		self.nodeCaptured: Any | None = None
+		self.nodeCaptured: 个return | 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
+			node = cast(个, node)
+			self.nodeCaptured = self.doThat(node)
 		self.generic_visit(node)
 
-	def captureLastMatch(self, node: ast.AST) -> Any | None:
+	def captureLastMatch(self, node: ast.AST) -> 个return | None:
 		self.nodeCaptured = None
 		self.visit(node)
 		return self.nodeCaptured

{asttoolkit-0.1.4 → asttoolkit-0.2.0}/astToolkit/_types.py

@@ -17,7 +17,8 @@ str_nameDOTname: typing_TypeAlias = str
 
 # Limited success with TypeVar.
 个 = typing_TypeVar('个', bound = ast.AST, covariant = True)
-NodeORattribute = typing_TypeVar('NodeORattribute', bound = ast.AST | ast_expr_Slice | ast_Identifier | str_nameDOTname | bool | Any | None, covariant = True)
+个return = typing_TypeVar('个return', covariant = True)
+NodeORattribute = typing_TypeVar('NodeORattribute', bound = ast.AST | ast_Identifier | str_nameDOTname | bool | Any | None, covariant = True)
 
 # For my reference, all ast classes by subgroup:
 Ima_ast_boolop: typing_TypeAlias = ast.boolop | ast.And | ast.Or

{asttoolkit-0.1.4 → asttoolkit-0.2.0}/astToolkit/transformationTools.py

@@ -1,6 +1,7 @@
 from astToolkit import (
 	ast_Identifier,
 	Be,
+	ClassIsAndAttribute,
 	DOT,
 	FREAKOUT,
 	Grab,
@@ -65,7 +66,8 @@ 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.funcAttribute(cast(Callable[[ast.expr], ast.expr], Grab.idAttribute(cast(Callable[[ast_Identifier], ast_Identifier], 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] = {}
@@ -94,7 +96,7 @@ def inlineFunctionDef(identifierToInline: ast_Identifier, module: ast.Module) ->
 						for astFunctionDef in dictionary4Inlining.values():
 							inliner.visit(astFunctionDef)
 					else:
-						inliner = NodeChanger(IfThis.isAssignAndValueIs(IfThis.isCall_Identifier(identifier)),Then.replaceWith(FunctionDefTarget.body[0:-1]))
+						inliner = NodeChanger(ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCall_Identifier(identifier)),Then.replaceWith(FunctionDefTarget.body[0:-1]))
 						for astFunctionDef in dictionary4Inlining.values():
 							inliner.visit(astFunctionDef)
 
@@ -104,7 +106,7 @@ def inlineFunctionDef(identifierToInline: ast_Identifier, module: ast.Module) ->
 			inliner = NodeChanger(IfThis.isCall_Identifier(identifier), Then.replaceWith(replacement))
 			inliner.visit(FunctionDefToInline)
 		else:
-			inliner = NodeChanger(IfThis.isAssignAndValueIs(IfThis.isCall_Identifier(identifier)),Then.replaceWith(FunctionDefTarget.body[0:-1]))
+			inliner = NodeChanger(ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCall_Identifier(identifier)),Then.replaceWith(FunctionDefTarget.body[0:-1]))
 			inliner.visit(FunctionDefToInline)
 	ast.fix_missing_locations(FunctionDefToInline)
 	return FunctionDefToInline

{asttoolkit-0.1.4 → asttoolkit-0.2.0}/astToolkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astToolkit
-Version: 0.1.4
+Version: 0.2.0
 Summary: A powerfully composable, type-safe toolkit for Python abstract syntax tree (AST) manipulation, analysis, transformation, and code generation with a layered architecture designed for building sophisticated code processing assembly-lines.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0

{asttoolkit-0.1.4 → asttoolkit-0.2.0}/pyproject.toml

@@ -36,7 +36,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.4"
+version = "0.2.0"
 
 [tool.coverage]
 report = { exclude_lines = [

asttoolkit-0.2.0/toolFactory/Z0Z_makeAstTools.py

@@ -0,0 +1,42 @@
+from collections.abc import Callable, Sequence
+import typeshed_client.finder
+from toolFactory import FREAKOUT, pathTypeshed, Z0Z_typesSpecial, makeTools
+from pathlib import Path
+from typing import Any, TypeAlias as typing_TypeAlias, TypeVar as typing_TypeVar
+import ast
+
+ast_expr_Slice: typing_TypeAlias = ast.expr
+ast_Identifier: typing_TypeAlias = str
+str_nameDOTname: typing_TypeAlias = str
+
+个 = typing_TypeVar('个', bound = ast.AST, covariant = True)
+NodeORattribute = typing_TypeVar('NodeORattribute', bound = ast.AST | ast_expr_Slice | ast_Identifier | str_nameDOTname | bool | Any | None, covariant = True)
+
+# TODO Some `DOT` methods return lists, notably DOT.targets, which is an attribute of ast.Assign.
+# But, none or almost none of the other functions and methods accept a list as input.
+# This is most obviously a problem in `ClassIsAndAttribute.targetsIs` because the user needs to pass
+# a function that can take list[ast.expr] as a parameter.
+# I don't know if the following works, but it is interesting.
+# ClassIsAndAttribute.targetsIs(ast.Assign, lambda list_expr: any([IfThis.isSubscript_Identifier('foldGroups')(node) for node in list_expr]))
+
+class cleverName:
+    @staticmethod
+    def index(at: int) -> Callable[[Sequence[NodeORattribute]], NodeORattribute]:
+        def workhorse(zzz: Sequence[NodeORattribute]) -> NodeORattribute:
+            node = zzz[at]
+            return node
+        return workhorse
+
+if __name__ == "__main__":
+	search_context = typeshed_client.finder.get_search_context(typeshed=pathTypeshed if pathTypeshed.exists() else None)
+
+	# pathFilenameStubFile: Path | None = typeshed_client.finder.get_stub_file("_ast", search_context=search_context)
+	# if pathFilenameStubFile is None: raise FREAKOUT
+	# astStubFile: ast.Module = ast.parse(pathFilenameStubFile.read_text())
+	# Z0Z_typesSpecial(astStubFile)
+
+	pathFilenameStubFile: Path | None = typeshed_client.finder.get_stub_file("ast", search_context=search_context)
+	if pathFilenameStubFile is None: raise FREAKOUT
+	astStubFile: ast.Module = ast.parse(pathFilenameStubFile.read_text())
+
+	makeTools(astStubFile)

asttoolkit-0.1.4/toolFactory/Z0Z_makeAstTools.py

@@ -1,36 +0,0 @@
-import typeshed_client.finder
-from toolFactory import FREAKOUT, pathTypeshed, Z0Z_typesSpecial, makeTools
-from pathlib import Path
-import ast
-
-# TODO I think there is a way to generalize this to all antecedents using a class analogous to Grab
-
-# NodeTransformer
-# NodeVisitor
-# ^\s*class \w+\(((operator)|(cmpop)|(AST)|(mod)|(stmt)|(expr)|(expr_context)|(type_ignore)|(_Slice)|(pattern)|(boolop)|(unaryop)|(binaryop)|(type_param)|(excepthandler))\)
-
-"""
-	@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:
-			return Be.AugAssign(node) and targetPredicate(DOT.target(node))
-		return workhorse
-
-findThis = Be.AnnAssign and Be.checkAttribute_target(IfThis.isName_Identifier(self.name))
-"""
-
-if __name__ == "__main__":
-	search_context = typeshed_client.finder.get_search_context(typeshed=pathTypeshed if pathTypeshed.exists() else None)
-
-	# pathFilenameStubFile: Path | None = typeshed_client.finder.get_stub_file("_ast", search_context=search_context)
-	# if pathFilenameStubFile is None: raise FREAKOUT
-	# astStubFile: ast.Module = ast.parse(pathFilenameStubFile.read_text())
-	# Z0Z_typesSpecial(astStubFile)
-
-	pathFilenameStubFile: Path | None = typeshed_client.finder.get_stub_file("ast", search_context=search_context)
-	# print(pathFilenameStubFile)
-	if pathFilenameStubFile is None: raise FREAKOUT
-	astStubFile: ast.Module = ast.parse(pathFilenameStubFile.read_text())
-	# print(ast.dump(astStubFile))
-
-	makeTools(astStubFile)