google-pasta

0.2.0 · maintenance · verified Sun Mar 29

google-pasta is an AST-based Python refactoring library (version 0.2.0). It aims to enable robust Python source code refactoring through Abstract Syntax Tree (AST) modifications, useful for tasks like renaming modules, rewriting import statements, enforcing code style, or safely migrating code between APIs. The library is currently marked as 'Pre-Alpha' on PyPI and has a slow release cadence, with the last update in March 2020.

Warnings

gotcha The library operates under the assumption that the Python version for which the code is written is the same as the Python version running `pasta`. This is due to its reliance on the built-in `ast.parse` module, which can have version-specific behaviors.
Fix: Ensure your environment's Python version matches the target code's Python version. Be cautious with newer Python syntax features (e.g., f-strings) if `pasta`'s development predates their full support.
gotcha Changing indentation levels of code blocks is not directly supported, which can limit certain refactoring operations like extracting methods.
Fix: Be aware of this limitation when designing refactoring tools. For transformations requiring indentation changes, post-processing with a linter/formatter might be necessary.
gotcha Some Python features, such as the `global` keyword, are not fully supported, which can lead to incorrect transformations or parsing errors.
Fix: Test `pasta` thoroughly with codebases containing these unsupported features before relying on it for critical refactoring tasks.
gotcha The project's PyPI status is '2 - Pre-Alpha', indicating it is still experimental and not considered stable or production-ready by its maintainers.
Fix: Use with caution and thorough testing. Do not rely on it for mission-critical applications without extensive validation of its output.
gotcha Development is slow or stalled. The last PyPI release (0.2.0) was in March 2020, and the last reported code push activity was around late 2020. Open issues exist for modern Python syntax (e.g., f-strings parsing failures, Python 3.10 support), suggesting potential compatibility problems with newer Python versions.
Fix: Verify functionality with your specific Python version and syntax before use. Consider contributing to the project if you encounter issues or require newer feature support.

Install

pip install google-pasta Install with pip

Imports

parse

import pasta
src = 'def foo(): pass'
ast = pasta.parse(src)

dump

import pasta
src = 'def foo(): pass'
ast = pasta.parse(src)
reconstructed_src = pasta.dump(ast)

Quickstart

This quickstart demonstrates the core functionality of `google-pasta`: parsing Python source code into an AST and then dumping it back into a string. A key design goal is 'symmetry', meaning `pasta.dump(pasta.parse(src))` should equal the original source code.

import pasta

# Original source code string
original_code = """
def greet(name):
    print(f"Hello, {name}!")

greet("World")
"""

# Parse the source code into an AST
ast_tree = pasta.parse(original_code)

# (Optional) Modify the AST here, for example, renaming a function
# For simplicity, we're just parsing and dumping to demonstrate symmetry

# Dump the AST back into source code
reconstructed_code = pasta.dump(ast_tree)

# Verify symmetry (as per pasta's design goals)
assert original_code == reconstructed_code

print("Original Code:\n" + original_code)
print("Reconstructed Code:\n" + reconstructed_code)
print(f"Code matches after parse and dump: {original_code == reconstructed_code}")

view raw JSON →