20. Custom Python REPL

Building a custom Python REPL (Read-Eval-Print Loop) can be an exciting project. It allows you to interact with Python code in an interactive, custom environment, potentially with additional features tailored to specific use cases (e.g., enhanced debugging, dynamic evaluation, or special commands). Here's how you can create a basic custom REPL:

Key Steps in Building a Custom REPL:

1. Read input from the user.

2. Evaluate the input using Python’s eval() or exec() functions.

3. Print the result of the evaluation.

4. Loop to allow continuous interaction until the user exits.

Below are some Python code snippets demonstrating the construction of a custom REPL. You can enhance it with additional features (such as custom commands, error handling, etc.) as needed.

1. Basic REPL Implementation

The simplest custom REPL would allow users to type in Python expressions and see the result immediately.

def custom_repl():
    print("Custom Python REPL. Type 'exit' to quit.")
    while True:
        try:
            # Read user input (Python code)
            user_input = input(">>> ")

            # Exit condition
            if user_input.lower() == 'exit':
                print("Exiting custom REPL.")
                break

            # Evaluate the expression and print the result
            result = eval(user_input)
            print(result)
        except Exception as e:
            # Handle any exceptions
            print(f"Error: {e}")

# Start the custom REPL
custom_repl()

Explanation:

• input(">>> "): Prompts the user for input.

• eval(user_input): Evaluates the user input as a Python expression and prints the result.

• Exit Command: The loop stops when the user types exit.

• Error Handling: Any syntax or runtime errors are caught and displayed.

2. Adding exec() for Statements and Functions

While eval() only handles expressions (e.g., 2 + 2), exec() can be used to execute statements (e.g., loops, function definitions). Here's an enhanced version:

def custom_repl_with_exec():
    print("Custom Python REPL with exec. Type 'exit' to quit.")
    while True:
        try:
            # Read user input
            user_input = input(">>> ")

            # Exit condition
            if user_input.lower() == 'exit':
                print("Exiting custom REPL.")
                break

            # Try evaluating the expression first
            try:
                result = eval(user_input)
                print(result)
            except Exception:
                # If it's not an expression, treat it as a statement
                exec(user_input)
        except Exception as e:
            print(f"Error: {e}")

# Start the enhanced REPL
custom_repl_with_exec()

Explanation:

• eval() is used for expressions (which return a value).

• exec() handles statements, like defining functions or classes.

• This version gives users more flexibility to run code that may involve both expressions and statements.

3. Customizing the REPL with Special Commands

You can introduce custom commands or features, such as a built-in function to show the current namespace or define new commands.

import builtins

def custom_repl_with_commands():
    print("Custom Python REPL with commands. Type 'exit' to quit.")
    
    # List of custom commands
    custom_commands = {
        'help': 'Shows this help message',
        'show_namespace': 'Displays the current variables in the REPL'
    }
    
    while True:
        try:
            # Read user input
            user_input = input(">>> ")

            # Exit condition
            if user_input.lower() == 'exit':
                print("Exiting custom REPL.")
                break
            elif user_input.lower() == 'help':
                # Show help message
                print("Available commands:")
                for command, description in custom_commands.items():
                    print(f"{command}: {description}")
            elif user_input.lower() == 'show_namespace':
                # Show current namespace
                print("Current namespace:", locals())
            else:
                # Evaluate regular Python expressions or statements
                try:
                    result = eval(user_input)
                    print(result)
                except Exception:
                    exec(user_input)
        except Exception as e:
            print(f"Error: {e}")

# Start the REPL with commands
custom_repl_with_commands()

Explanation:

• help: Displays a list of available commands.

• show_namespace: Prints out the current local variables in the REPL.

• The REPL can handle custom commands and still run normal Python code.

4. Implementing Custom Error Handling

For better usability, you can implement custom error handling, so the user is guided more effectively when errors occur.

def custom_repl_with_error_handling():
    print("Custom Python REPL with enhanced error handling. Type 'exit' to quit.")
    while True:
        try:
            # Read user input
            user_input = input(">>> ")

            # Exit condition
            if user_input.lower() == 'exit':
                print("Exiting custom REPL.")
                break

            # Try evaluating the expression first
            try:
                result = eval(user_input)
                print(result)
            except Exception as eval_error:
                # Handle eval exceptions
                print(f"Error in expression: {eval_error}")
                try:
                    exec(user_input)
                except Exception as exec_error:
                    print(f"Error in statement: {exec_error}")
        except Exception as e:
            print(f"Unexpected error: {e}")

# Start the REPL with error handling
custom_repl_with_error_handling()

Explanation:

• This implementation tries to evaluate the input as an expression first. If it fails, it attempts to execute it as a statement.

• If there are errors in either case, they are caught and printed separately, making it easier for the user to identify the issue.

5. Maintaining State Across Evaluations

A custom REPL can maintain state across evaluations by storing variables or functions defined in the session.

def custom_repl_with_state():
    print("Custom Python REPL with state. Type 'exit' to quit.")
    
    # Maintain a global namespace (state)
    global_namespace = {}

    while True:
        try:
            # Read user input
            user_input = input(">>> ")

            # Exit condition
            if user_input.lower() == 'exit':
                print("Exiting custom REPL.")
                break

            # Evaluate the input with global state
            try:
                result = eval(user_input, global_namespace)
                print(result)
            except Exception:
                # If it's not an expression, execute as statement
                exec(user_input, global_namespace)
        except Exception as e:
            print(f"Error: {e}")

# Start the custom REPL with state
custom_repl_with_state()

Explanation:

• The global_namespace dictionary is used to store and manage the state (i.e., variables and functions) across multiple evaluations.

• This ensures that variables or functions defined earlier in the session remain accessible in later interactions.

---

6. Custom REPL with Syntax Highlighting

If you're building a more advanced custom REPL, you may want to add syntax highlighting for a better user experience. Here's an example that uses pygments for syntax highlighting:

import struct
from pygments import highlight
from pygments.lexers import PythonLexer
from pygments.formatters import TerminalFormatter

def custom_repl_with_syntax_highlighting():
    print("Custom Python REPL with syntax highlighting. Type 'exit' to quit.")
    
    while True:
        try:
            # Read user input
            user_input = input(">>> ")

            # Exit condition
            if user_input.lower() == 'exit':
                print("Exiting custom REPL.")
                break

            # Syntax highlighting using Pygments
            highlighted_input = highlight(user_input, PythonLexer(), TerminalFormatter())
            print(highlighted_input)
            
            # Execute the input
            try:
                result = eval(user_input)
                print(result)
            except Exception:
                exec(user_input)
        except Exception as e:
            print(f"Error: {e}")

# Start the custom REPL with syntax highlighting
custom_repl_with_syntax_highlighting()

Explanation:

• pygments: A powerful library for syntax highlighting.

• highlight(): Used to highlight the input using the Python lexer and output formatted for the terminal.

---

Conclusion

With these snippets, you can start building a custom Python REPL tailored to your needs, whether it's for interactive coding, custom commands, error handling, or state management. By extending this foundation, you can create a REPL that offers a richer, more controlled experience.