tessl/pypi-flask

A simple framework for building complex web applications.

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview

Eval results

Files

Templates

Name: tessl/pypi-flask
Author: tessl

Flask uses Jinja2 as its template engine, providing powerful template rendering capabilities with template inheritance, macros, filters, and automatic escaping for security.

Capabilities

Template Rendering Functions

Functions for rendering templates with context data.

def render_template(template_name_or_list: str | list[str], **context) -> str:
    """
    Render a template with the given context.
    
    Args:
        template_name_or_list: Template filename or list of template names
        **context: Template variables
        
    Returns:
        Rendered template as string
        
    Raises:
        TemplateNotFound: If template file doesn't exist
    """

def render_template_string(source: str, **context) -> str:
    """
    Render a template from a string source.
    
    Args:
        source: Template source code as string
        **context: Template variables
        
    Returns:
        Rendered template as string
    """

def stream_template(template_name_or_list: str | list[str], **context) -> Iterator[str]:
    """
    Stream a template as an iterator of strings.
    
    Args:
        template_name_or_list: Template filename or list of template names
        **context: Template variables
        
    Yields:
        Template chunks as strings
    """

def stream_template_string(source: str, **context) -> Iterator[str]:
    """
    Stream a template from string source as an iterator.
    
    Args:
        source: Template source code as string
        **context: Template variables
        
    Yields:
        Template chunks as strings
    """

Template Context Processing

Decorators and methods for adding variables to template context.

def context_processor(self, f: Callable) -> Callable:
    """
    Decorator to register a template context processor.
    
    Args:
        f: Function that returns dict of context variables
        
    Returns:
        The original function
    """

def update_template_context(self, context: dict[str, Any]) -> None:
    """
    Update template context with additional variables.
    
    Args:
        context: Context dictionary to update
    """

Template Filters

Functions for registering custom template filters.

def template_filter(self, name: str | None = None) -> Callable:
    """
    Decorator to register a template filter.
    
    Args:
        name: Filter name (defaults to function name)
        
    Returns:
        Decorator function
    """

def add_template_filter(self, f: Callable, name: str | None = None) -> None:
    """
    Register a template filter function.
    
    Args:
        f: Filter function
        name: Filter name (defaults to function name)
    """

Template Tests

Functions for registering custom template tests.

def template_test(self, name: str | None = None) -> Callable:
    """
    Decorator to register a template test.
    
    Args:
        name: Test name (defaults to function name)
        
    Returns:
        Decorator function
    """

def add_template_test(self, f: Callable, name: str | None = None) -> None:
    """
    Register a template test function.
    
    Args:
        f: Test function
        name: Test name (defaults to function name)
    """

Template Globals

Functions for registering global template functions.

def template_global(self, name: str | None = None) -> Callable:
    """
    Decorator to register a template global function.
    
    Args:
        name: Global name (defaults to function name)
        
    Returns:
        Decorator function
    """

def add_template_global(self, f: Callable, name: str | None = None) -> None:
    """
    Register a template global function.
    
    Args:
        f: Global function
        name: Global name (defaults to function name)
    """

Template Environment

Access to the Jinja2 environment for advanced customization.

class Flask:
    jinja_env: Environment  # Jinja2 environment instance
    
    def create_jinja_environment(self) -> Environment:
        """
        Create the Jinja2 environment.
        
        Returns:
            Configured Jinja2 environment
        """
    
    def select_jinja_autoescape(self, filename: str) -> bool:
        """
        Determine if autoescape should be enabled for a template.
        
        Args:
            filename: Template filename
            
        Returns:
            True if autoescape should be enabled
        """

Usage Examples

Basic Template Rendering

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def home():
    return render_template('index.html', title='Home Page')

@app.route('/user/<name>')
def user_profile(name):
    user_data = {
        'name': name,
        'email': f'{name}@example.com',
        'joined': '2023-01-01'
    }
    return render_template('user.html', user=user_data)

@app.route('/posts')
def posts():
    posts = [
        {'title': 'First Post', 'content': 'Hello World'},
        {'title': 'Second Post', 'content': 'Flask is great'}
    ]
    return render_template('posts.html', posts=posts)

Template with Context Variables

from flask import Flask, render_template
from datetime import datetime

app = Flask(__name__)

@app.route('/dashboard')
def dashboard():
    context = {
        'user': {
            'name': 'John Doe',
            'role': 'admin',
            'last_login': datetime.now()
        },
        'stats': {
            'total_users': 1250,
            'active_sessions': 45,
            'system_status': 'healthy'
        },
        'navigation': [
            {'name': 'Dashboard', 'url': '/dashboard'},
            {'name': 'Users', 'url': '/users'},
            {'name': 'Settings', 'url': '/settings'}
        ]
    }
    
    return render_template('dashboard.html', **context)

Template Inheritance Example

Base template (templates/base.html):

<!DOCTYPE html>
<html>
<head>
    <title>{% block title %}{% endblock %} - My App</title>
    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
</head>
<body>
    <header>
        <nav>
            <a href="{{ url_for('home') }}">Home</a>
            <a href="{{ url_for('about') }}">About</a>
        </nav>
    </header>
    
    <main>
        {% block content %}{% endblock %}
    </main>
    
    <footer>
        <p>&copy; 2023 My App</p>
    </footer>
</body>
</html>

Child template (templates/page.html):

{% extends "base.html" %}

{% block title %}{{ page_title }}{% endblock %}

{% block content %}
<h1>{{ page_title }}</h1>
<p>{{ page_content }}</p>
{% endblock %}

Custom Template Filters

from flask import Flask, render_template
from datetime import datetime

app = Flask(__name__)

@app.template_filter('dateformat')
def dateformat_filter(value, format='%Y-%m-%d'):
    """Format a datetime object."""
    if value is None:
        return ''
    return value.strftime(format)

@app.template_filter('currency')
def currency_filter(value):
    """Format a number as currency."""
    return f'${value:,.2f}'

# Alternative registration method
def reverse_filter(s):
    """Reverse a string."""
    return s[::-1]

app.add_template_filter(reverse_filter, 'reverse')

@app.route('/formatted')
def formatted_data():
    data = {
        'date': datetime.now(),
        'price': 1234.56,
        'text': 'Hello World'
    }
    return render_template('formatted.html', **data)

Template using filters (templates/formatted.html):

<p>Date: {{ date | dateformat('%B %d, %Y') }}</p>
<p>Price: {{ price | currency }}</p>
<p>Reversed: {{ text | reverse }}</p>

Custom Template Tests

from flask import Flask, render_template

app = Flask(__name__)

@app.template_test('even')
def is_even(n):
    """Test if a number is even."""
    return n % 2 == 0

@app.template_test('admin')
def is_admin(user):
    """Test if user is admin."""
    return user.get('role') == 'admin'

@app.route('/users')
def users():
    users = [
        {'name': 'John', 'role': 'admin', 'id': 1},
        {'name': 'Jane', 'role': 'user', 'id': 2},
        {'name': 'Bob', 'role': 'user', 'id': 3}
    ]
    return render_template('users.html', users=users)

Template using tests (templates/users.html):

{% for user in users %}
    <div class="user {% if user.id is even %}even{% else %}odd{% endif %}">
        {{ user.name }}
        {% if user is admin %}
            <span class="badge">Admin</span>
        {% endif %}
    </div>
{% endfor %}

Template Globals

from flask import Flask, render_template, url_for
import os

app = Flask(__name__)

@app.template_global('get_version')
def get_version():
    """Get application version."""
    return os.environ.get('APP_VERSION', '1.0.0')

@app.template_global('active_page')
def active_page(page):
    """Check if current page is active."""
    from flask import request
    return 'active' if request.endpoint == page else ''

@app.route('/about')
def about():
    return render_template('about.html')

Template using globals (templates/about.html):

<p>Version: {{ get_version() }}</p>
<nav>
    <a href="{{ url_for('home') }}" class="{{ active_page('home') }}">Home</a>
    <a href="{{ url_for('about') }}" class="{{ active_page('about') }}">About</a>
</nav>

Context Processors

from flask import Flask, render_template, g
from datetime import datetime

app = Flask(__name__)

@app.context_processor
def inject_globals():
    """Inject global variables into all templates."""
    return {
        'now': datetime.now(),
        'app_name': 'My Flask App',
        'year': datetime.now().year
    }

@app.context_processor
def inject_user():
    """Inject current user into templates."""
    # In real app, get from session or database
    user = getattr(g, 'user', None)
    return {'current_user': user}

@app.before_request
def load_user():
    # Simulate loading user
    g.user = {'name': 'John Doe', 'role': 'user'}

@app.route('/profile')
def profile():
    return render_template('profile.html')

Template using context variables (templates/profile.html):

<h1>{{ app_name }}</h1>
<p>Welcome, {{ current_user.name }}!</p>
<p>Current time: {{ now.strftime('%Y-%m-%d %H:%M:%S') }}</p>
<footer>&copy; {{ year }} {{ app_name }}</footer>

Streaming Templates

from flask import Flask, stream_template
import time

app = Flask(__name__)

@app.route('/stream')
def stream_data():
    def generate_data():
        """Generate data for streaming template."""
        for i in range(10):
            yield {'index': i, 'data': f'Item {i}'}
            time.sleep(0.5)  # Simulate processing time
    
    return stream_template('stream.html', items=generate_data())

@app.route('/large-report')
def large_report():
    # Stream large dataset
    def get_report_data():
        # Simulate large dataset
        for i in range(1000):
            yield {
                'id': i,
                'name': f'Record {i}',
                'value': i * 10
            }
    
    return stream_template('report.html', records=get_report_data())

Streaming template (templates/stream.html):

<!DOCTYPE html>
<html>
<head>
    <title>Streaming Data</title>
</head>
<body>
    <h1>Live Data Stream</h1>
    <ul>
    {% for item in items %}
        <li>{{ item.index }}: {{ item.data }}</li>
        {% if loop.index % 5 == 0 %}
            <!-- Flush every 5 items -->
        {% endif %}
    {% endfor %}
    </ul>
</body>
</html>

Template Security and Escaping

from flask import Flask, render_template_string, Markup

app = Flask(__name__)

@app.route('/safe')
def safe_content():
    user_input = '<script>alert("XSS")</script>'
    safe_html = '<strong>Safe HTML</strong>'
    
    template = '''
    <p>User input (escaped): {{ user_input }}</p>
    <p>Safe HTML (marked safe): {{ safe_html | safe }}</p>
    <p>Or use Markup: {{ markup_html }}</p>
    '''
    
    return render_template_string(
        template,
        user_input=user_input,
        safe_html=safe_html,
        markup_html=Markup(safe_html)
    )

@app.template_filter('safe_html')
def safe_html_filter(html):
    """Custom filter to mark HTML as safe."""
    # In real app, sanitize HTML first
    return Markup(html)

Install with Tessl CLI