Source code
from __future__ import annotations
import typing as t
from jinja2 import BaseLoader
from jinja2 import Environment as BaseEnvironment
from jinja2 import Template
from jinja2 import TemplateNotFound
from .ctx import AppContext
from .globals import app_ctx
from .helpers import stream_with_context
from .signals import before_render_template
from .signals import template_rendered
class Environment(BaseEnvironment):
"""Works like a regular Jinja environment but has some additional
knowledge of how Flask's blueprint works so that it can prepend the
name of the blueprint to referenced templates if necessary.
"""
def __init__(self, app: App, **options: t.Any) -> None:
if "loader" not in options:
options["loader"] = app.create_global_jinja_loader()
BaseEnvironment.__init__(self, **options)
self.app = app
Run 1
The code is well-structured with clear imports, a class definition, and an __init__ method that handles loader setup cleanly. Nesting is minimal; there is only one conditional at a shallow level. Intent is clear from the docstring and method logic—customizing Jinja's environment for Flask blueprints. The length is concise but complete. Action granularity is appropriate: each line performs a single clear action. Reading flow is natural, moving from imports to class definition to method logic. Minor deductions: the conditional could be slightly more explicit about its purpose, and typing could be more specific (e.g., using a protocol for app), but overall readability is high.
Run 2
The code is clear and well-structured with logical imports, minimal nesting, and concise length. Each action is generally on its own line, and the class docstring clearly explains intent. Minor deductions: the constructor uses an inline conditional that slightly interrupts reading flow, and the app parameter lacks a type annotation for the App class, slightly reducing clarity of intent. Otherwise, it is readable and maintainable.
Run 3
The code is well-structured and readable. It imports only necessary components, uses clear type hints, and follows a logical order. The class docstring clearly explains the purpose and behavior. The __init__ method is concise, handles the loader default cleanly, and delegates initialization to the parent class. Action granularity is appropriate, with one meaningful operation per line. Nesting is minimal. The only minor issue is the relative import style may require familiarity with the package layout, but this is acceptable. Overall, the code is straightforward and maintainable.
Run 1
Code Structure: Imports followed by a focused class and constructor provide logical organization, though several imports are unused in this snippet. Nesting: A single conditional keeps nesting shallow. Clarity of intent: Descriptive names and the docstring explain the Flask-aware environment, but the blueprint behavior described is not shown, and App is neither defined nor imported in the snippet. Code length: The implementation is concise, with some import clutter. Action granularity: Each statement performs one action. Reading flow: The constructor naturally progresses from selecting a default loader to initializing the base environment and storing the app; additional spacing between imports and the class would improve visual separation.
Run 2
Code Structure: Imports and a single focused class are logically organized. Nesting: One shallow conditional keeps the constructor easy to follow. Clarity of intent: Descriptive names, type annotations, and a class docstring explain the environment extension, though the docstring discusses blueprint behavior not directly shown here, and App is not imported in the snippet. Code length: The implementation is concise without unnecessary logic. Action granularity: Each statement performs one clear action. Reading flow: The constructor naturally progresses from configuring a default loader to initializing the base environment and storing the application. Additional spacing between import groups and before the class would slightly improve visual readability.
Run 3
Code Structure: Imports and the environment subclass are logically organized, with initialization contained in one short method. Nesting: Only a single conditional introduces nesting, making control flow easy to follow. Clarity of intent: Descriptive names, type annotations, and the docstring explain the class's purpose, although the blueprint behavior is not demonstrated here and App is not defined or imported in the snippet. Code length: The implementation is concise, but several imports are unused in the shown code. Action granularity: Each statement performs a single clear action. Reading flow: Initialization proceeds naturally from providing a default loader to initializing the base environment and storing the application. Additional spacing between import groups and before the class would improve visual separation.