tessl/pypi-prompt-toolkit

Library for building powerful interactive command lines in Python

—

Pending

Overview

Eval results

Files

Application Building

Name: tessl/pypi-prompt-toolkit
Author: tessl

Framework for building full-featured interactive terminal applications with event loops, layouts, and user interfaces. The Application class serves as the central coordinator managing all aspects of terminal interaction.

Capabilities

Application Class

The main Application class provides the core framework for interactive terminal applications, managing the event loop, input/output, layout rendering, and user interaction.

class Application:
    def __init__(
        self,
        layout=None,
        style=None,
        key_bindings=None,
        clipboard=None,
        full_screen=False,
        mouse_support=False,
        enable_page_navigation_bindings=None,
        color_depth=None,
        min_redraw_interval=0.04,
        max_render_postpone_time=0.01,
        refresh_interval=0.5,
        input=None,
        output=None
    ):
        """
        Create an Application instance.
        
        Parameters:
        - layout: Layout instance defining the UI structure
        - style: Style instance for visual formatting  
        - key_bindings: KeyBindings instance for keyboard handling
        - clipboard: Clipboard instance for copy/paste operations
        - full_screen: bool, whether to use full screen mode
        - mouse_support: bool, whether to enable mouse input
        - color_depth: ColorDepth, color support level
        - input: Input instance for reading user input
        - output: Output instance for terminal output
        """
        
    def run(self, pre_run=None, set_exception_handler=True):
        """
        Run the application synchronously.
        
        Parameters:
        - pre_run: Optional callable to execute before starting
        - set_exception_handler: bool, whether to set exception handler
        
        Returns:
        Application result value
        """
        
    async def run_async(self, pre_run=None, set_exception_handler=True):
        """
        Run the application asynchronously.
        
        Parameters:
        - pre_run: Optional async callable to execute before starting
        - set_exception_handler: bool, whether to set exception handler
        
        Returns:
        Application result value
        """
        
    def exit(self, result=None, exception=None, style=""):
        """
        Exit the application with optional result.
        
        Parameters:
        - result: Return value for the application
        - exception: Optional exception to raise
        - style: Exit style specification
        """
        
    def invalidate(self):
        """
        Invalidate the application for redraw.
        """
        
    def render_last(self):
        """
        Render the last frame again.
        """

Application Session Management

Functions for managing application context and accessing the current application instance.

def get_app():
    """
    Get the current Application instance.
    
    Returns:
    Current Application instance
    
    Raises:
    RuntimeError: If no application is running
    """

def get_app_or_none():
    """
    Get the current Application instance or None.
    
    Returns:
    Current Application instance or None if no app running
    """

def set_app(app):
    """
    Set the current Application instance.
    
    Parameters:
    - app: Application instance to set as current
    """

class AppSession:
    """
    Application session context manager.
    """
    def __init__(self, app, output=None):
        """
        Create application session.
        
        Parameters:
        - app: Application instance
        - output: Optional output instance
        """

def get_app_session():
    """
    Get the current application session.
    
    Returns:
    Current AppSession instance
    """

def create_app_session(app=None, input=None, output=None):
    """
    Create a new application session.
    
    Parameters:
    - app: Optional Application instance
    - input: Optional Input instance
    - output: Optional Output instance
    
    Returns:
    AppSession instance
    """

def create_app_session_from_tty():
    """
    Create application session from TTY.
    
    Returns:
    AppSession instance configured for TTY
    """

Terminal Operations

Functions for running operations within terminal context and managing terminal state.

def in_terminal(func=None):
    """
    Decorator for running function in terminal context.
    
    Parameters:
    - func: Function to wrap
    
    Returns:
    Decorated function or decorator
    """

def run_in_terminal(func, render_cli_done=False, in_executor=False):
    """
    Run function in terminal mode.
    
    Parameters:
    - func: Function to execute
    - render_cli_done: bool, whether to render completion message
    - in_executor: bool, whether to run in thread executor
    
    Returns:
    Function result
    """

Dummy Application

Test implementation for unit testing and development.

class DummyApplication(Application):
    """
    Dummy Application implementation for testing.
    """
    def __init__(self):
        """
        Create dummy application with minimal configuration.
        """

Usage Examples

Basic Application

from prompt_toolkit.application import Application
from prompt_toolkit.layout import Layout
from prompt_toolkit.layout.containers import HSplit
from prompt_toolkit.layout.controls import FormattedTextControl
from prompt_toolkit.key_binding import KeyBindings

# Create key bindings
bindings = KeyBindings()

@bindings.add('c-c')
def exit_app(event):
    event.app.exit()

@bindings.add('c-q')  
def quit_app(event):
    event.app.exit()

# Create layout
layout = Layout(
    HSplit([
        FormattedTextControl('Hello World!'),
        FormattedTextControl('Press Ctrl-C or Ctrl-Q to exit.')
    ])
)

# Create and run application
app = Application(
    layout=layout,
    key_bindings=bindings,
    full_screen=True
)

app.run()

Application with Mouse Support

from prompt_toolkit.application import Application
from prompt_toolkit.layout import Layout
from prompt_toolkit.layout.containers import HSplit, Window
from prompt_toolkit.layout.controls import FormattedTextControl

# Create layout with mouse-enabled components
layout = Layout(
    HSplit([
        Window(
            FormattedTextControl('Click anywhere to see mouse position'),
            height=3
        ),
        Window(
            FormattedTextControl('Mouse info will appear here'),
            height=1
        )
    ])
)

# Key bindings with mouse support
bindings = KeyBindings()

@bindings.add('c-c')
def exit_app(event):
    event.app.exit()

# Create application with mouse support
app = Application(
    layout=layout,
    key_bindings=bindings,
    mouse_support=True,
    full_screen=True
)

app.run()

Async Application

import asyncio
from prompt_toolkit.application import Application
from prompt_toolkit.layout import Layout
from prompt_toolkit.layout.containers import HSplit
from prompt_toolkit.layout.controls import FormattedTextControl

async def main():
    # Create layout
    layout = Layout(
        HSplit([
            FormattedTextControl('Async Application'),
            FormattedTextControl('Press Ctrl-C to exit')
        ])
    )
    
    # Key bindings
    bindings = KeyBindings()
    
    @bindings.add('c-c')
    def exit_app(event):
        event.app.exit()
    
    # Create and run async application
    app = Application(
        layout=layout,
        key_bindings=bindings,
        full_screen=True
    )
    
    result = await app.run_async()
    return result

# Run the async application
asyncio.run(main())

Application with Custom Input/Output

from prompt_toolkit.application import Application
from prompt_toolkit.input import create_pipe_input
from prompt_toolkit.output import create_output
from prompt_toolkit.layout import Layout
from prompt_toolkit.layout.controls import FormattedTextControl

# Create custom input/output
input_pipe = create_pipe_input()
output = create_output()

# Create application with custom I/O
app = Application(
    layout=Layout(FormattedTextControl('Custom I/O Application')),
    input=input_pipe,
    output=output
)

# Send input programmatically
input_pipe.send_text('Hello\n')

# Run application
app.run()

Install with Tessl CLI