astToolkit 0.3.7__tar.gz → 0.4.0__tar.gz

{asttoolkit-0.3.7 → asttoolkit-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astToolkit
-Version: 0.3.7
+Version: 0.4.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
@@ -30,12 +30,14 @@ Requires-Dist: Z0Z_tools
 Requires-Dist: autoflake
 Requires-Dist: python_minifier
 Requires-Dist: tomli
+Requires-Dist: typing-extensions
 Provides-Extra: testing
 Requires-Dist: mypy; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
 Requires-Dist: pyupgrade; extra == "testing"
+Requires-Dist: setuptools-scm; extra == "testing"
 Requires-Dist: trove_classifiers; extra == "testing"
 Dynamic: license-file
 

{asttoolkit-0.3.7 → asttoolkit-0.4.0}/astToolkit/_astTypes.py

@@ -51,8 +51,9 @@ hasDOTcontext_expr: typing_TypeAlias = ast.withitem
 hasDOTconversion: typing_TypeAlias = ast.FormattedValue
 hasDOTctx: typing_TypeAlias = ast.Attribute | ast.List | ast.Name | ast.Starred | ast.Subscript | ast.Tuple
 hasDOTdecorator_list: typing_TypeAlias = ast.AsyncFunctionDef | ast.ClassDef | ast.FunctionDef
-if sys.version_info >= (3, 13):
-    hasDOTdefault_value: typing_TypeAlias = ast.ParamSpec | ast.TypeVar | ast.TypeVarTuple
+match sys.version_info:
+    case version if version >= (3, 13):
+        hasDOTdefault_value: typing_TypeAlias = ast.ParamSpec | ast.TypeVar | ast.TypeVarTuple
 hasDOTdefaults: typing_TypeAlias = ast.arguments
 hasDOTelt: typing_TypeAlias = ast.GeneratorExp | ast.ListComp | ast.SetComp
 hasDOTelts: typing_TypeAlias = ast.List | ast.Set | ast.Tuple
@@ -117,10 +118,10 @@ hasDOTslice: typing_TypeAlias = ast.Subscript
 hasDOTstep: typing_TypeAlias = ast.Slice
 hasDOTsubject: typing_TypeAlias = ast.Match
 hasDOTtag: typing_TypeAlias = ast.TypeIgnore
+hasDOTtarget_expr: typing_TypeAlias = ast.AsyncFor | ast.comprehension | ast.For
 hasDOTtarget_Name: typing_TypeAlias = ast.NamedExpr
 hasDOTtarget_NameOrAttributeOrSubscript: typing_TypeAlias = ast.AnnAssign | ast.AugAssign
-hasDOTtarget_expr: typing_TypeAlias = ast.AsyncFor | ast.comprehension | ast.For
-hasDOTtarget: typing_TypeAlias = hasDOTtarget_Name | hasDOTtarget_NameOrAttributeOrSubscript | hasDOTtarget_expr
+hasDOTtarget: typing_TypeAlias = hasDOTtarget_expr | hasDOTtarget_Name | hasDOTtarget_NameOrAttributeOrSubscript
 hasDOTtargets: typing_TypeAlias = ast.Assign | ast.Delete
 hasDOTtest: typing_TypeAlias = ast.Assert | ast.If | ast.IfExp | ast.While
 hasDOTtype: typing_TypeAlias = ast.ExceptHandler
@@ -128,10 +129,10 @@ hasDOTtype_comment: typing_TypeAlias = ast.arg | ast.Assign | ast.AsyncFor | ast
 hasDOTtype_ignores: typing_TypeAlias = ast.Module
 hasDOTtype_params: typing_TypeAlias = ast.AsyncFunctionDef | ast.ClassDef | ast.FunctionDef | ast.TypeAlias
 hasDOTupper: typing_TypeAlias = ast.Slice
-hasDOTvalue_ConstantValueType: typing_TypeAlias = ast.Constant
 hasDOTvalue_boolOrNone: typing_TypeAlias = ast.MatchSingleton
+hasDOTvalue_ConstantValueType: typing_TypeAlias = ast.Constant
 hasDOTvalue_expr: typing_TypeAlias = ast.Assign | ast.Attribute | ast.AugAssign | ast.Await | ast.DictComp | ast.Expr | ast.FormattedValue | ast.keyword | ast.MatchValue | ast.NamedExpr | ast.Starred | ast.Subscript | ast.TypeAlias | ast.YieldFrom
 hasDOTvalue_exprOrNone: typing_TypeAlias = ast.AnnAssign | ast.Return | ast.Yield
-hasDOTvalue: typing_TypeAlias = hasDOTvalue_ConstantValueType | hasDOTvalue_boolOrNone | hasDOTvalue_expr | hasDOTvalue_exprOrNone
+hasDOTvalue: typing_TypeAlias = hasDOTvalue_boolOrNone | hasDOTvalue_ConstantValueType | hasDOTvalue_expr | hasDOTvalue_exprOrNone
 hasDOTvalues: typing_TypeAlias = ast.BoolOp | ast.Dict | ast.JoinedStr
 hasDOTvararg: typing_TypeAlias = ast.arguments

{asttoolkit-0.3.7 → asttoolkit-0.4.0}/astToolkit/_toolClassIsAndAttribute.py

@@ -72,7 +72,7 @@ class ClassIsAndAttribute:
         ...
 
     @staticmethod
-    def argsIs(astClass: type[hasDOTargs], attributeCondition: Callable[[ast.arguments], bool] | Callable[[Sequence[ast.expr]], bool] | Callable[[list[ast.arg]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTargs] | bool]:
+    def argsIs(astClass: type[hasDOTargs], attributeCondition: Callable[[ast.arguments], bool] | Callable[[list[ast.arg]], bool] | Callable[[Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTargs] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTargs] | bool:
             return isinstance(node, astClass) and attributeCondition(node.args)
@@ -626,7 +626,7 @@ class ClassIsAndAttribute:
         ...
 
     @staticmethod
-    def targetIs(astClass: type[hasDOTtarget], attributeCondition: Callable[[ast.Name], bool] | Callable[[ast.expr], bool] | Callable[[ast.Name | ast.Attribute | ast.Subscript], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTtarget] | bool]:
+    def targetIs(astClass: type[hasDOTtarget], attributeCondition: Callable[[ast.expr], bool] | Callable[[ast.Name], bool] | Callable[[ast.Name | ast.Attribute | ast.Subscript], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTtarget] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTtarget] | bool:
             return isinstance(node, astClass) and attributeCondition(node.target)
@@ -702,7 +702,7 @@ class ClassIsAndAttribute:
         ...
 
     @staticmethod
-    def valueIs(astClass: type[hasDOTvalue], attributeCondition: Callable[[ast.expr], bool] | Callable[[ConstantValueType], bool] | Callable[[bool], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTvalue] | bool]:
+    def valueIs(astClass: type[hasDOTvalue], attributeCondition: Callable[[ast.expr], bool] | Callable[[bool], bool] | Callable[[ConstantValueType], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTvalue] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTvalue] | bool:
             return isinstance(node, astClass) and node.value is not None and attributeCondition(node.value)

{asttoolkit-0.3.7 → asttoolkit-0.4.0}/astToolkit/_toolDOT.py

@@ -1,3 +1,4 @@
+# pyright: reportReturnType=false
 # ruff: noqa: F403, F405
 """This file is generated automatically, so changes to this file will be lost."""
 from astToolkit._astTypes import *
@@ -30,7 +31,7 @@ class DOT:
 
     @staticmethod
     def annotation(node: hasDOTannotation) -> ast.expr:
-        return node.annotation # pyright: ignore[reportReturnType]
+        return node.annotation
 
     @staticmethod
     @overload
@@ -44,7 +45,7 @@ class DOT:
 
     @staticmethod
     def arg(node: hasDOTarg) -> str:
-        return node.arg # pyright: ignore[reportReturnType]
+        return node.arg
 
     @staticmethod
     @overload
@@ -62,7 +63,7 @@ class DOT:
         ...
 
     @staticmethod
-    def args(node: hasDOTargs) -> ast.arguments | Sequence[ast.expr] | list[ast.arg]:
+    def args(node: hasDOTargs) -> ast.arguments | list[ast.arg] | Sequence[ast.expr]:
         return node.args
 
     @staticmethod
@@ -71,7 +72,7 @@ class DOT:
 
     @staticmethod
     def asname(node: hasDOTasname) -> str:
-        return node.asname # pyright: ignore[reportReturnType]
+        return node.asname
 
     @staticmethod
     def attr(node: hasDOTattr) -> str:
@@ -97,7 +98,7 @@ class DOT:
 
     @staticmethod
     def bound(node: hasDOTbound) -> ast.expr:
-        return node.bound # pyright: ignore[reportReturnType]
+        return node.bound
 
     @staticmethod
     def cases(node: hasDOTcases) -> Sequence[ast.match_case]:
@@ -105,7 +106,7 @@ class DOT:
 
     @staticmethod
     def cause(node: hasDOTcause) -> ast.expr:
-        return node.cause # pyright: ignore[reportReturnType]
+        return node.cause
 
     @staticmethod
     def cls(node: hasDOTcls) -> ast.expr:
@@ -134,7 +135,7 @@ class DOT:
 
         @staticmethod
         def default_value(node: hasDOTdefault_value) -> ast.expr:
-            return node.default_value # pyright: ignore[reportReturnType]
+            return node.default_value
 
     @staticmethod
     def defaults(node: hasDOTdefaults) -> Sequence[ast.expr]:
@@ -150,7 +151,7 @@ class DOT:
 
     @staticmethod
     def exc(node: hasDOTexc) -> ast.expr:
-        return node.exc # pyright: ignore[reportReturnType]
+        return node.exc
 
     @staticmethod
     def finalbody(node: hasDOTfinalbody) -> Sequence[ast.stmt]:
@@ -158,7 +159,7 @@ class DOT:
 
     @staticmethod
     def format_spec(node: hasDOTformat_spec) -> ast.expr:
-        return node.format_spec # pyright: ignore[reportReturnType]
+        return node.format_spec
 
     @staticmethod
     def func(node: hasDOTfunc) -> ast.expr:
@@ -170,7 +171,7 @@ class DOT:
 
     @staticmethod
     def guard(node: hasDOTguard) -> ast.expr:
-        return node.guard # pyright: ignore[reportReturnType]
+        return node.guard
 
     @staticmethod
     def handlers(node: hasDOThandlers) -> list[ast.ExceptHandler]:
@@ -212,7 +213,7 @@ class DOT:
 
     @staticmethod
     def keys(node: hasDOTkeys) -> Sequence[ast.expr]:
-        return node.keys # pyright: ignore[reportReturnType]
+        return node.keys
 
     @staticmethod
     def keywords(node: hasDOTkeywords) -> Sequence[ast.keyword]:
@@ -220,22 +221,22 @@ class DOT:
 
     @staticmethod
     def kind(node: hasDOTkind) -> str:
-        return node.kind # pyright: ignore[reportReturnType]
+        return node.kind
 
     @staticmethod
     def kw_defaults(node: hasDOTkw_defaults) -> Sequence[ast.expr]:
-        return node.kw_defaults # pyright: ignore[reportReturnType]
+        return node.kw_defaults
 
     @staticmethod
     def kwarg(node: hasDOTkwarg) -> ast.arg:
-        return node.kwarg # pyright: ignore[reportReturnType]
+        return node.kwarg
 
     @staticmethod
     def kwd_attrs(node: hasDOTkwd_attrs) -> list[str]:
         return node.kwd_attrs
 
     @staticmethod
-    def kwd_patterns(node: hasDOTkwd_patterns) -> list[ast.pattern]:
+    def kwd_patterns(node: hasDOTkwd_patterns) -> Sequence[ast.pattern]:
         return node.kwd_patterns
 
     @staticmethod
@@ -256,15 +257,15 @@ class DOT:
 
     @staticmethod
     def lower(node: hasDOTlower) -> ast.expr:
-        return node.lower # pyright: ignore[reportReturnType]
+        return node.lower
 
     @staticmethod
     def module(node: hasDOTmodule) -> str:
-        return node.module # pyright: ignore[reportReturnType]
+        return node.module
 
     @staticmethod
     def msg(node: hasDOTmsg) -> ast.expr:
-        return node.msg # pyright: ignore[reportReturnType]
+        return node.msg
 
     @staticmethod
     @overload
@@ -283,7 +284,7 @@ class DOT:
 
     @staticmethod
     def name(node: hasDOTname) -> ast.Name | str:
-        return node.name # pyright: ignore[reportReturnType]
+        return node.name
 
     @staticmethod
     @overload
@@ -328,7 +329,7 @@ class DOT:
 
     @staticmethod
     def optional_vars(node: hasDOToptional_vars) -> ast.expr:
-        return node.optional_vars # pyright: ignore[reportReturnType]
+        return node.optional_vars
 
     @staticmethod
     @overload
@@ -356,7 +357,7 @@ class DOT:
 
     @staticmethod
     def pattern(node: hasDOTpattern) -> ast.pattern:
-        return node.pattern # pyright: ignore[reportReturnType]
+        return node.pattern
 
     @staticmethod
     def patterns(node: hasDOTpatterns) -> Sequence[ast.pattern]:
@@ -368,7 +369,7 @@ class DOT:
 
     @staticmethod
     def rest(node: hasDOTrest) -> str:
-        return node.rest # pyright: ignore[reportReturnType]
+        return node.rest
 
     @staticmethod
     @overload
@@ -382,7 +383,7 @@ class DOT:
 
     @staticmethod
     def returns(node: hasDOTreturns) -> ast.expr:
-        return node.returns # pyright: ignore[reportReturnType]
+        return node.returns
 
     @staticmethod
     def right(node: hasDOTright) -> ast.expr:
@@ -398,7 +399,7 @@ class DOT:
 
     @staticmethod
     def step(node: hasDOTstep) -> ast.expr:
-        return node.step # pyright: ignore[reportReturnType]
+        return node.step
 
     @staticmethod
     def subject(node: hasDOTsubject) -> ast.expr:
@@ -424,7 +425,7 @@ class DOT:
         ...
 
     @staticmethod
-    def target(node: hasDOTtarget) -> ast.Name | ast.expr | (ast.Name | ast.Attribute | ast.Subscript):
+    def target(node: hasDOTtarget) -> ast.expr | ast.Name | (ast.Name | ast.Attribute | ast.Subscript):
         return node.target
 
     @staticmethod
@@ -437,11 +438,11 @@ class DOT:
 
     @staticmethod
     def type(node: hasDOTtype) -> ast.expr:
-        return node.type # pyright: ignore[reportReturnType]
+        return node.type
 
     @staticmethod
     def type_comment(node: hasDOTtype_comment) -> str:
-        return node.type_comment # pyright: ignore[reportReturnType]
+        return node.type_comment
 
     @staticmethod
     def type_ignores(node: hasDOTtype_ignores) -> list[ast.TypeIgnore]:
@@ -453,7 +454,7 @@ class DOT:
 
     @staticmethod
     def upper(node: hasDOTupper) -> ast.expr:
-        return node.upper # pyright: ignore[reportReturnType]
+        return node.upper
 
     @staticmethod
     @overload
@@ -476,7 +477,7 @@ class DOT:
         ...
 
     @staticmethod
-    def value(node: hasDOTvalue) -> ast.expr | ConstantValueType | bool:
+    def value(node: hasDOTvalue) -> ast.expr | bool | ConstantValueType:
         return node.value
 
     @staticmethod
@@ -485,4 +486,4 @@ class DOT:
 
     @staticmethod
     def vararg(node: hasDOTvararg) -> ast.arg:
-        return node.vararg # pyright: ignore[reportReturnType]
+        return node.vararg

{asttoolkit-0.3.7 → asttoolkit-0.4.0}/astToolkit/_toolMake.py

@@ -4,7 +4,8 @@ from astToolkit import (
 	identifierDotAttribute,
 )
 from collections.abc import Sequence
-from typing import overload, Unpack
+from typing import overload
+from typing_extensions import Unpack
 import ast
 import sys
 
@@ -116,8 +117,8 @@ class Make:
         return ast.comprehension(target=target, iter=iter, ifs=list(ifs), is_async=is_async)
 
     @staticmethod
-    def Constant(value: ConstantValueType, **keywordArguments: Unpack[ast_attributes_type_comment]) -> ast.Constant:
-        return ast.Constant(value=value, kind=None, **keywordArguments) # pyright: ignore[reportArgumentType]
+    def Constant(value: ConstantValueType, kind: str | None=None, **keywordArguments: Unpack[ast_attributes]) -> ast.Constant:
+        return ast.Constant(value=value, kind=kind, **keywordArguments) # pyright: ignore[reportArgumentType]
 
     @staticmethod
     def Continue(**keywordArguments: Unpack[ast_attributes]) -> ast.Continue:
@@ -188,12 +189,12 @@ class Make:
         return ast.IfExp(test=test, body=body, orelse=orElse, **keywordArguments)
 
     @staticmethod
-    def Import(moduleWithLogicalPath: identifierDotAttribute, asName: str | None=None, **keywordArguments: Unpack[ast_attributes]) -> ast.Import:
-        return ast.Import(names=[Make.alias(moduleWithLogicalPath, asName)], **keywordArguments)
+    def Import(dotModule: identifierDotAttribute, asName: str | None=None, **keywordArguments: Unpack[ast_attributes]) -> ast.Import:
+        return ast.Import(names=[Make.alias(dotModule, asName)], **keywordArguments)
 
     @staticmethod
-    def ImportFrom(module: str, list_alias: list[ast.alias], **keywordArguments: Unpack[ast_attributes]) -> ast.ImportFrom:
-        return ast.ImportFrom(module=module, names=list_alias, level=0, **keywordArguments)
+    def ImportFrom(module: str | None, list_alias: list[ast.alias], level: int=0, **keywordArguments: Unpack[ast_attributes]) -> ast.ImportFrom:
+        return ast.ImportFrom(module=module, names=list_alias, level=level, **keywordArguments)
 
     @staticmethod
     def Interactive(body: Sequence[ast.stmt]) -> ast.Interactive:

{asttoolkit-0.3.7 → asttoolkit-0.4.0}/astToolkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astToolkit
-Version: 0.3.7
+Version: 0.4.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
@@ -30,12 +30,14 @@ Requires-Dist: Z0Z_tools
 Requires-Dist: autoflake
 Requires-Dist: python_minifier
 Requires-Dist: tomli
+Requires-Dist: typing-extensions
 Provides-Extra: testing
 Requires-Dist: mypy; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
 Requires-Dist: pyupgrade; extra == "testing"
+Requires-Dist: setuptools-scm; extra == "testing"
 Requires-Dist: trove_classifiers; extra == "testing"
 Dynamic: license-file
 

{asttoolkit-0.3.7 → asttoolkit-0.4.0}/astToolkit.egg-info/requires.txt

@@ -2,6 +2,7 @@ Z0Z_tools
 autoflake
 python_minifier
 tomli
+typing-extensions
 
 [testing]
 mypy
@@ -9,4 +10,5 @@ pytest
 pytest-cov
 pytest-xdist
 pyupgrade
+setuptools-scm
 trove_classifiers

{asttoolkit-0.3.7 → asttoolkit-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "astToolkit"
-version = "0.3.7"
+version = "0.4.0"
 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 = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.12"
@@ -43,13 +43,14 @@ classifiers = [
   "Topic :: Software Development :: Libraries :: Python Modules",
   "Typing :: Typed",]
 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 = ["Z0Z_tools", "autoflake", "python_minifier", "tomli"]
+dependencies = ["Z0Z_tools", "autoflake", "python_minifier", "tomli", "typing-extensions"]
 optional-dependencies = { testing = [
   "mypy",
   "pytest",
   "pytest-cov",
   "pytest-xdist",
   "pyupgrade",
+  "setuptools-scm",
   "trove_classifiers",] }
 
 [build-system]

{asttoolkit-0.3.7 → asttoolkit-0.4.0}/tests/test_joinClassmethod.py

@@ -1,33 +1,21 @@
-import ast
-import pytest
-from collections.abc import Callable
-
-from astToolkit import Make
+from astToolkit import ast_attributes, Make
 from astToolkit._joinClassmethod import (
-    Add,
-    BitAnd,
-    BitOr,
-    BitXor,
-    Div,
-    FloorDiv,
-    LShift,
-    MatMult,
-    Mod,
-    Mult,
-    Pow,
-    RShift,
-    Sub,
+	Add, BitAnd, BitOr, BitXor, Div, FloorDiv, LShift, MatMult, Mod, Mult, Pow, RShift, Sub,
 )
+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 = {"lineno": 3, "col_offset": 8, "end_lineno": 3, "end_col_offset": 12}
-keyword_arguments_set_B = {"lineno": 17, "col_offset": 19, "end_lineno": 17, "end_col_offset": 25}
+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: dict) -> ast.expr:
+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)
@@ -59,8 +47,8 @@ list_join_implementation_and_ast_operator_pairs = [
     (Sub, ast.Sub),
 ]
 
-list_join_method_test_scenarios_params = []
-raw_scenarios = [
+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], {}),
@@ -86,8 +74,8 @@ raw_scenarios = [
 
 for scenario_id, expressions, kwargs in raw_scenarios:
     # Create a builder that captures the specific expressions and kwargs for this scenario
-    builder = lambda op_type, bound_expressions=expressions, bound_kwargs=kwargs: \
-        construct_expected_ast_node(op_type, bound_expressions, bound_kwargs)
+    def builder(op_type: type[ast.operator], bound_expressions: list[ast.expr] = expressions, bound_kwargs: ast_attributes = kwargs):
+        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)
     )
@@ -100,11 +88,12 @@ def test_join_method(
     ast_operator_type: type[ast.operator],
     scenario_identifier: str,
     expressions_for_join_method: list[ast.expr],
-    keyword_arguments_for_join_method: dict,
-    expected_ast_constructor: Callable
+    keyword_arguments_for_join_method: ast_attributes,
+    expected_ast_constructor: Callable[[type[ast.operator]], ast.expr]
 
 ):
-    actual_ast_node = JoinImplementerClass.join(expressions_for_join_method, **keyword_arguments_for_join_method)
+    join_method = getattr(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)