astToolkit 0.3.2__tar.gz → 0.3.4__tar.gz

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

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

asttoolkit-0.3.4/astToolkit/__init__.py

@@ -0,0 +1,74 @@
+"""
+AST Toolkit for Python - A comprehensive utility library for AST manipulation and transformation
+
+The astToolkit package provides a powerful set of tools for working with Python's Abstract Syntax Tree (AST),
+enabling sophisticated code analysis, transformation, and generation. The toolkit is designed around a 
+composable architecture with specialized modules for different aspects of AST manipulation:
+
+Core Components:
+- NodeTourist/NodeChanger: AST traversal and transformation engines
+- Make: Factory methods for creating AST nodes with clean semantics
+- IfThis/Then: Predicate-based node matching and transformation
+- IngredientsFunction/IngredientsModule: Containers for storing code components with dependencies
+
+Tool Categories:
+- Antecedents: Be, ClassIsAndAttribute, IfThis
+- Actions: Make, Then
+- Modify antecedents and actions: DOT, Grab
+- AST Organization: LedgerOfImports - Manage import statements
+- Code Generation: extractFunctionDef, parseLogicalPath2astModule - Extract and parse code
+
+The toolkit enables developers to perform complex AST operations with semantically clear code,
+maintaining type safety and providing a declarative approach to code transformation.
+"""
+
+from astToolkit._astTypes import *  # noqa: F403
+
+from astToolkit._types import (
+	str_nameDOTname as str_nameDOTname,
+)
+
+from astToolkit._dumpFunctionDef import dump as dump
+
+from astToolkit._toolkitNodeVisitor import (
+	NodeChanger as NodeChanger,
+	NodeTourist as NodeTourist,
+)
+
+from astToolkit._toolBe import Be as Be
+from astToolkit._toolClassIsAndAttribute import ClassIsAndAttribute as ClassIsAndAttribute
+from astToolkit._toolDOT import DOT as DOT
+from astToolkit._toolGrab import Grab as Grab
+from astToolkit._toolMake import Make as Make
+from astToolkit._joinClassmethod import (
+    Add as Add,
+    BitAnd as BitAnd,
+    BitOr as BitOr,
+    BitXor as BitXor,
+    Div as Div,
+    FloorDiv as FloorDiv,
+    LShift as LShift,
+    MatMult as MatMult,
+    Mod as Mod,
+	Mult as Mult,
+    Pow as Pow,
+    RShift as RShift,
+    Sub as Sub,
+)
+
+from astToolkit._toolIfThis import IfThis as IfThis
+from astToolkit._toolThen import Then as Then
+
+from astToolkit._toolkitContainers import (
+	IngredientsFunction as IngredientsFunction,
+	IngredientsModule as IngredientsModule,
+	LedgerOfImports as LedgerOfImports,
+)
+
+from astToolkit._toolkitAST import (
+	astModuleToIngredientsFunction as astModuleToIngredientsFunction,
+	extractClassDef as extractClassDef,
+	extractFunctionDef as extractFunctionDef,
+	parseLogicalPath2astModule as parseLogicalPath2astModule,
+	parsePathFilename2astModule as parsePathFilename2astModule,
+)

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

@@ -1,5 +1,5 @@
 """This file is generated automatically, so changes to this file will be lost."""
-from typing import Any, TypeAlias as typing_TypeAlias, TypeVar as typing_TypeVar
+from typing import Any, TypeAlias as typing_TypeAlias, TypedDict, TypeVar as typing_TypeVar
 import ast
 import sys
 intORstr: typing_TypeAlias = Any
@@ -8,6 +8,12 @@ intORtype_params: typing_TypeAlias = Any
 木 = typing_TypeVar('木', bound=ast.AST, covariant=True)
 个 = typing_TypeVar('个', covariant=True)
 个return = typing_TypeVar('个return', covariant=True)
+
+class ast_attributes(TypedDict, total=False):
+    lineno: int
+    col_offset: int
+    end_lineno: int | None
+    end_col_offset: int | None
 hasDOTannotation_expr: typing_TypeAlias = ast.AnnAssign
 hasDOTannotation_exprOrNone: typing_TypeAlias = ast.arg
 hasDOTannotation: typing_TypeAlias = hasDOTannotation_expr | hasDOTannotation_exprOrNone

asttoolkit-0.3.4/astToolkit/_dumpFunctionDef.py

@@ -0,0 +1,76 @@
+from _ast import *
+
+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 is not None:
+            level += 1
+            prefix = '\n' + indent * level
+            sep = ',\n' + indent * 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:
+                    keywords = True
+                    continue
+                if not show_empty and (value is None or value == []) and (not isinstance(node, (Constant, MatchSingleton))):
+                    args_buffer.append(repr(value))
+                    continue
+                elif not keywords:
+                    args.extend(args_buffer)
+                    args_buffer = []
+                value, simple = _format(value, level)
+                allsimple = allsimple and simple
+                if keywords:
+                    args.append('%s=%s' % (name, value))
+                else:
+                    args.append(value)
+            if include_attributes and node._attributes:
+                for name in node._attributes:
+                    try:
+                        value = getattr(node, name)
+                    except AttributeError:
+                        continue
+                    if value is None and getattr(cls, name, ...) is None:
+                        continue
+                    value, simple = _format(value, level)
+                    allsimple = allsimple and simple
+                    args.append('%s=%s' % (name, value))
+            if allsimple and len(args) <= 3:
+                return ('%s(%s)' % ('ast.' + node.__class__.__name__, ', '.join(args)), not args)
+            return ('%s(%s%s)' % ('ast.' + 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 = ' ' * indent
+    return _format(node)[0]