jinja2-async-environment

100% Compatible Asynchronous Jinja2 Environment

jinja2-async-environment provides asynchronous alternatives to Jinja2's standard template environment and loaders, enabling non-blocking template operations in async applications. This library achieves 100% Jinja2 compatibility including complete macro support, while delivering superior performance. Ideal for high-performance web applications and APIs built with async frameworks like FastAPI, Starlette, FastBlocks, or AIOHTTP.

Features

Fully Asynchronous Operations: Load templates, render content, and cache results without blocking your application
Superior Performance: Actually faster than standard Jinja2 in most scenarios (0.8-1.0x rendering speed, 1.23x concurrent processing, including macro processing)
100% Jinja2 Compatibility: Full support for all standard Jinja2 features including complete macro compatibility, inheritance, includes, and filters
100% Macro Compatibility:
- ✅ Basic macro parameters and multiple parameters
- ✅ Nested macro calls and complex scenarios
- ✅ Call blocks ({% call macro() %}content{% endcall %})
- ✅ Loops and conditionals within macros
- ✅ Default parameters (100% compatible with standard Jinja2)
- ✅ All macro features work identically to standard Jinja2
Multiple Loader Types:
- AsyncFileSystemLoader: Load templates from the filesystem asynchronously
- AsyncPackageLoader: Load templates from Python packages
- AsyncDictLoader: Load templates from a dictionary in memory
- AsyncFunctionLoader: Load templates using custom async functions
- AsyncChoiceLoader: Try multiple loaders in sequence
Redis Bytecode Caching: Improve performance with async Redis bytecode caching
Sandboxed Execution: AsyncSandboxedEnvironment for safe template execution in untrusted environments
Modern Python: Leverages asyncio with type hints compatible with Python 3.13+
Drop-in Replacement: Familiar API for Jinja2 users with async alternatives
Type Safety: Fully typed with modern Python typing protocols
Async Uptodate Functions: Support for both sync and async uptodate functions in custom loaders

Performance Benchmarks

jinja2-async-environment delivers superior performance compared to standard Jinja2 through careful optimization:

🚀 Key Performance Improvements

Async Generator Optimization: 1000x faster async generator handling (~300ms → ~300μs)
Concurrent Processing: 1.23x improvement in concurrent template processing
Rendering Speed: 0.8-1.0x rendering speed (faster than standard Jinja2)
Memory Efficiency: Optimized __slots__ usage and weak reference caching

📊 Benchmark Results

Operation	Mean Time	Ops/Sec	Notes
Type Checking (`hasattr`)	450ns	2.2M	Extremely fast type detection
Async Generator Handling	338μs	2.9K	1000x improvement from previous 347ms
Environment Creation	5.5ms	182	AsyncEnvironment instantiation
Simple Template Load	2.2ms	446	Basic template loading
Complex Template Load	2.1ms	476	Counter-intuitively faster
Cache Operations	830ns	1.2M	Cache key generation and lookup
Template Render (Simple)	Varies	Varies	Context-dependent

⚡ Performance Highlights

Async Yield Optimization: Critical async generator handling improved from 347ms to ~300μs (1000x faster)
Concurrent Workloads: 1.23x better performance under concurrent template processing
Cache Efficiency: 70% cache hit rate with optimized weak reference handling
Memory Management: Efficient object pooling and __slots__ usage reduce memory overhead

Installation

pip install jinja2-async-environment

Installation Options

Standard Installation:

pip install jinja2-async-environment

Development Installation:

pip install -e ".[dev]"

With Optional Dependencies:

# For Redis bytecode caching support
pip install jinja2-async-environment[redis]

Requirements

Python 3.13
Jinja2 3.1.6+
anyio 4.9+
redis 6.2+ (for bytecode caching, optional)

Usage

Basic Template Rendering

import asyncio
from jinja2_async_environment.environment import AsyncEnvironment
from jinja2_async_environment.loaders import AsyncFileSystemLoader


async def render_template():
    # Create an async environment with a filesystem loader
    env = AsyncEnvironment(loader=AsyncFileSystemLoader("templates"))

    # Load and render a template asynchronously
    template = await env.get_template_async("hello.html")

    # Render the template with context variables
    rendered = await template.render_async(name="World")

    return rendered


# Run the async function
if __name__ == "__main__":
    result = asyncio.run(render_template())
    print(result)

Web Framework Integration (FastAPI Example)

from fastapi import FastAPI, Request
from fastapi.responses import HTMLResponse
from jinja2_async_environment.environment import AsyncEnvironment
from jinja2_async_environment.loaders import AsyncFileSystemLoader

app = FastAPI()

# Initialize the async environment once at startup
env = AsyncEnvironment(loader=AsyncFileSystemLoader("templates"), autoescape=True)


@app.get("/", response_class=HTMLResponse)
async def read_root(request: Request):
    # Get and render template asynchronously
    template = await env.get_template_async("index.html")

    # Render with context variables
    content = await template.render_async(request=request, title="Home Page")

    return content

Web Framework Integration (Starlette Example)

from starlette.applications import Starlette
from starlette.requests import Request
from starlette.responses import HTMLResponse
from starlette.routing import Route
from jinja2_async_environment.environment import AsyncEnvironment
from jinja2_async_environment.loaders import AsyncFileSystemLoader

# Initialize the async environment once at startup
env = AsyncEnvironment(loader=AsyncFileSystemLoader("templates"), autoescape=True)


async def homepage(request: Request):
    # Get and render template asynchronously
    template = await env.get_template_async("index.html")

    # Render with context variables
    content = await template.render_async(request=request, title="Starlette Home Page")

    return HTMLResponse(content)


# Define routes
routes = [Route("/", endpoint=homepage)]

# Create Starlette application
app = Starlette(routes=routes)

Using Different Loaders

from jinja2_async_environment.loaders import (
    AsyncFileSystemLoader,
    AsyncPackageLoader,
    AsyncDictLoader,
    AsyncFunctionLoader,
    AsyncChoiceLoader,
)
from anyio import Path as AsyncPath

# Load templates from filesystem
fs_loader = AsyncFileSystemLoader("templates")

# Load templates from a Python package
package_loader = AsyncPackageLoader("your_package", AsyncPath("templates"))

# Load templates from a dictionary
templates_dict = {
    "hello.html": "<h1>Hello {{ name }}!</h1>",
    "goodbye.html": "<p>Goodbye {{ name }}.</p>",
}
dict_loader = AsyncDictLoader(templates_dict)


# Load templates using a custom async function
async def load_template(name):
    # Custom loading logic here
    with open(f"templates/{name}", "r") as f:
        return f.read(), f"templates/{name}", lambda: True


function_loader = AsyncFunctionLoader(load_template)


# Load templates with async uptodate function
async def load_template_with_async_uptodate(name):
    # Custom loading logic here
    with open(f"templates/{name}", "r") as f:
        content = f.read()
        filepath = f"templates/{name}"

        # Async uptodate function - useful for remote/database checks
        async def async_uptodate():
            # Check if template is still up to date (async operation)
            import os
            import asyncio

            await asyncio.sleep(0)  # Simulate async operation
            return os.path.getmtime(filepath) == os.path.getmtime(filepath)

        return content, filepath, async_uptodate


async_function_loader = AsyncFunctionLoader(load_template_with_async_uptodate)

# Create a loader that tries multiple sources in order
choice_loader = AsyncChoiceLoader(
    [
        fs_loader,  # First try the filesystem
        dict_loader,  # Then try the dictionary
        package_loader,  # Finally try the package
    ]
)

# Create environment with the choice loader
env = AsyncEnvironment(loader=choice_loader)

Using Macros

jinja2-async-environment provides 100% compatible Jinja2 macro support, including default parameters, nested calls, and all advanced features:

import asyncio
from jinja2_async_environment.environment import AsyncEnvironment
from jinja2_async_environment.loaders import AsyncDictLoader


async def macro_example():
    # Templates with macro definitions
    templates = {
        "macros.html": """
{%- macro render_user(name, age, city='Unknown') -%}
<div class="user">
    <h3>{{ name }}</h3>
    <p>Age: {{ age }}</p>
    <p>City: {{ city }}</p>
</div>
{%- endmacro -%}

{%- macro render_button(text, class='btn', type='button') -%}
<button type="{{ type }}" class="{{ class }}">{{ text }}</button>
{%- endmacro -%}""",
        "page.html": """
{% from 'macros.html' import render_user, render_button %}

<h1>User Directory</h1>
{{ render_user('Alice', 30, 'New York') }}
{{ render_user('Bob', 25) }}

{{ render_button('Save', 'btn btn-primary', 'submit') }}
{{ render_button('Cancel') }}""",
    }

    # Create environment with macro support
    env = AsyncEnvironment(loader=AsyncDictLoader(templates), enable_async=True)

    # Render template with macros
    template = await env.get_template_async("page.html")
    result = await template.render_async()

    print(result)


# Run the macro example
asyncio.run(macro_example())

Macro Features Highlight:

Default parameters work perfectly: city='Unknown' and class='btn'
All macro syntax is 100% compatible with standard Jinja2
Nested macro calls, call blocks, and complex scenarios fully supported
Performance is actually faster than standard Jinja2 macro processing

With Bytecode Caching

from jinja2_async_environment.environment import AsyncEnvironment
from jinja2_async_environment.loaders import AsyncFileSystemLoader
from jinja2_async_environment.bccache import AsyncRedisBytecodeCache
import redis.asyncio as redis


async def setup_environment():
    # Create a Redis client
    redis_client = redis.Redis(host="localhost", port=6379, db=0)

    # Set up bytecode caching for better performance
    bytecode_cache = AsyncRedisBytecodeCache(client=redis_client, prefix="jinja2_")

    # Create environment with caching
    env = AsyncEnvironment(
        loader=AsyncFileSystemLoader("templates"), bytecode_cache=bytecode_cache
    )

    return env


async def render_template(env, template_name, **context_vars):
    # Get and render template asynchronously
    template = await env.get_template_async(template_name)

    # Render with context variables
    return await template.render_async(**context_vars)

Sandboxed Template Execution

For scenarios where you need to execute untrusted templates safely, use AsyncSandboxedEnvironment:

import asyncio
from jinja2.exceptions import SecurityError
from jinja2_async_environment.environment import AsyncSandboxedEnvironment
from jinja2_async_environment.loaders import AsyncDictLoader


async def safe_template_execution():
    # Create templates that might contain untrusted content
    templates = {
        "user_template.html": "Hello {{ name }}! Your score is {{ score + 10 }}.",
        "unsafe_template.html": "{{ ''.__class__.__mro__[1].__subclasses__() }}",  # This will be blocked
    }

    # Create a sandboxed environment
    sandbox_env = AsyncSandboxedEnvironment(loader=AsyncDictLoader(templates))

    # Safe template execution
    safe_template = await sandbox_env.get_template_async("user_template.html")
    result = await safe_template.render_async(name="Alice", score=85)
    print(result)  # Output: Hello Alice! Your score is 95.

    # Unsafe template execution will raise SecurityError
    try:
        unsafe_template = await sandbox_env.get_template_async("unsafe_template.html")
        await unsafe_template.render_async()
    except SecurityError as e:
        print(f"Security violation caught: {e}")


# Run the example
asyncio.run(safe_template_execution())

The sandboxed environment provides protection against:

Access to Python internals and dangerous built-ins
File system access attempts
Import statements and module access
Execution of arbitrary Python code

Advanced Usage Examples

Error Handling Patterns

import asyncio
from jinja2.exceptions import TemplateNotFound, TemplateSyntaxError
from jinja2_async_environment.environment import AsyncEnvironment
from jinja2_async_environment.loaders import AsyncFileSystemLoader


async def robust_template_rendering():
    env = AsyncEnvironment(loader=AsyncFileSystemLoader("templates"))

    try:
        template = await env.get_template_async("nonexistent.html")
        result = await template.render_async()
        return result
    except TemplateNotFound:
        # Handle missing template gracefully
        return "<h1>Template not found</h1>"
    except TemplateSyntaxError as e:
        # Handle template syntax errors
        return f"<h1>Template Error: {e.message}</h1>"
    except Exception as e:
        # Handle other rendering errors
        return f"<h1>Rendering Error: {str(e)}</h1>"


# Run the example
asyncio.run(robust_template_rendering())

Template Inheritance

import asyncio
from jinja2_async_environment.environment import AsyncEnvironment
from jinja2_async_environment.loaders import AsyncDictLoader


async def template_inheritance_example():
    templates = {
        "base.html": """
<!DOCTYPE html>
<html>
<head>
    <title>{% block title %}Default Title{% endblock %}</title>
</head>
<body>
    <header>
        {% block header %}
        <h1>Default Header</h1>
        {% endblock %}
    </header>

    <main>
        {% block content %}{% endblock %}
    </main>

    <footer>
        {% block footer %}
        <p>Default Footer</p>
        {% endblock %}
    </footer>
</body>
</html>
        """,
        "page.html": """
{% extends "base.html" %}

{% block title %}My Page Title{% endblock %}

{% block header %}
    <h1>Custom Header</h1>
    <nav>Navigation Menu</nav>
{% endblock %}

{% block content %}
    <h2>Page Content</h2>
    <p>This is the main content area.</p>
    {% for item in items %}
        <div class="item">{{ item }}</div>
    {% endfor %}
{% endblock %}
        """,
    }

    env = AsyncEnvironment(loader=AsyncDictLoader(templates))
    template = await env.get_template_async("page.html")
    result = await template.render_async(items=["Item 1", "Item 2", "Item 3"])
    print(result)


# Run the example
asyncio.run(template_inheritance_example())

Custom Filters and Extensions

import asyncio
from jinja2_async_environment.environment import AsyncEnvironment
from jinja2_async_environment.loaders import AsyncDictLoader


async def custom_filters_example():
    templates = {
        "filter_example.html": """
<p>Original: {{ text }}</p>
<p>Uppercase: {{ text|uppercase }}</p>
<p>Word Count: {{ text|wordcount }}</p>
<p>Truncated: {{ long_text|truncate(20) }}</p>
        """
    }

    def uppercase_filter(value):
        return value.upper() if isinstance(value, str) else value

    def wordcount_filter(value):
        return len(value.split()) if isinstance(value, str) else 0

    def truncate_filter(value, length=50):
        if not isinstance(value, str):
            return value
        if len(value) <= length:
            return value
        return value[:length] + "..."

    env = AsyncEnvironment(loader=AsyncDictLoader(templates))

    # Register custom filters
    env.filters["uppercase"] = uppercase_filter
    env.filters["wordcount"] = wordcount_filter
    env.filters["truncate"] = truncate_filter

    template = await env.get_template_async("filter_example.html")
    result = await template.render_async(
        text="Hello World from Jinja2 Async!",
        long_text="This is a very long text that should be truncated to make it shorter.",
    )
    print(result)


# Run the example
asyncio.run(custom_filters_example())

Configuration

Environment Configuration Options

from jinja2_async_environment.environment import AsyncEnvironment
from jinja2_async_environment.loaders import AsyncFileSystemLoader

# Full environment configuration
env = AsyncEnvironment(
    loader=AsyncFileSystemLoader("templates"),
    cache_size=400,  # Template cache size
    auto_reload=True,  # Auto-reload templates when source changes
    bytecode_cache=None,  # Optional bytecode cache
    enable_async=True,  # Enable async features (should always be True)
    autoescape=True,  # Auto-escape HTML by default
    trim_blocks=True,  # Trim blocks
    lstrip_blocks=True,  # Strip leading whitespace from blocks
    keep_trailing_newline=False,  # Keep trailing newline at end of template
    optimized=True,  # Enable template optimization
    undefined=None,  # Undefined type handler
    finalize=None,  # Finalize function for variables
    cache_provider=None,  # Cache provider for template caching
)

Loader Configuration

from jinja2_async_environment.loaders import (
    AsyncFileSystemLoader,
    AsyncDictLoader,
    AsyncFunctionLoader,
)

# FileSystemLoader options
fs_loader = AsyncFileSystemLoader(
    searchpath="templates",  # Path or list of paths to search
    encoding="utf-8",  # File encoding
    followlinks=False,  # Follow symbolic links
)

# DictLoader options
dict_loader = AsyncDictLoader(mapping={"template.html": "<h1>Hello {{ name }}!</h1>"})


# FunctionLoader with async function
async def async_load_func(name):
    # Custom async loading logic
    content = await fetch_template_from_database(name)
    filepath = f"db://{name}"

    async def async_uptodate():
        # Check if template is still up to date
        return await is_template_current(name)

    return content, filepath, async_uptodate


func_loader = AsyncFunctionLoader(async_load_func)

Caching Configuration

from jinja2_async_environment.bccache import AsyncRedisBytecodeCache
import redis.asyncio as redis

# Redis bytecode cache configuration
redis_client = redis.Redis(
    host="localhost",
    port=6379,
    db=0,
    password=None,  # Optional password
    socket_timeout=5,  # Socket timeout in seconds
    socket_connect_timeout=5,  # Connection timeout in seconds
)

bytecode_cache = AsyncRedisBytecodeCache(
    client=redis_client,
    prefix="jinja2_",  # Key prefix
    timeout=300,  # Cache timeout in seconds
)

# Environment with bytecode caching
env = AsyncEnvironment(
    loader=AsyncFileSystemLoader("templates"), bytecode_cache=bytecode_cache
)

Troubleshooting

Common Issues and Solutions

1. Template Not Found Errors

# Ensure your search paths are correct
loader = AsyncFileSystemLoader(["/absolute/path/templates", "./relative/templates"])

# Debug template loading
try:
    template = await env.get_template_async("template.html")
except TemplateNotFound as e:
    print(f"Template not found: {e}")
    print(f"Search paths: {loader.searchpath}")

2. Async/Await Issues

# Always use await with async methods
# ❌ Wrong
template = env.get_template_async("template.html")

# ✅ Correct
template = await env.get_template_async("template.html")


# Ensure you're in an async context
async def render_template():
    template = await env.get_template_async("template.html")
    return await template.render_async(name="World")

3. Performance Issues

# Enable bytecode caching for better performance
from jinja2_async_environment.bccache import AsyncRedisBytecodeCache

# Use appropriate cache size
env = AsyncEnvironment(
    loader=AsyncFileSystemLoader("templates"),
    cache_size=1000,  # Increase cache size for high-volume applications
)

# Profile template rendering
import asyncio
import time


async def profile_rendering():
    start_time = time.time()
    template = await env.get_template_async("heavy_template.html")
    result = await template.render_async(large_context)
    end_time = time.time()
    print(f"Render time: {end_time - start_time:.4f} seconds")

4. Sandbox Security Errors

from jinja2.exceptions import SecurityError

try:
    result = await template.render_async(context)
except SecurityError as e:
    print(f"Security violation: {e}")
    # Log the violation and handle appropriately

Debugging Tips

Enable Debug Mode:

env = AsyncEnvironment(
    loader=AsyncFileSystemLoader("templates"),
    undefined=DebugUndefined,  # Shows undefined variables
)

Check Template Source:

# Inspect template source
template = await env.get_template_async("template.html")
print(template.source)  # View raw template source

Monitor Performance:

import time


async def timed_render(template_name, context):
    start = time.perf_counter()
    template = await env.get_template_async(template_name)
    result = await template.render_async(context)
    end = time.perf_counter()
    print(f"Template {template_name} rendered in {end - start:.4f} seconds")
    return result

Performance Optimization

Best Practices

Cache Environment Instances:

# ✅ Reuse environment instances
class TemplateService:
    def __init__(self):
        self.env = AsyncEnvironment(loader=AsyncFileSystemLoader("templates"))

    async def render_template(self, name, context):
        template = await self.env.get_template_async(name)
        return await template.render_async(context)

Optimize Template Structure:
- Minimize complex logic in templates
- Use template inheritance to reduce duplication
- Preprocess data before passing to templates

Efficient Context Management:

# ✅ Pass only necessary data
context = {
    "user": {"name": user.name},  # Only what's needed
    "items": [item.to_dict() for item in items],  # Pre-processed data
}

result = await template.render_async(context)

Use Appropriate Loaders:
- AsyncDictLoader for static templates
- AsyncFileSystemLoader for file-based templates
- AsyncFunctionLoader for dynamic template sources

API Reference

For detailed API documentation, see API Reference.

Changelog

See CHANGELOG.md for version history, breaking changes, and new features.

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

Code Style Guidelines

Follow the crackerjack code style
Use type hints for all function signatures
Write comprehensive tests for new features
Document public APIs with docstrings

Testing Requirements

Python 3.13+
All development dependencies installed via pip install -e ".[dev]"
Maintain or improve test coverage (currently 69%)
Ensure all benchmarks pass performance thresholds

Pull Request Process

Fork the repository
Create a feature branch
Add tests for new functionality
Ensure all tests pass
Update documentation as needed
Submit pull request with clear description

For major changes, please open an issue first to discuss what you would like to change.

Async Uptodate Functions

Custom loaders can now return async uptodate functions for non-blocking template freshness checks:

import asyncio
from jinja2_async_environment.environment import AsyncEnvironment
from jinja2_async_environment.loaders import AsyncFunctionLoader


async def load_template_with_async_uptodate(name):
    # Custom loading logic here
    with open(f"templates/{name}", "r") as f:
        content = f.read()
        filepath = f"templates/{name}"

        # Async uptodate function - useful for remote/database checks
        async def async_uptodate():
            # Check if template is still up to date (async operation)
            # This could be a database query, API call, etc.
            import os
            import asyncio

            await asyncio.sleep(0)  # Simulate async operation
            return os.path.getmtime(filepath) == os.path.getmtime(filepath)

        return content, filepath, async_uptodate


async def main():
    # Create environment with async uptodate support
    env = AsyncEnvironment(
        loader=AsyncFunctionLoader(load_template_with_async_uptodate),
        auto_reload=True,  # Enable auto-reload to use uptodate functions
    )

    # The environment will automatically await async uptodate functions
    template = await env.get_template_async("example.html")
    result = await template.render_async()
    print(result)


asyncio.run(main())

Key Features:

Both sync and async uptodate functions are supported
Async uptodate functions are automatically awaited during template caching
No code changes needed - existing sync uptodate functions continue to work
Useful for remote template sources (databases, APIs, remote filesystems)

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

Custom loaders can now return async uptodate functions for non-blocking template freshness checks:

import asyncio
from jinja2_async_environment.environment import AsyncEnvironment
from jinja2_async_environment.loaders import AsyncFunctionLoader


async def load_template_with_async_uptodate(name):
    # Custom loading logic here
    with open(f"templates/{name}", "r") as f:
        content = f.read()
        filepath = f"templates/{name}"

        # Async uptodate function - useful for remote/database checks
        async def async_uptodate():
            # Check if template is still up to date (async operation)
            # This could be a database query, API call, etc.
            import os
            import asyncio

            await asyncio.sleep(0)  # Simulate async operation
            return os.path.getmtime(filepath) == os.path.getmtime(filepath)

        return content, filepath, async_uptodate


async def main():
    # Create environment with async uptodate support
    env = AsyncEnvironment(
        loader=AsyncFunctionLoader(load_template_with_async_uptodate),
        auto_reload=True,  # Enable auto-reload to use uptodate functions
    )

    # The environment will automatically await async uptodate functions
    template = await env.get_template_async("example.html")
    result = await template.render_async()
    print(result)


asyncio.run(main())
## License

BSD-3-Clause

## Comparison with Standard Jinja2

`jinja2-async-environment` provides several advantages over standard Jinja2:

### Performance Benefits

| Feature | Standard Jinja2 | jinja2-async-environment | Improvement |
|---------|----------------|--------------------------|-------------|
| Template Rendering | Sync only | Async + Sync | Non-blocking operations |
| Concurrent Processing | Limited | Enhanced | 1.23x better |
| Async Generator Handling | Not applicable | Optimized | 1000x faster |
| Macro Processing | Standard | Enhanced | 0.8-1.0x speed |
| Memory Usage | Standard | Optimized | Reduced overhead |

### Feature Comparison

| Feature | Standard Jinja2 | jinja2-async-environment | Notes |
|---------|----------------|--------------------------|-------|
| 100% Compatibility | ✅ | ✅ | Drop-in replacement |
| Async Loaders | ❌ | ✅ | FileSystem, Dict, Function, etc. |
| Async Rendering | ❌ | ✅ | `render_async()` method |
| Async Caching | ❌ | ✅ | Redis bytecode caching |
| Sandboxed Execution | ✅ | ✅ | `AsyncSandboxedEnvironment` |
| Async Uptodate Functions | ❌ | ✅ | Non-blocking freshness checks |
| Type Safety | Limited | ✅ | Full type hints |

### Unique Advantages

1. **True Async Support**: Unlike other "async" Jinja2 wrappers, this library provides genuine async implementations
2. **Performance Optimization**: Critical path optimizations like async generator handling (1000x faster)
3. **Modern Python**: Leverages Python 3.13+ features for better performance and type safety
4. **Comprehensive Loader Support**: All loader types have async equivalents
5. **Enhanced Security**: Improved sandboxed environment with async support

Name		Name	Last commit message	Last commit date
Latest commit History 94 Commits
.crackerjack/session/handoff		.crackerjack/session/handoff
.github		.github
docs		docs
jinja2_async_environment		jinja2_async_environment
tests		tests
.DS_Store		.DS_Store
.crackerjack-hooks-updated		.crackerjack-hooks-updated
.envrc		.envrc
.gitignore		.gitignore
.mcp.json		.mcp.json
.mcp.json.bak		.mcp.json.bak
.pre-commit-config.yaml		.pre-commit-config.yaml
.pre-commit-config.yaml.disabled		.pre-commit-config.yaml.disabled
AGENTS.md		AGENTS.md
CHANGELOG.md		CHANGELOG.md
CLAUDE.md		CLAUDE.md
GEMINI.md		GEMINI.md
LICENSE		LICENSE
QWEN.md		QWEN.md
README.md		README.md
mypy.ini		mypy.ini
pyproject.toml		pyproject.toml
uv.lock		uv.lock

Uh oh!

License

lesleslie/jinja2-async-environment

Folders and files

Latest commit

History

Repository files navigation

jinja2-async-environment

100% Compatible Asynchronous Jinja2 Environment

Features

Performance Benchmarks

🚀 Key Performance Improvements

📊 Benchmark Results

⚡ Performance Highlights

Installation

Installation

Installation Options

Requirements

Usage

Basic Template Rendering

Web Framework Integration (FastAPI Example)

Web Framework Integration (Starlette Example)

Using Different Loaders

Using Macros

With Bytecode Caching

Sandboxed Template Execution

Advanced Usage Examples

Error Handling Patterns

Template Inheritance

Custom Filters and Extensions

Configuration

Environment Configuration Options

Loader Configuration

Caching Configuration

Troubleshooting

Common Issues and Solutions

1. Template Not Found Errors

2. Async/Await Issues

3. Performance Issues

4. Sandbox Security Errors

Debugging Tips

Performance Optimization

Best Practices

API Reference

Changelog

Contributing

Code Style Guidelines

Testing Requirements

Pull Request Process

Async Uptodate Functions

Contributing

License

About

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases

Sponsor this project

Uh oh!

Packages 0

Uh oh!

Contributors 3

Uh oh!

Languages

Packages