astToolkit 0.3.4__tar.gz → 0.3.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astToolkit
-Version: 0.3.4
+Version: 0.3.6
 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
@@ -8,7 +8,7 @@ Project-URL: Donate, https://www.patreon.com/integrated
 Project-URL: Homepage, https://github.com/hunterhogan/astToolkit
 Project-URL: Issues, https://github.com/hunterhogan/astToolkit/issues
 Project-URL: Repository, https://github.com/hunterhogan/astToolkit.git
-Keywords: ast,abstract syntax tree,code generation,code transformation,ast-analysis,ast-manipulation,ast-traversal,ast-visitor,code-analysis,code-refactoring,static-analysis,python-ast,metaprogramming,visitor-pattern,typed-ast,type-safe,composable-apis,function-inlining,source-code-generation,ast-predicate
+Keywords: abstract syntax tree,ast,ast-analysis,ast-manipulation,ast-predicate,ast-traversal,ast-visitor,code generation,code transformation,code-analysis,code-refactoring,composable-apis,function-inlining,metaprogramming,python-ast,source-code-generation,static-analysis,type-safe,typed-ast,visitor-pattern
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -17,21 +17,19 @@ 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
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: Software Development :: Code Generators
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: Z0Z_tools
 Requires-Dist: autoflake
 Requires-Dist: python_minifier
 Requires-Dist: tomli
-Requires-Dist: Z0Z_tools
 Provides-Extra: testing
 Requires-Dist: mypy; extra == "testing"
 Requires-Dist: pytest; extra == "testing"

{asttoolkit-0.3.4 → asttoolkit-0.3.6}/astToolkit/__init__.py

@@ -28,7 +28,8 @@ from astToolkit._types import (
 	str_nameDOTname as str_nameDOTname,
 )
 
-from astToolkit._dumpFunctionDef import dump as dump
+# from astToolkit._dumpFunctionDef import dump as dump
+from astToolkit._dumpHandmade import dump as dump
 
 from astToolkit._toolkitNodeVisitor import (
 	NodeChanger as NodeChanger,

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

@@ -1,19 +1,31 @@
 """This file is generated automatically, so changes to this file will be lost."""
-from typing import Any, TypeAlias as typing_TypeAlias, TypedDict, TypeVar as typing_TypeVar
+from types import EllipsisType, NotImplementedType
+from typing import Any, TypeAlias as typing_TypeAlias, TypeVar as typing_TypeVar, TypedDict
 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 +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_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.6/astToolkit/_dumpHandmade.py

@@ -0,0 +1,91 @@
+from ast import AST, Constant, MatchSingleton
+
+def dump(
+    node, annotate_fields=True, include_attributes=False,
+    *,
+    indent=None, show_empty=False,
+):
+    """
+    Return a formatted dump of the tree in node.  This is mainly useful for
+    debugging purposes.  If annotate_fields is true (by default),
+    the returned string will show the names and the values for fields.
+    If annotate_fields is false, the result string will be more compact by
+    omitting unambiguous field names.  Attributes such as line
+    numbers and column offsets are not dumped by default.  If this is wanted,
+    include_attributes can be set to true.  If indent is a non-negative
+    integer or string, then the tree will be pretty-printed with that indent
+    level. None (the default) selects the single line representation.
+    If show_empty is False, then empty lists and fields that are None
+    will be omitted from the output for better readability.
+    """
+    def _format(node, level=0):
+        if indent_str is not None:
+            level += 1
+            prefix = '\n' + indent_str * level
+            sep = ',\n' + indent_str * level
+        else:
+            prefix = ''
+            sep = ', '
+        if isinstance(node, AST):
+            cls = type(node)
+            args = []
+            args_buffer = []
+            allsimple = True
+            keywords = annotate_fields
+            for name in node._fields:
+                try:
+                    value = getattr(node, name)
+                except AttributeError:
+                    keywords = True
+                    continue
+                if value is None and getattr(cls, name, ...) is None:
+                    if show_empty:
+                        args.append('%s=%s' % (name, value))
+                    keywords = True
+                    continue
+                elif (
+                    not show_empty
+                    and (value is None or value == [])
+                    # Special cases:
+                    # `Constant(value=None)` and `MatchSingleton(value=None)`
+                    and not isinstance(node, (Constant, MatchSingleton))
+                ):
+                    args_buffer.append(repr(value))
+                    continue
+                elif not keywords:
+                    args.extend(args_buffer)
+                    args_buffer = []
+                value_formatted, simple = _format(value, level)
+                allsimple = allsimple and simple
+                if keywords:
+                    args.append('%s=%s' % (name, value_formatted))
+                else:
+                    args.append(value_formatted)
+            if include_attributes and node._attributes:
+                for name_attributes in node._attributes:
+                    try:
+                        value_attributes = getattr(node, name_attributes)
+                    except AttributeError:
+                        continue
+                    if value_attributes is None and getattr(cls, name_attributes, ...) is None:
+                        continue
+                    value_attributes_formatted, simple = _format(value_attributes, level)
+                    allsimple = allsimple and simple
+                    args.append('%s=%s' % (name_attributes, value_attributes_formatted))
+            if allsimple and len(args) <= 3:
+                return ('%s(%s)' % (f"{node.__class__.__module__}.{node.__class__.__name__}", ', '.join(args)), not args)
+            return ('%s(%s%s)' % (f"{node.__class__.__module__}.{node.__class__.__name__}", prefix, sep.join(args)), False)
+        elif isinstance(node, list):
+            if not node:
+                return ('[]', True)
+            return '[%s%s]' % (prefix, sep.join(_format(x, level)[0] for x in node)), False
+        return (repr(node), True)
+
+    if not isinstance(node, AST):
+        raise TypeError('expected AST, got %r' % node.__class__.__name__)
+    if indent is not None and not isinstance(indent, str):
+        indent_str = ' ' * indent
+    else:
+        indent_str = indent
+    return _format(node)[0]
+

asttoolkit-0.3.6/astToolkit/_dumpHandmade.pyi

@@ -0,0 +1,43 @@
+from ast import AST
+from types import EllipsisType, NotImplementedType
+from typing import TypeAlias
+
+_Constant: TypeAlias = bool | bytes | complex | EllipsisType | float | int | None | NotImplementedType | range | str
+
+ConstantType: TypeAlias = _Constant | frozenset['ConstantType'] | tuple['ConstantType', ...]
+
+def dump(
+    node: AST,
+    annotate_fields: bool = ...,
+    include_attributes: bool = ...,
+    *,
+    indent: int | str | None = ...,
+    show_empty: bool = ...,
+) -> str:
+    def _format(node: ConstantType | AST | list[AST] | list[str], level: int = ...) -> tuple[str, bool]:
+        # Local variables in _format function
+        prefix: str
+        sep: str
+        cls: type[AST]
+        args: list[str]
+        args_buffer: list[str]
+        allsimple: bool
+        keywords: bool
+        
+        name: str
+        value: AST | list[AST] | list[str] | ConstantType | bool | bytes | complex | float | int | str
+        value_formatted: str
+        simple: bool
+
+        name_attributes: str
+        value_attributes: int | None
+        value_attributes_formatted: str
+
+        x: AST | str
+        
+        ...
+    
+    # Local variables in dump function
+    indent_str: str | None
+    
+    ...