astToolkit 0.3.4__tar.gz → 0.3.5__tar.gz

{asttoolkit-0.3.4 → asttoolkit-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astToolkit
-Version: 0.3.4
+Version: 0.3.5
 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
@@ -17,8 +17,6 @@ Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Typing :: Typed

{asttoolkit-0.3.4 → asttoolkit-0.3.5}/astToolkit/_astTypes.py

@@ -1,19 +1,32 @@
 """This file is generated automatically, so changes to this file will be lost."""
+from types import EllipsisType, NotImplementedType
 from typing import Any, TypeAlias as typing_TypeAlias, TypedDict, TypeVar as typing_TypeVar
 import ast
 import sys
+
 intORstr: typing_TypeAlias = Any
 intORstrORtype_params: typing_TypeAlias = Any
 intORtype_params: typing_TypeAlias = Any
+_Scalar: typing_TypeAlias = bool | bytes | complex | EllipsisType | float | int | None | NotImplementedType | range | str
+ScalarOrContainerOfScalar: typing_TypeAlias = _Scalar | frozenset['ScalarOrContainerOfScalar'] | tuple['ScalarOrContainerOfScalar', ...]
 木 = typing_TypeVar('木', bound=ast.AST, covariant=True)
 个 = typing_TypeVar('个', covariant=True)
 个return = typing_TypeVar('个return', covariant=True)
 
-class ast_attributes(TypedDict, total=False):
+class _attributes(TypedDict, total=False):
     lineno: int
     col_offset: int
+
+class ast_attributes(_attributes, total=False):
     end_lineno: int | None
     end_col_offset: int | None
+
+class ast_attributes_int(_attributes, total=False):
+    end_lineno: int
+    end_col_offset: int
+
+class ast_attributes_type_comment(ast_attributes, total=False):
+    type_comment: str | None
 hasDOTannotation_expr: typing_TypeAlias = ast.AnnAssign
 hasDOTannotation_exprOrNone: typing_TypeAlias = ast.arg
 hasDOTannotation: typing_TypeAlias = hasDOTannotation_expr | hasDOTannotation_exprOrNone
@@ -117,10 +130,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_Any: typing_TypeAlias = ast.Constant
+hasDOTvalue_ScalarOrContainerOfScalar: typing_TypeAlias = ast.Constant
 hasDOTvalue_boolOrNone: typing_TypeAlias = ast.MatchSingleton
 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_Any | hasDOTvalue_boolOrNone | hasDOTvalue_expr | hasDOTvalue_exprOrNone
+hasDOTvalue: typing_TypeAlias = hasDOTvalue_ScalarOrContainerOfScalar | hasDOTvalue_boolOrNone | hasDOTvalue_expr | hasDOTvalue_exprOrNone
 hasDOTvalues: typing_TypeAlias = ast.BoolOp | ast.Dict | ast.JoinedStr
 hasDOTvararg: typing_TypeAlias = ast.arguments

asttoolkit-0.3.5/astToolkit/_joinClassmethod.py

@@ -0,0 +1,586 @@
+"""This file is generated automatically, so changes to this file will be lost."""
+from astToolkit import ast_attributes, Make
+from collections.abc import Iterable
+from typing import Unpack
+import ast
+
+def operatorJoinMethod(ast_operator: type[ast.operator], expressions: Iterable[ast.expr], **keywordArguments: Unpack[ast_attributes]) -> ast.expr:
+    listExpressions: list[ast.expr] = list(expressions)
+    if not listExpressions:
+        listExpressions.append(Make.Constant('', **keywordArguments))
+    expressionsJoined: ast.expr = listExpressions[0]
+    for expression in listExpressions[1:]:
+        expressionsJoined = ast.BinOp(left=expressionsJoined, op=ast_operator(), right=expression, **keywordArguments)
+    return expressionsJoined
+
+class Add(ast.Add):
+    """Identical to the `ast` class but with a method, `join()`, that "joins" expressions using the `ast.BinOp` class."""
+
+    @classmethod
+    def join(cls, expressions: Iterable[ast.expr], **keywordArguments: Unpack[ast_attributes]) -> ast.expr:
+        """
+        Create a single `ast.expr` from a collection of `ast.expr` by forming nested `ast.BinOp`
+        that are logically "joined" using the `ast.operator` subclass. Like str.join() but for AST expressions.
+
+        Parameters
+        ----------
+        expressions : Iterable[ast.expr]
+            Collection of expressions to join.
+        **keywordArguments : ast._attributes
+
+        Returns
+        -------
+        joinedExpression : ast.expr
+            Single expression representing the joined expressions.
+
+        Examples
+        --------
+        Instead of manually constructing nested ast.BinOp structures:
+        ```
+        ast.BinOp(
+            left=ast.BinOp(
+                left=ast.Name('Crosby')
+                , op=ast.BitOr()
+                , right=ast.Name('Stills'))
+            , op=ast.BitOr()
+            , right=ast.Name('Nash')
+        )
+        ```
+
+        Simply use:
+        ```
+        astToolkit.BitOr().join([ast.Name('Crosby'), ast.Name('Stills'), ast.Name('Nash')])
+        ```
+
+        Both produce the same AST structure but the join() method eliminates the manual nesting.
+        Handles single expressions and empty iterables gracefully.
+        """
+        return operatorJoinMethod(cls, expressions, **keywordArguments)
+
+class BitAnd(ast.BitAnd):
+    """Identical to the `ast` class but with a method, `join()`, that "joins" expressions using the `ast.BinOp` class."""
+
+    @classmethod
+    def join(cls, expressions: Iterable[ast.expr], **keywordArguments: Unpack[ast_attributes]) -> ast.expr:
+        """
+        Create a single `ast.expr` from a collection of `ast.expr` by forming nested `ast.BinOp`
+        that are logically "joined" using the `ast.operator` subclass. Like str.join() but for AST expressions.
+
+        Parameters
+        ----------
+        expressions : Iterable[ast.expr]
+            Collection of expressions to join.
+        **keywordArguments : ast._attributes
+
+        Returns
+        -------
+        joinedExpression : ast.expr
+            Single expression representing the joined expressions.
+
+        Examples
+        --------
+        Instead of manually constructing nested ast.BinOp structures:
+        ```
+        ast.BinOp(
+            left=ast.BinOp(
+                left=ast.Name('Crosby')
+                , op=ast.BitOr()
+                , right=ast.Name('Stills'))
+            , op=ast.BitOr()
+            , right=ast.Name('Nash')
+        )
+        ```
+
+        Simply use:
+        ```
+        astToolkit.BitOr().join([ast.Name('Crosby'), ast.Name('Stills'), ast.Name('Nash')])
+        ```
+
+        Both produce the same AST structure but the join() method eliminates the manual nesting.
+        Handles single expressions and empty iterables gracefully.
+        """
+        return operatorJoinMethod(cls, expressions, **keywordArguments)
+
+class BitOr(ast.BitOr):
+    """Identical to the `ast` class but with a method, `join()`, that "joins" expressions using the `ast.BinOp` class."""
+
+    @classmethod
+    def join(cls, expressions: Iterable[ast.expr], **keywordArguments: Unpack[ast_attributes]) -> ast.expr:
+        """
+        Create a single `ast.expr` from a collection of `ast.expr` by forming nested `ast.BinOp`
+        that are logically "joined" using the `ast.operator` subclass. Like str.join() but for AST expressions.
+
+        Parameters
+        ----------
+        expressions : Iterable[ast.expr]
+            Collection of expressions to join.
+        **keywordArguments : ast._attributes
+
+        Returns
+        -------
+        joinedExpression : ast.expr
+            Single expression representing the joined expressions.
+
+        Examples
+        --------
+        Instead of manually constructing nested ast.BinOp structures:
+        ```
+        ast.BinOp(
+            left=ast.BinOp(
+                left=ast.Name('Crosby')
+                , op=ast.BitOr()
+                , right=ast.Name('Stills'))
+            , op=ast.BitOr()
+            , right=ast.Name('Nash')
+        )
+        ```
+
+        Simply use:
+        ```
+        astToolkit.BitOr().join([ast.Name('Crosby'), ast.Name('Stills'), ast.Name('Nash')])
+        ```
+
+        Both produce the same AST structure but the join() method eliminates the manual nesting.
+        Handles single expressions and empty iterables gracefully.
+        """
+        return operatorJoinMethod(cls, expressions, **keywordArguments)
+
+class BitXor(ast.BitXor):
+    """Identical to the `ast` class but with a method, `join()`, that "joins" expressions using the `ast.BinOp` class."""
+
+    @classmethod
+    def join(cls, expressions: Iterable[ast.expr], **keywordArguments: Unpack[ast_attributes]) -> ast.expr:
+        """
+        Create a single `ast.expr` from a collection of `ast.expr` by forming nested `ast.BinOp`
+        that are logically "joined" using the `ast.operator` subclass. Like str.join() but for AST expressions.
+
+        Parameters
+        ----------
+        expressions : Iterable[ast.expr]
+            Collection of expressions to join.
+        **keywordArguments : ast._attributes
+
+        Returns
+        -------
+        joinedExpression : ast.expr
+            Single expression representing the joined expressions.
+
+        Examples
+        --------
+        Instead of manually constructing nested ast.BinOp structures:
+        ```
+        ast.BinOp(
+            left=ast.BinOp(
+                left=ast.Name('Crosby')
+                , op=ast.BitOr()
+                , right=ast.Name('Stills'))
+            , op=ast.BitOr()
+            , right=ast.Name('Nash')
+        )
+        ```
+
+        Simply use:
+        ```
+        astToolkit.BitOr().join([ast.Name('Crosby'), ast.Name('Stills'), ast.Name('Nash')])
+        ```
+
+        Both produce the same AST structure but the join() method eliminates the manual nesting.
+        Handles single expressions and empty iterables gracefully.
+        """
+        return operatorJoinMethod(cls, expressions, **keywordArguments)
+
+class Div(ast.Div):
+    """Identical to the `ast` class but with a method, `join()`, that "joins" expressions using the `ast.BinOp` class."""
+
+    @classmethod
+    def join(cls, expressions: Iterable[ast.expr], **keywordArguments: Unpack[ast_attributes]) -> ast.expr:
+        """
+        Create a single `ast.expr` from a collection of `ast.expr` by forming nested `ast.BinOp`
+        that are logically "joined" using the `ast.operator` subclass. Like str.join() but for AST expressions.
+
+        Parameters
+        ----------
+        expressions : Iterable[ast.expr]
+            Collection of expressions to join.
+        **keywordArguments : ast._attributes
+
+        Returns
+        -------
+        joinedExpression : ast.expr
+            Single expression representing the joined expressions.
+
+        Examples
+        --------
+        Instead of manually constructing nested ast.BinOp structures:
+        ```
+        ast.BinOp(
+            left=ast.BinOp(
+                left=ast.Name('Crosby')
+                , op=ast.BitOr()
+                , right=ast.Name('Stills'))
+            , op=ast.BitOr()
+            , right=ast.Name('Nash')
+        )
+        ```
+
+        Simply use:
+        ```
+        astToolkit.BitOr().join([ast.Name('Crosby'), ast.Name('Stills'), ast.Name('Nash')])
+        ```
+
+        Both produce the same AST structure but the join() method eliminates the manual nesting.
+        Handles single expressions and empty iterables gracefully.
+        """
+        return operatorJoinMethod(cls, expressions, **keywordArguments)
+
+class FloorDiv(ast.FloorDiv):
+    """Identical to the `ast` class but with a method, `join()`, that "joins" expressions using the `ast.BinOp` class."""
+
+    @classmethod
+    def join(cls, expressions: Iterable[ast.expr], **keywordArguments: Unpack[ast_attributes]) -> ast.expr:
+        """
+        Create a single `ast.expr` from a collection of `ast.expr` by forming nested `ast.BinOp`
+        that are logically "joined" using the `ast.operator` subclass. Like str.join() but for AST expressions.
+
+        Parameters
+        ----------
+        expressions : Iterable[ast.expr]
+            Collection of expressions to join.
+        **keywordArguments : ast._attributes
+
+        Returns
+        -------
+        joinedExpression : ast.expr
+            Single expression representing the joined expressions.
+
+        Examples
+        --------
+        Instead of manually constructing nested ast.BinOp structures:
+        ```
+        ast.BinOp(
+            left=ast.BinOp(
+                left=ast.Name('Crosby')
+                , op=ast.BitOr()
+                , right=ast.Name('Stills'))
+            , op=ast.BitOr()
+            , right=ast.Name('Nash')
+        )
+        ```
+
+        Simply use:
+        ```
+        astToolkit.BitOr().join([ast.Name('Crosby'), ast.Name('Stills'), ast.Name('Nash')])
+        ```
+
+        Both produce the same AST structure but the join() method eliminates the manual nesting.
+        Handles single expressions and empty iterables gracefully.
+        """
+        return operatorJoinMethod(cls, expressions, **keywordArguments)
+
+class LShift(ast.LShift):
+    """Identical to the `ast` class but with a method, `join()`, that "joins" expressions using the `ast.BinOp` class."""
+
+    @classmethod
+    def join(cls, expressions: Iterable[ast.expr], **keywordArguments: Unpack[ast_attributes]) -> ast.expr:
+        """
+        Create a single `ast.expr` from a collection of `ast.expr` by forming nested `ast.BinOp`
+        that are logically "joined" using the `ast.operator` subclass. Like str.join() but for AST expressions.
+
+        Parameters
+        ----------
+        expressions : Iterable[ast.expr]
+            Collection of expressions to join.
+        **keywordArguments : ast._attributes
+
+        Returns
+        -------
+        joinedExpression : ast.expr
+            Single expression representing the joined expressions.
+
+        Examples
+        --------
+        Instead of manually constructing nested ast.BinOp structures:
+        ```
+        ast.BinOp(
+            left=ast.BinOp(
+                left=ast.Name('Crosby')
+                , op=ast.BitOr()
+                , right=ast.Name('Stills'))
+            , op=ast.BitOr()
+            , right=ast.Name('Nash')
+        )
+        ```
+
+        Simply use:
+        ```
+        astToolkit.BitOr().join([ast.Name('Crosby'), ast.Name('Stills'), ast.Name('Nash')])
+        ```
+
+        Both produce the same AST structure but the join() method eliminates the manual nesting.
+        Handles single expressions and empty iterables gracefully.
+        """
+        return operatorJoinMethod(cls, expressions, **keywordArguments)
+
+class MatMult(ast.MatMult):
+    """Identical to the `ast` class but with a method, `join()`, that "joins" expressions using the `ast.BinOp` class."""
+
+    @classmethod
+    def join(cls, expressions: Iterable[ast.expr], **keywordArguments: Unpack[ast_attributes]) -> ast.expr:
+        """
+        Create a single `ast.expr` from a collection of `ast.expr` by forming nested `ast.BinOp`
+        that are logically "joined" using the `ast.operator` subclass. Like str.join() but for AST expressions.
+
+        Parameters
+        ----------
+        expressions : Iterable[ast.expr]
+            Collection of expressions to join.
+        **keywordArguments : ast._attributes
+
+        Returns
+        -------
+        joinedExpression : ast.expr
+            Single expression representing the joined expressions.
+
+        Examples
+        --------
+        Instead of manually constructing nested ast.BinOp structures:
+        ```
+        ast.BinOp(
+            left=ast.BinOp(
+                left=ast.Name('Crosby')
+                , op=ast.BitOr()
+                , right=ast.Name('Stills'))
+            , op=ast.BitOr()
+            , right=ast.Name('Nash')
+        )
+        ```
+
+        Simply use:
+        ```
+        astToolkit.BitOr().join([ast.Name('Crosby'), ast.Name('Stills'), ast.Name('Nash')])
+        ```
+
+        Both produce the same AST structure but the join() method eliminates the manual nesting.
+        Handles single expressions and empty iterables gracefully.
+        """
+        return operatorJoinMethod(cls, expressions, **keywordArguments)
+
+class Mod(ast.Mod):
+    """Identical to the `ast` class but with a method, `join()`, that "joins" expressions using the `ast.BinOp` class."""
+
+    @classmethod
+    def join(cls, expressions: Iterable[ast.expr], **keywordArguments: Unpack[ast_attributes]) -> ast.expr:
+        """
+        Create a single `ast.expr` from a collection of `ast.expr` by forming nested `ast.BinOp`
+        that are logically "joined" using the `ast.operator` subclass. Like str.join() but for AST expressions.
+
+        Parameters
+        ----------
+        expressions : Iterable[ast.expr]
+            Collection of expressions to join.
+        **keywordArguments : ast._attributes
+
+        Returns
+        -------
+        joinedExpression : ast.expr
+            Single expression representing the joined expressions.
+
+        Examples
+        --------
+        Instead of manually constructing nested ast.BinOp structures:
+        ```
+        ast.BinOp(
+            left=ast.BinOp(
+                left=ast.Name('Crosby')
+                , op=ast.BitOr()
+                , right=ast.Name('Stills'))
+            , op=ast.BitOr()
+            , right=ast.Name('Nash')
+        )
+        ```
+
+        Simply use:
+        ```
+        astToolkit.BitOr().join([ast.Name('Crosby'), ast.Name('Stills'), ast.Name('Nash')])
+        ```
+
+        Both produce the same AST structure but the join() method eliminates the manual nesting.
+        Handles single expressions and empty iterables gracefully.
+        """
+        return operatorJoinMethod(cls, expressions, **keywordArguments)
+
+class Mult(ast.Mult):
+    """Identical to the `ast` class but with a method, `join()`, that "joins" expressions using the `ast.BinOp` class."""
+
+    @classmethod
+    def join(cls, expressions: Iterable[ast.expr], **keywordArguments: Unpack[ast_attributes]) -> ast.expr:
+        """
+        Create a single `ast.expr` from a collection of `ast.expr` by forming nested `ast.BinOp`
+        that are logically "joined" using the `ast.operator` subclass. Like str.join() but for AST expressions.
+
+        Parameters
+        ----------
+        expressions : Iterable[ast.expr]
+            Collection of expressions to join.
+        **keywordArguments : ast._attributes
+
+        Returns
+        -------
+        joinedExpression : ast.expr
+            Single expression representing the joined expressions.
+
+        Examples
+        --------
+        Instead of manually constructing nested ast.BinOp structures:
+        ```
+        ast.BinOp(
+            left=ast.BinOp(
+                left=ast.Name('Crosby')
+                , op=ast.BitOr()
+                , right=ast.Name('Stills'))
+            , op=ast.BitOr()
+            , right=ast.Name('Nash')
+        )
+        ```
+
+        Simply use:
+        ```
+        astToolkit.BitOr().join([ast.Name('Crosby'), ast.Name('Stills'), ast.Name('Nash')])
+        ```
+
+        Both produce the same AST structure but the join() method eliminates the manual nesting.
+        Handles single expressions and empty iterables gracefully.
+        """
+        return operatorJoinMethod(cls, expressions, **keywordArguments)
+
+class Pow(ast.Pow):
+    """Identical to the `ast` class but with a method, `join()`, that "joins" expressions using the `ast.BinOp` class."""
+
+    @classmethod
+    def join(cls, expressions: Iterable[ast.expr], **keywordArguments: Unpack[ast_attributes]) -> ast.expr:
+        """
+        Create a single `ast.expr` from a collection of `ast.expr` by forming nested `ast.BinOp`
+        that are logically "joined" using the `ast.operator` subclass. Like str.join() but for AST expressions.
+
+        Parameters
+        ----------
+        expressions : Iterable[ast.expr]
+            Collection of expressions to join.
+        **keywordArguments : ast._attributes
+
+        Returns
+        -------
+        joinedExpression : ast.expr
+            Single expression representing the joined expressions.
+
+        Examples
+        --------
+        Instead of manually constructing nested ast.BinOp structures:
+        ```
+        ast.BinOp(
+            left=ast.BinOp(
+                left=ast.Name('Crosby')
+                , op=ast.BitOr()
+                , right=ast.Name('Stills'))
+            , op=ast.BitOr()
+            , right=ast.Name('Nash')
+        )
+        ```
+
+        Simply use:
+        ```
+        astToolkit.BitOr().join([ast.Name('Crosby'), ast.Name('Stills'), ast.Name('Nash')])
+        ```
+
+        Both produce the same AST structure but the join() method eliminates the manual nesting.
+        Handles single expressions and empty iterables gracefully.
+        """
+        return operatorJoinMethod(cls, expressions, **keywordArguments)
+
+class RShift(ast.RShift):
+    """Identical to the `ast` class but with a method, `join()`, that "joins" expressions using the `ast.BinOp` class."""
+
+    @classmethod
+    def join(cls, expressions: Iterable[ast.expr], **keywordArguments: Unpack[ast_attributes]) -> ast.expr:
+        """
+        Create a single `ast.expr` from a collection of `ast.expr` by forming nested `ast.BinOp`
+        that are logically "joined" using the `ast.operator` subclass. Like str.join() but for AST expressions.
+
+        Parameters
+        ----------
+        expressions : Iterable[ast.expr]
+            Collection of expressions to join.
+        **keywordArguments : ast._attributes
+
+        Returns
+        -------
+        joinedExpression : ast.expr
+            Single expression representing the joined expressions.
+
+        Examples
+        --------
+        Instead of manually constructing nested ast.BinOp structures:
+        ```
+        ast.BinOp(
+            left=ast.BinOp(
+                left=ast.Name('Crosby')
+                , op=ast.BitOr()
+                , right=ast.Name('Stills'))
+            , op=ast.BitOr()
+            , right=ast.Name('Nash')
+        )
+        ```
+
+        Simply use:
+        ```
+        astToolkit.BitOr().join([ast.Name('Crosby'), ast.Name('Stills'), ast.Name('Nash')])
+        ```
+
+        Both produce the same AST structure but the join() method eliminates the manual nesting.
+        Handles single expressions and empty iterables gracefully.
+        """
+        return operatorJoinMethod(cls, expressions, **keywordArguments)
+
+class Sub(ast.Sub):
+    """Identical to the `ast` class but with a method, `join()`, that "joins" expressions using the `ast.BinOp` class."""
+
+    @classmethod
+    def join(cls, expressions: Iterable[ast.expr], **keywordArguments: Unpack[ast_attributes]) -> ast.expr:
+        """
+        Create a single `ast.expr` from a collection of `ast.expr` by forming nested `ast.BinOp`
+        that are logically "joined" using the `ast.operator` subclass. Like str.join() but for AST expressions.
+
+        Parameters
+        ----------
+        expressions : Iterable[ast.expr]
+            Collection of expressions to join.
+        **keywordArguments : ast._attributes
+
+        Returns
+        -------
+        joinedExpression : ast.expr
+            Single expression representing the joined expressions.
+
+        Examples
+        --------
+        Instead of manually constructing nested ast.BinOp structures:
+        ```
+        ast.BinOp(
+            left=ast.BinOp(
+                left=ast.Name('Crosby')
+                , op=ast.BitOr()
+                , right=ast.Name('Stills'))
+            , op=ast.BitOr()
+            , right=ast.Name('Nash')
+        )
+        ```
+
+        Simply use:
+        ```
+        astToolkit.BitOr().join([ast.Name('Crosby'), ast.Name('Stills'), ast.Name('Nash')])
+        ```
+
+        Both produce the same AST structure but the join() method eliminates the manual nesting.
+        Handles single expressions and empty iterables gracefully.
+        """
+        return operatorJoinMethod(cls, expressions, **keywordArguments)

{asttoolkit-0.3.4 → asttoolkit-0.3.5}/astToolkit/_theSSOT.py

@@ -6,12 +6,12 @@ import dataclasses
 
 # TODO some of this can move to toolFactory because of the unusual nature of this package.
 try:
-	packageNamePACKAGING: str = tomli_load(Path("../pyproject.toml").open('rb'))["project"]["name"]
+	identifierPackagePACKAGING: str = tomli_load(Path("pyproject.toml").open('rb'))["project"]["name"]
 except Exception:
-	packageNamePACKAGING = "astToolkit"
+	identifierPackagePACKAGING = "astToolkit"
 
 def getPathPackageINSTALLING() -> Path:
-	pathPackage: Path = Path(inspect_getfile(importlib_import_module(packageNamePACKAGING)))
+	pathPackage: Path = Path(inspect_getfile(importlib_import_module(identifierPackagePACKAGING)))
 	if pathPackage.is_file():
 		pathPackage = pathPackage.parent
 	return pathPackage
@@ -22,7 +22,7 @@ class PackageSettings:
 	fileExtension: str = dataclasses.field(default='.py', metadata={'evaluateWhen': 'installing'})
 	"""Default file extension for generated code files."""
 
-	packageName: str = dataclasses.field(default = packageNamePACKAGING, metadata={'evaluateWhen': 'packaging'})
+	packageName: str = dataclasses.field(default = identifierPackagePACKAGING, metadata={'evaluateWhen': 'packaging'})
 	"""Name of this package, used for import paths and configuration."""
 
 	pathPackage: Path = dataclasses.field(default_factory=getPathPackageINSTALLING, metadata={'evaluateWhen': 'installing'})