astToolkit 0.7.0__tar.gz → 0.7.2__tar.gz

{asttoolkit-0.7.0 → asttoolkit-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astToolkit
-Version: 0.7.0
+Version: 0.7.2
 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
@@ -28,7 +28,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: autoflake
-Requires-Dist: hunterMakesPy
+Requires-Dist: hunterMakesPy>=0.2.1
 Requires-Dist: typing_extensions>=4.10.0
 Provides-Extra: development
 Requires-Dist: mypy; extra == "development"
@@ -354,4 +354,4 @@ Coding One Step at a Time:
 2. Write good code.
 3. When revising, write better code.
 
-[![CC-BY-NC-4.0](https://github.com/hunterhogan/astToolkit/blob/main/CC-BY-NC-4.0.svg)](https://creativecommons.org/licenses/by-nc/4.0/)
+[![CC-BY-NC-4.0](https://github.com/hunterhogan/astToolkit/blob/main/CC-BY-NC-4.0.png)](https://creativecommons.org/licenses/by-nc/4.0/)

{asttoolkit-0.7.0 → asttoolkit-0.7.2}/README.md

@@ -312,4 +312,4 @@ Coding One Step at a Time:
 2. Write good code.
 3. When revising, write better code.
 
-[![CC-BY-NC-4.0](https://github.com/hunterhogan/astToolkit/blob/main/CC-BY-NC-4.0.svg)](https://creativecommons.org/licenses/by-nc/4.0/)
+[![CC-BY-NC-4.0](https://github.com/hunterhogan/astToolkit/blob/main/CC-BY-NC-4.0.png)](https://creativecommons.org/licenses/by-nc/4.0/)

{asttoolkit-0.7.0 → asttoolkit-0.7.2}/astToolkit/_toolkitAST.py

@@ -71,23 +71,19 @@ def extractClassDef(astAST: ast.AST, identifier: str) -> ast.ClassDef | None:
 
 def extractFunctionDef(astAST: ast.AST, identifier: str) -> ast.FunctionDef | None:
 	"""
-	Extract a function definition with a specific name from an AST module.
-
-	(AI generated docstring)
-
-	This function searches through an AST module for a function definition that matches the provided identifier and returns it if found.
+	Extract the function from `astAST` with `ast.FunctionDef.name == identifier`.
 
 	Parameters
 	----------
 	astAST : ast.AST
-		The AST object to search within.
+		(abstract syntax tree) An `ast.AST` subclass from which to extract the function.
 	identifier : str
-		The name of the function to find.
+		The identifier in `ast.FunctionDef.name`.
 
 	Returns
 	-------
-	astFunctionDef | None
-		The matching function definition AST node, or `None` if not found.
+	astFunctionDef : ast.FunctionDef | None
+		The target function, or `None` if `extractFunctionDef` does not find `ast.FunctionDef.name == identifier`.
 
 	"""
 	return NodeTourist(IfThis.isFunctionDefIdentifier(identifier), Then.extractIt).captureLastMatch(astAST)
@@ -99,7 +95,7 @@ def parseLogicalPath2astModule(logicalPath: identifierDotAttribute, package: str
 	(AI generated docstring)
 
 	This function imports a module using its logical path (e.g., 'scipy.signal.windows') and converts its source code into an
-	`ast.Module` (abstract syntax tree) object. Supports all relevant `ast.parse` parameters.
+	`ast.Module` (abstract syntax tree) `object`. Supports all relevant `ast.parse` parameters.
 
 	Parameters
 	----------

{asttoolkit-0.7.0 → asttoolkit-0.7.2}/astToolkit/transformationTools.py

@@ -35,6 +35,7 @@ from os import PathLike
 from pathlib import PurePath
 from typing import Any
 import ast
+import io
 
 def makeDictionaryAsyncFunctionDef(astAST: ast.AST) -> dict[str, ast.AsyncFunctionDef]:
 	"""
@@ -127,48 +128,60 @@ def makeDictionaryMosDef(astAST: ast.AST) -> dict[str, ast.AsyncFunctionDef | as
 	dictionaryIdentifier2MosDef.update(makeDictionaryFunctionDef(astAST))
 	return dictionaryIdentifier2MosDef
 
-def inlineFunctionDef(identifierToInline: str, module: ast.Module) -> ast.FunctionDef:  # noqa: C901, PLR0912
+def inlineFunctionDef(identifierToInline: str, astModule: ast.Module) -> ast.FunctionDef:
 	"""
-	Inline function calls within a function definition to create a self-contained function.
+	Synthesize a new function from `identifierToInline` with the logic "inlined" from functions called by `identifierToInline`.
 
-	(AI generated docstring)
+	`inlineFunctionDef` starts with the `ast.FunctionDef` in `astModule` whose `ast.FunctionDef.name == identifierToInline`, then
+	`inlineFunctionDef` searches through `identifierToInline` for calls to functions defined in `astModule`.
+
+	More specifically, `inlineFunctionDef` searches for an `ast.Call` to an `ast.Name` (*e.g.*, `Path`, but not the
+	`ast.Attribute`, `pathlib.Path`). The `ast.Name` identifier is in `ast.Name.id`, for example, `ast.Name.id = "Path"`.
+	`inlineFunctionDef` then searches in `astModule` for an `ast.FunctionDef.name` that is the same as the `ast.Name.id`. If
+	`inlineFunctionDef` finds a matching `ast.FunctionDef`, it will replace `ast.Call` with the logic from the called function.
+
+	`inlineFunctionDef` repeats the process until it gets bored or until it cannot find any more functions to inline. Therefore,
+	`inlineFunctionDef` will inline functions that were not called directly by `identifierToInline` in the original `astModule`.
 
-	This function takes a function identifier and a module, finds the function definition,
-	and then recursively inlines all function calls within that function with their
-	implementation bodies. This produces a fully inlined function that doesn't depend
-	on other function definitions from the module.
+	`inlineFunctionDef`, however, does not inline an `ast.FunctionDef` if the `ast.FunctionDef` calls itself or if a "child" of
+	the `ast.FunctionDef` calls the original `ast.FunctionDef`.
 
 	Parameters
 	----------
 	identifierToInline : str
-		The name of the function to inline.
-	module : ast.Module
-		The AST module containing the function and its dependencies.
+		The identifier of the target function; the `str` must match an `ast.FunctionDef.name` in `astModule`.
+	astModule : ast.Module
+		(abstract syntax tree Module) An `ast.Module` with `ast.FunctionDef.name == identifierToInline` and zero or more other
+		`ast.FunctionDef` to inline.
 
 	Returns
 	-------
 	FunctionDefToInline : ast.FunctionDef
-		The inlined function definition as an `ast.FunctionDef` object.
+		The synthesized function with inlined logic from other functions defined in `astModule`.
 
 	Raises
 	------
-		ValueError: If the function to inline is not found in the module.
+		ValueError: If `identifierToInline` does not match any `ast.FunctionDef.name` in `astModule`.
 	"""
-	dictionaryFunctionDef: dict[str, ast.FunctionDef] = makeDictionaryFunctionDef(module)
+	dictionaryFunctionDef: dict[str, ast.FunctionDef] = makeDictionaryFunctionDef(astModule)
 	try:
 		FunctionDefToInline = dictionaryFunctionDef[identifierToInline]
 	except KeyError as ERRORmessage:
-		message = f"FunctionDefToInline not found in dictionaryIdentifier2FunctionDef: {identifierToInline = }"
+		message = f"I was unable to find an `ast.FunctionDef` with name {identifierToInline = } in {astModule = }."
 		raise ValueError(message) from ERRORmessage
 
 	listIdentifiersCalledFunctions: list[str] = []
+# TODO I probably have the skill now to expand this from only `IfThis.isCallToName` to include more options for `ast.Call.func`,
+# such as attribute and subscript access. `IfThis.isNestedNameIdentifier` might be perfect. BUT, I think this will affect how I
+# key `dictionaryFunctionDef`.
 	findIdentifiersToInline = NodeTourist[ast.Call, ast.expr](IfThis.isCallToName
 		, Grab.funcAttribute(Grab.idAttribute(Then.appendTo(listIdentifiersCalledFunctions))))
 	findIdentifiersToInline.visit(FunctionDefToInline)
 
 	dictionary4Inlining: dict[str, ast.FunctionDef] = {}
 	for identifier in sorted(set(listIdentifiersCalledFunctions).intersection(dictionaryFunctionDef.keys())):
-		if NodeTourist(IfThis.matchesMeButNotAnyDescendant(IfThis.isCallIdentifier(identifier)), Then.extractIt).captureLastMatch(module) is not None:
+# TODO Learn how real programmers avoid infinite loops but still inline recursive functions.
+		if NodeTourist(IfThis.matchesMeButNotAnyDescendant(IfThis.isCallIdentifier(identifier)), Then.extractIt).captureLastMatch(astModule) is not None:
 			dictionary4Inlining[identifier] = dictionaryFunctionDef[identifier]
 
 	keepGoing = True
@@ -181,7 +194,7 @@ def inlineFunctionDef(identifierToInline: str, module: ast.Module) -> ast.Functi
 		if len(listIdentifiersCalledFunctions) > 0:
 			keepGoing = True
 			for identifier in listIdentifiersCalledFunctions:
-				if NodeTourist(IfThis.matchesMeButNotAnyDescendant(IfThis.isCallIdentifier(identifier)), Then.extractIt).captureLastMatch(module) is not None:
+				if NodeTourist(IfThis.matchesMeButNotAnyDescendant(IfThis.isCallIdentifier(identifier)), Then.extractIt).captureLastMatch(astModule) is not None:
 					FunctionDefTarget = dictionaryFunctionDef[identifier]
 					if len(FunctionDefTarget.body) == 1:
 						replacement = NodeTourist(Be.Return, Then.extractIt(DOT.value)).captureLastMatch(FunctionDefTarget)
@@ -205,6 +218,32 @@ def inlineFunctionDef(identifierToInline: str, module: ast.Module) -> ast.Functi
 	ast.fix_missing_locations(FunctionDefToInline)
 	return FunctionDefToInline
 
+def pythonCode2ast_expr(string: str) -> ast.expr:
+	"""PROTOTYPE Convert *one* expression-as-a-string of Python code to an `ast.expr`.
+
+	TODO add list of applicable subclasses. Until then, see `Make.expr` for an approximate list.
+
+	Note well
+	---------
+	This prototype "shortcut" function has approximately 482 *implied* constraints and pitfalls. If you can't get it to do what
+	you want, I recommend saving yourself a bunch of stress and not using this shortcut.
+	"""
+	return raiseIfNone(NodeTourist(Be.Expr, Then.extractIt(DOT.value)).captureLastMatch(ast.parse(string)))
+
+def pythonCode2ast_stmt(string: str):
+	"""PROTOTYPE Convert *one* statement-as-a-string of Python code to an `ast.stmt`.
+
+	TODO add list of applicable subclasses. Until then, see `Make.stmt` for an approximate list.
+
+	Note well
+	---------
+	This prototype "shortcut" function has approximately eleventy gazillion *implied* constraints and pitfalls. If you can't get
+	it to do what you want, I recommend saving yourself a bunch of stress and not using this shortcut.
+	"""
+	astModule: ast.Module = ast.parse(string)
+	findThis = Be.Module
+	doThat = "not today; I can't think through the pain."
+
 def removeUnusedParameters(ingredientsFunction: IngredientsFunction) -> IngredientsFunction:
 	"""
 	Remove unused parameters from `IngredientsFunction.astFunctionDef`, but not from `import` statements.
@@ -255,6 +294,46 @@ def removeUnusedParameters(ingredientsFunction: IngredientsFunction) -> Ingredie
 
 	return ingredientsFunction
 
+def unjoinBinOP(astAST: ast.AST, operator: type[ast.operator] = ast.operator) -> list[ast.expr]:
+	"""
+	Unjoin a binary operation AST node into a list of expressions.
+
+	(AI generated docstring)
+
+	This function takes an AST node representing a binary operation and recursively
+	unjoins it into a flat list of expressions. It handles both binary operations
+	and unary operations, ensuring that all nested expressions are extracted.
+
+	Parameters
+	----------
+	astAST : ast.AST
+		The AST node to unjoin.
+	operator : type[ast.operator] = ast.operator
+		The type of binary operator to look for in the AST. Defaults to `ast.operator`.
+
+	Returns
+	-------
+	list[ast.expr]
+		A list of expressions extracted from the binary operation AST node.
+	"""
+	list_ast_expr: list[ast.expr] = []
+	workbench: list[ast.expr] = []
+
+	findThis = Be.BinOp.opIs(lambda this_op: isinstance(this_op, operator))
+	doThat = Grab.andDoAllOf([Grab.leftAttribute(Then.appendTo(workbench)), Grab.rightAttribute(Then.appendTo(list_ast_expr))])
+	breakingBinOp = NodeTourist(findThis, doThat)
+
+	breakingBinOp.visit(astAST)
+
+	while workbench:
+		ast_expr = workbench.pop()
+		if isinstance(ast_expr, ast.BinOp):
+			breakingBinOp.visit(ast_expr)
+		else:
+			list_ast_expr.append(ast_expr)
+
+	return list_ast_expr
+
 def unparseFindReplace(astTree: 木, mappingFindReplaceNodes: Mapping[ast.AST, ast.AST]) -> 木:
 	"""
 	Recursively replace AST (Abstract Syntax Tree) nodes based on a mapping of find-replace pairs.
@@ -295,7 +374,7 @@ def unparseFindReplace(astTree: 木, mappingFindReplaceNodes: Mapping[ast.AST, a
 			astTree = deepcopy(newTree)
 	return newTree
 
-def write_astModule(ingredients: IngredientsModule, pathFilename: PathLike[Any] | PurePath, packageName: str | None = None) -> None:
+def write_astModule(ingredients: IngredientsModule, pathFilename: PathLike[Any] | PurePath | io.TextIOBase, packageName: str | None = None) -> None:
 	"""
 	Convert an IngredientsModule to Python source code and write it to a file.
 
@@ -326,49 +405,10 @@ def write_astModule(ingredients: IngredientsModule, pathFilename: PathLike[Any]
 	"""
 	astModule = Make.Module(ingredients.body, ingredients.type_ignores)
 	ast.fix_missing_locations(astModule)
-	pythonSource: str = raiseIfNone(ast.unparse(astModule))
+	pythonSource: str = ast.unparse(astModule)
 	autoflake_additional_imports: list[str] = ingredients.imports.exportListModuleIdentifiers()
 	if packageName:
 		autoflake_additional_imports.append(packageName)
 	pythonSource = autoflake_fix_code(pythonSource, autoflake_additional_imports, expand_star_imports=False, remove_all_unused_imports=True, remove_duplicate_keys = False, remove_unused_variables = False)
 	writeStringToHere(pythonSource, pathFilename)
 
-def unjoinBinOP(astAST: ast.AST, operator: type[ast.operator] = ast.operator) -> list[ast.expr]:
-	"""
-	Unjoin a binary operation AST node into a list of expressions.
-
-	(AI generated docstring)
-
-	This function takes an AST node representing a binary operation and recursively
-	unjoins it into a flat list of expressions. It handles both binary operations
-	and unary operations, ensuring that all nested expressions are extracted.
-
-	Parameters
-	----------
-	astAST : ast.AST
-		The AST node to unjoin.
-	operator : type[ast.operator] = ast.operator
-		The type of binary operator to look for in the AST. Defaults to `ast.operator`.
-
-	Returns
-	-------
-	list[ast.expr]
-		A list of expressions extracted from the binary operation AST node.
-	"""
-	list_ast_expr: list[ast.expr] = []
-	workbench: list[ast.expr] = []
-
-	findThis = Be.BinOp.opIs(lambda this_op: isinstance(this_op, operator))
-	doThat = Grab.andDoAllOf([Grab.leftAttribute(Then.appendTo(workbench)), Grab.rightAttribute(Then.appendTo(list_ast_expr))])
-	breakingBinOp = NodeTourist(findThis, doThat)
-
-	breakingBinOp.visit(astAST)
-
-	while workbench:
-		ast_expr = workbench.pop()
-		if isinstance(ast_expr, ast.BinOp):
-			breakingBinOp.visit(ast_expr)
-		else:
-			list_ast_expr.append(ast_expr)
-
-	return list_ast_expr

{asttoolkit-0.7.0 → asttoolkit-0.7.2}/astToolkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astToolkit
-Version: 0.7.0
+Version: 0.7.2
 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
@@ -28,7 +28,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: autoflake
-Requires-Dist: hunterMakesPy
+Requires-Dist: hunterMakesPy>=0.2.1
 Requires-Dist: typing_extensions>=4.10.0
 Provides-Extra: development
 Requires-Dist: mypy; extra == "development"
@@ -354,4 +354,4 @@ Coding One Step at a Time:
 2. Write good code.
 3. When revising, write better code.
 
-[![CC-BY-NC-4.0](https://github.com/hunterhogan/astToolkit/blob/main/CC-BY-NC-4.0.svg)](https://creativecommons.org/licenses/by-nc/4.0/)
+[![CC-BY-NC-4.0](https://github.com/hunterhogan/astToolkit/blob/main/CC-BY-NC-4.0.png)](https://creativecommons.org/licenses/by-nc/4.0/)

{asttoolkit-0.7.0 → asttoolkit-0.7.2}/astToolkit.egg-info/SOURCES.txt

@@ -26,9 +26,6 @@ astToolkit.egg-info/top_level.txt
 tests/__init__.py
 tests/conftest.py
 tests/test_Be.py
-tests/test_Find.py
-tests/test_joinClassmethod.py
-tests/test_nodeVisitors.py
 tests/dataSamples/Make.py
 tests/dataSamples/__init__.py
 tests/dataSamples/createTestData.py

{asttoolkit-0.7.0 → asttoolkit-0.7.2}/astToolkit.egg-info/requires.txt

@@ -1,5 +1,5 @@
 autoflake
-hunterMakesPy
+hunterMakesPy>=0.2.1
 typing_extensions>=4.10.0
 
 [development]

{asttoolkit-0.7.0 → asttoolkit-0.7.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "astToolkit"
-version = "0.7.0"
+version = "0.7.2"
 description = "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."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -48,7 +48,7 @@ classifiers = [
 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" }
 dependencies = [
   "autoflake",
-  "hunterMakesPy",
+  "hunterMakesPy>=0.2.1",
   "typing_extensions>=4.10.0",
 ]
 optional-dependencies = { development = [

{asttoolkit-0.7.0 → asttoolkit-0.7.2}/tests/conftest.py

@@ -1,19 +1,12 @@
 """SSOT for all tests."""
 
 from collections.abc import Iterator
-from datetime import datetime, UTC
 from functools import cache
 from tests.dataSamples.Make import allSubclasses
 from typing import Any
 import ast  # pyright: ignore[reportUnusedImport]
 import pytest
 
-antiTests: int = 3
-
-shiftByHour: int = datetime.now(UTC).hour
-shiftByDate: int = datetime.now(UTC).day
-shiftTotal: int = shiftByHour * shiftByDate + 1
-
 def generateBeTestData() -> Iterator[tuple[str, str, dict[str, Any]]]:
 	"""Yield test data for positive Be tests. (AI generated docstring).
 

asttoolkit-0.7.0/tests/test_Find.py

@@ -1,15 +0,0 @@
-"""Not every module needs a docstring."""
-from astToolkit import Find
-from tests.conftest import generateBeTestData
-from typing import Any, TYPE_CHECKING
-import pytest
-
-if TYPE_CHECKING:
-	import ast
-
-# @pytest.mark.parametrize("identifierClass, subtestName, dictionaryTests", list(generateBeTestData()))  # noqa: PT006
-# def test_Find_identifies_class(identifierClass: str, subtestName: str, dictionaryTests: dict[str, Any]) -> None:  # noqa: ARG001
-# 	"""test_Find_identifies_class."""
-# 	node: ast.AST = dictionaryTests["expression"]
-# 	ww = eval(f"Find.{identifierClass}")
-# 	assert ww(node)

asttoolkit-0.7.0/tests/test_joinClassmethod.py

@@ -1,103 +0,0 @@
-from astToolkit import ast_attributes, Make
-from collections.abc import Callable
-from typing import cast
-import ast
-import pytest
-
-constant_expression_5 = Make.Constant(5)
-constant_expression_7 = Make.Constant(7)
-constant_expression_11 = Make.Constant(11)
-
-keyword_arguments_set_A: ast_attributes = {"lineno": 3, "col_offset": 8, "end_lineno": 3, "end_col_offset": 12}
-keyword_arguments_set_B: ast_attributes = {"lineno": 17, "col_offset": 19, "end_lineno": 17, "end_col_offset": 25}
-
-
-def construct_expected_ast_node(ast_operator_type: type[ast.operator], input_expressions_iterable: list[ast.expr], keyword_arguments_for_operation: ast_attributes) -> ast.expr:
-	processed_expressions_list = list(input_expressions_iterable)
-	if not processed_expressions_list:
-		return Make.Constant('', **keyword_arguments_for_operation)
-
-	current_joined_expression = processed_expressions_list[0]
-	for next_expression_to_join in processed_expressions_list[1:]:
-		current_joined_expression = ast.BinOp(
-			left=current_joined_expression,
-			op=ast_operator_type(),
-			right=next_expression_to_join,
-			**keyword_arguments_for_operation
-		)
-	return current_joined_expression
-
-listBoolOpIdentifiers: list[str] = sorted([subclass.__name__ for subclass in ast.boolop.__subclasses__()])
-listOperatorIdentifiers: list[str] = sorted([subclass.__name__ for subclass in ast.operator.__subclasses__()])
-
-listBoolOpJoinImplementationAndAstPairs = [
-	(Make.__dict__[identifier], ast.__dict__[identifier])
-	for identifier in listBoolOpIdentifiers
-	if identifier in Make.__dict__
-]
-
-listOperatorJoinImplementationAndAstPairs = [
-	(Make.__dict__[identifier], ast.__dict__[identifier])
-	for identifier in listOperatorIdentifiers
-	if identifier in Make.__dict__
-]
-
-list_join_method_test_scenarios_params: list[object] = []
-raw_scenarios: list[tuple[str, list[ast.expr], ast_attributes]] = [
-	("empty_list_no_kwargs", [], {}),
-	("empty_list_with_kwargs", [], keyword_arguments_set_A),
-	("single_expr_no_kwargs", [constant_expression_5], {}),
-	("single_expr_with_kwargs", [constant_expression_5], keyword_arguments_set_A),
-	("two_exprs_no_kwargs", [constant_expression_5, constant_expression_7], {}),
-	("two_exprs_with_kwargs", [constant_expression_5, constant_expression_7], keyword_arguments_set_A),
-	("three_exprs_no_kwargs", [constant_expression_5, constant_expression_7, constant_expression_11], {}),
-	("three_exprs_with_kwargs", [constant_expression_5, constant_expression_7, constant_expression_11], keyword_arguments_set_B),
-	(
-		"single_expr_with_internal_attrs_and_kwargs",
-		[Make.Constant(13, lineno=23, col_offset=29, end_lineno=23, end_col_offset=35)],
-		keyword_arguments_set_A,
-	),
-	(
-		"two_exprs_with_internal_attrs_and_kwargs",
-		[
-			Make.Constant(13, lineno=23, col_offset=29, end_lineno=23, end_col_offset=35),
-			Make.Constant(31, lineno=37, col_offset=41, end_lineno=37, end_col_offset=47)
-		],
-		keyword_arguments_set_A,
-	)
-]
-
-for scenario_id, expressions, kwargs in raw_scenarios:
-	# Create a builder that captures the specific expressions and kwargs for this scenario
-	def builder(op_type: type[ast.operator], bound_expressions: list[ast.expr] = expressions, bound_kwargs: ast_attributes = kwargs) -> ast.expr:
-		return construct_expected_ast_node(op_type, bound_expressions, bound_kwargs)
-	list_join_method_test_scenarios_params.append(
-		pytest.param(scenario_id, expressions, kwargs, builder, id=scenario_id)
-	)
-
-
-@pytest.mark.parametrize("JoinImplementerClass, ast_operator_type", listOperatorJoinImplementationAndAstPairs)
-@pytest.mark.parametrize("scenario_identifier, expressions_for_join_method, keyword_arguments_for_join_method, expected_ast_constructor", list_join_method_test_scenarios_params)
-def test_join_method(
-	JoinImplementerClass: type,
-	ast_operator_type: type[ast.operator],
-	scenario_identifier: str,
-	expressions_for_join_method: list[ast.expr],
-	keyword_arguments_for_join_method: ast_attributes,
-	expected_ast_constructor: Callable[[type[ast.operator]], ast.expr]
-
-) -> None:
-	join_method = JoinImplementerClass.join
-	actual_ast_node = cast("ast.expr", join_method(expressions_for_join_method, **keyword_arguments_for_join_method))
-	expected_ast_node = expected_ast_constructor(ast_operator_type)
-
-	dump_of_actual_ast_node = ast.dump(actual_ast_node)
-	dump_of_expected_ast_node = ast.dump(expected_ast_node)
-
-	assert dump_of_actual_ast_node == dump_of_expected_ast_node, (
-		f"Test {scenario_identifier} for {JoinImplementerClass.__name__} failed.\n"
-		f"Input expressions: {[ast.dump(expression_node) for expression_node in expressions_for_join_method]}\n"
-		f"Input kwargs: {keyword_arguments_for_join_method}\n"
-		f"Expected AST dump: {dump_of_expected_ast_node}\n"
-		f"Actual AST dump: {dump_of_actual_ast_node}"
-	)

asttoolkit-0.7.0/tests/test_nodeVisitors.py

@@ -1,377 +0,0 @@
-from astToolkit import Make, NodeChanger, NodeTourist
-import ast
-
-class TestNodeVisitors:
-	"""
-	Tests adapted from CPython's NodeVisitor and NodeTransformer tests
-	to validate astToolkit's NodeTourist and NodeChanger functionality.
-	"""
-
-	def test_nodeTouristBasicVisiting(self):
-		"""Test that NodeTourist can visit nodes and collect information."""
-
-		visitedNodes = []
-
-		def collectNameNodes(node: ast.AST):
-			if isinstance(node, ast.Name):
-				visitedNodes.append(('Name', node.id, node.ctx.__class__.__name__))
-				return True
-			return False
-
-		def collectNodeInfo(node: ast.AST):
-			# Action is already handled in the predicate for this test
-			return None
-
-		# Create test AST using Make factory
-		testModule = Make.Module([
-			Make.Assign(
-				[Make.Name("x", ast.Store())],
-				Make.Constant(42)
-			),
-			Make.Assign(
-				[Make.Name("y", ast.Store())],
-				Make.Name("x", ast.Load())
-			)
-		])
-
-		# Create tourist that captures Name nodes
-		nameTourist = NodeTourist(collectNameNodes, collectNodeInfo)
-		nameTourist.visit(testModule)
-
-		expected = [
-			('Name', 'x', 'Store'),
-			('Name', 'y', 'Store'),
-			('Name', 'x', 'Load')        ]
-		assert visitedNodes == expected
-
-	def test_nodeChangerBasicTransformation(self):
-		"""Test that NodeChanger can transform nodes."""
-
-		def findNameNodes(node: ast.AST):
-			return isinstance(node, ast.Name) and node.id == "oldVariable"
-
-		def replaceWithNewName(node):
-			return Make.Name("newVariable", node.ctx)
-
-		# Create test AST
-		originalModule = Make.Module([
-			Make.Assign(
-				[Make.Name("oldVariable", ast.Store())],
-				Make.Constant(42)
-			),
-			Make.Expr(Make.Name("oldVariable", ast.Load()))
-		])
-
-		changer = NodeChanger(findNameNodes, replaceWithNewName)
-		transformedModule = changer.visit(originalModule)
-
-		# Check that names were replaced
-		assert isinstance(transformedModule, ast.Module)
-		assignment = transformedModule.body[0]
-		assert isinstance(assignment, ast.Assign)
-		assert isinstance(assignment.targets[0], ast.Name)
-		assert assignment.targets[0].id == "newVariable"
-
-		expression = transformedModule.body[1]
-		assert isinstance(expression, ast.Expr)
-		assert isinstance(expression.value, ast.Name)
-		assert expression.value.id == "newVariable"
-
-	def test_nodeChangerRemoveNodes(self):
-		"""Test NodeChanger can remove nodes by returning None."""
-
-		def findPrintExpressions(node):
-			return (isinstance(node, ast.Expr) and
-				   isinstance(node.value, ast.Call) and
-				   isinstance(node.value.func, ast.Name) and
-				   node.value.func.id == "print")
-
-		def removeNode(node):
-			return None
-			# Remove print calls
-
-		# Create test AST with print calls
-		testModule = Make.Module([
-			Make.Expr(Make.Call(Make.Name("print", ast.Load()), [Make.Constant("hello")])),
-			Make.Assign([Make.Name("x", ast.Store())], Make.Constant(42)),
-			Make.Expr(Make.Call(Make.Name("print", ast.Load()), [Make.Name("x", ast.Load())]))
-		])
-
-		remover = NodeChanger(findPrintExpressions, removeNode)
-		transformedModule = remover.visit(testModule)
-
-		# Only the assignment should remain
-		assert isinstance(transformedModule, ast.Module)
-		assert len(transformedModule.body) == 1
-		assert isinstance(transformedModule.body[0], ast.Assign)
-
-	def test_nodeChangerMultipleReplacements(self):
-		"""Test NodeChanger can replace one node with multiple nodes."""
-
-		def findAssignments(node):
-			return (isinstance(node, ast.Assign) and
-				   len(node.targets) == 1 and
-				   isinstance(node.targets[0], ast.Name))
-
-		def expandAssignment(node):
-			# Expand x = 42 into x = 42; print(x)
-			assignmentNode = node
-			printCall = Make.Expr(Make.Call(
-				Make.Name("print", ast.Load()),
-				[Make.Name(node.targets[0].id, ast.Load())]
-			))
-			return [assignmentNode, printCall]
-
-		testModule = Make.Module([
-			Make.Assign([Make.Name("x", ast.Store())], Make.Constant(42))
-		])
-
-		expander = NodeChanger(findAssignments, expandAssignment)
-		transformedModule = expander.visit(testModule)
-
-		# Should have both assignment and print
-		assert isinstance(transformedModule, ast.Module)
-		assert len(transformedModule.body) == 2
-		assert isinstance(transformedModule.body[0], ast.Assign)
-		assert isinstance(transformedModule.body[1], ast.Expr)
-		assert isinstance(transformedModule.body[1].value, ast.Call)
-
-	def test_nodeTouristWithComplexAST(self):
-		"""Test NodeTourist with more complex AST structures."""
-
-		# Use a shared counter to track different node types
-		counts = {"functions": 0, "classes": 0, "loops": 0, "conditions": 0}
-
-		def findStructuralNodes(node):
-			return isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef,
-								   ast.For, ast.While, ast.If))
-
-		def countNodeType(node):
-			if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-				counts["functions"] += 1
-			elif isinstance(node, ast.ClassDef):
-				counts["classes"] += 1
-			elif isinstance(node, (ast.For, ast.While)):
-				counts["loops"] += 1
-			elif isinstance(node, ast.If):
-				counts["conditions"] += 1
-			return node
-
-		# Create complex AST structure
-		complexModule = Make.Module([
-			Make.FunctionDef(
-				"function1",
-				Make.arguments(),
-				body=[
-					Make.If(
-						Make.Name("condition", ast.Load()),
-						body=[Make.Pass()]
-					),
-					Make.For(
-						Make.Name("item", ast.Store()),
-						Make.Name("items", ast.Load()),
-						body=[Make.Pass()]
-					)
-				]
-			),
-			Make.ClassDef(
-				"TestClass",
-				body=[
-					Make.FunctionDef(
-						"method",
-						Make.arguments(),
-						body=[
-							Make.While(
-								Make.Constant(True),
-								body=[Make.Break()]
-							)
-						]
-					)
-				]
-			)
-		])
-
-		analyzer = NodeTourist(findStructuralNodes, countNodeType)
-		analyzer.visit(complexModule)
-
-		assert counts["functions"] == 2
-		# function1 and method
-		assert counts["classes"] == 1
-		# TestClass
-		assert counts["loops"] == 2
-		# for and while
-		assert counts["conditions"] == 1
-		# if statement
-	def test_nodeChangerPreservesLocation(self):
-		"""Test that NodeChanger preserves location information."""
-
-		def findIntConstants(node):
-			return isinstance(node, ast.Constant) and isinstance(node.value, int)
-
-		def doubleConstant(node):
-			# Replace integer constants with doubled values
-			newNode = Make.Constant(node.value * 2)
-			return ast.copy_location(newNode, node)
-
-		# Create AST with location info
-		testModule = Make.Module([
-			Make.Assign(
-				[Make.Name("x", ast.Store())],
-				Make.Constant(21, lineno=1, col_offset=4)
-			)
-		])
-
-		changer = NodeChanger(findIntConstants, doubleConstant)
-		transformedModule = changer.visit(testModule)
-
-		# Check that value was doubled and location preserved
-		assert isinstance(transformedModule, ast.Module)
-		assignment = transformedModule.body[0]
-		assert isinstance(assignment, ast.Assign)
-		constantNode = assignment.value
-		assert isinstance(constantNode, ast.Constant)
-		assert constantNode.value == 42
-		assert constantNode.lineno == 1
-		assert constantNode.col_offset == 4
-
-	def test_nodeChangerWithMakeFactoryMethods(self):
-		"""Test NodeChanger using Make factory methods for transformations."""
-
-		def findAugAssign(node):
-			return isinstance(node, ast.AugAssign)
-
-		def expandToAssignment(node):
-			"""Expand x += 1 to x = x + 1"""
-			# Create regular assignment equivalent
-			binaryOp = Make.BinOp(
-				Make.Name(node.target.id, ast.Load()),
-				node.op,
-				node.value
-			)
-			assignment = Make.Assign(
-				[Make.Name(node.target.id, ast.Store())],
-				binaryOp
-			)
-			return ast.copy_location(assignment, node)
-
-		testModule = Make.Module([
-			Make.AugAssign(
-				Make.Name("counter", ast.Store()),
-				ast.Add(),
-				Make.Constant(1)
-			)
-		])
-
-		expander = NodeChanger(findAugAssign, expandToAssignment)
-		transformedModule = expander.visit(testModule)
-
-		# Should be converted to regular assignment
-		assert isinstance(transformedModule, ast.Module)
-		statement = transformedModule.body[0]
-		assert isinstance(statement, ast.Assign)
-		assert isinstance(statement.value, ast.BinOp)
-		assert isinstance(statement.value.op, ast.Add)
-
-	def test_nodeVisitorErrorHandling(self):
-		"""Test visitor error handling with malformed AST."""
-
-		errorCount = [0]
-		# Use list for mutable reference
-
-		def findNameNodes(node):
-			return isinstance(node, ast.Name)
-
-		def handleNameNode(node):
-			try:
-				# This might fail if node is malformed
-				if hasattr(node, 'id') and node.id:
-					pass
-			except Exception:
-				errorCount[0] += 1
-			return node
-
-		# Create valid AST
-		validModule = Make.Module([
-			Make.Expr(Make.Name("validName", ast.Load()))
-		])
-
-		tourist = NodeTourist(findNameNodes, handleNameNode)
-		tourist.visit(validModule)
-
-		# Should handle valid AST without errors
-		assert errorCount[0] == 0
-
-	def test_nestedVisitorTransformations(self):
-		"""Test applying multiple transformations in sequence."""
-
-		def findUppercaseNames(node):
-			return isinstance(node, ast.Name) and node.id.isupper()
-
-		def lowercaseName(node):
-			return Make.Name(node.id.lower(), node.ctx)
-
-		def findIntConstants(node):
-			return isinstance(node, ast.Constant) and isinstance(node.value, int)
-
-		def doubleConstant(node):
-			return Make.Constant(node.value * 2)
-
-		# Create test AST
-		originalModule = Make.Module([
-			Make.Assign(
-				[Make.Name("VARIABLE", ast.Store())],
-				Make.Constant(21)
-			)
-		])
-
-		# Apply transformations in sequence
-		step1 = NodeChanger(findUppercaseNames, lowercaseName)
-		step2 = NodeChanger(findIntConstants, doubleConstant)
-
-		intermediateModule = step1.visit(originalModule)
-		finalModule = step2.visit(intermediateModule)
-
-		# Check both transformations applied
-		assert isinstance(finalModule, ast.Module)
-		assignment = finalModule.body[0]
-		assert isinstance(assignment, ast.Assign)
-		assert isinstance(assignment.targets[0], ast.Name)
-		assert assignment.targets[0].id == "variable"
-		# lowercased
-		assert isinstance(assignment.value, ast.Constant)
-		assert assignment.value.value == 42
-		# doubled
-	def test_visitorWithMakeJoinMethods(self):
-		"""Test visitors with Make join methods for combining expressions."""
-
-		def findComplexBoolOp(node):
-			return (isinstance(node, ast.BoolOp) and
-				   isinstance(node.op, ast.And) and
-				   len(node.values) > 2)
-
-		def simplifyBoolOp(node):
-			# Use Make.And.join for cleaner combination
-			return Make.And.join(node.values)
-
-		# Create complex boolean expression
-		testModule = Make.Module([
-			Make.If(
-				Make.BoolOp(ast.And(), [
-					Make.Name("a", ast.Load()),
-					Make.Name("b", ast.Load()),
-					Make.Name("c", ast.Load()),
-					Make.Name("d", ast.Load())
-				]),
-				body=[Make.Pass()]
-			)
-		])
-
-		combiner = NodeChanger(findComplexBoolOp, simplifyBoolOp)
-		transformedModule = combiner.visit(testModule)
-
-		# Should still be a valid boolean expression
-		assert isinstance(transformedModule, ast.Module)
-		ifStatement = transformedModule.body[0]
-		assert isinstance(ifStatement, ast.If)
-		condition = ifStatement.test
-		assert isinstance(condition, (ast.BoolOp, ast.Name))