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 cleanly structured with clear imports, a concise docstring, and a single well-defined class. The constructor uses a flat, logical flow with minimal nesting and clear intent. The condition and assignment are separated appropriately, and overall length is minimal. The only minor drawback is the slightly dense import block, but it is organized and typical for Python modules.
Run 3
The code is highly readable with clear imports, straightforward class definition, and a concise docstring explaining the Flask-specific behavior. The __init__ method logically handles the loader setup before delegating to the parent class, with a single conditional adding only minimal nesting. Each action is clearly separated, and the reading flow is natural: imports, class definition, docstring, then initialization logic. Naming is descriptive ('create_global_jinja_loader', 'app_ctx'), and type hints improve clarity. Length is appropriate—no redundancy or unnecessary verbosity. Only minor deductions: the conditional could be slightly more explicit about why the loader is set, and the docstring could mention the 'app' attribute, but overall this is clean, maintainable code.
Run 1
Code Structure: Imports followed by a class and a short constructor provide clear organization, though several imports are unused in this snippet. Nesting: A single conditional keeps nesting shallow. Clarity of intent: Descriptive names, type annotations, and a docstring make the purpose understandable, although the docstring describes behavior not directly shown and App is not defined or imported here. Code length: The implementation is concise, with little unnecessary logic. Action granularity: Each statement performs one clear action. Reading flow: Constructor steps follow naturally from supplying a default loader to initializing the base environment and storing the application. Additional blank lines between import groups and before the class would improve visual separation.
Run 2
Code Structure: Imports and a single focused class are logically organized, though grouping related Jinja2 imports could improve presentation. Nesting: Only one shallow conditional keeps the constructor easy to follow. Clarity of intent: The docstring, descriptive names, and type annotations clearly explain the environment extension and default loader setup, although App is not defined or imported in the snippet. Code length: The implementation is concise, with no unnecessary logic. Action granularity: Each statement performs one clear action. Reading flow: The constructor naturally progresses from configuring the loader to initializing the base environment and retaining the application reference. Several imports are unused in the shown code, adding minor visual clutter.
Run 3
Code Structure: Imports precede a focused class and constructor, providing clear logical organization. Nesting: A single shallow conditional is easy to follow. Clarity of intent: Descriptive names, type annotations, and a docstring explain the Flask-aware environment and loader initialization, although the docstring describes behavior not directly shown and App is not imported in this snippet. Code length: The implementation is concise without unnecessary logic. Action granularity: Each statement performs one action, and imports are individually listed. Reading flow: Initialization proceeds naturally from selecting a default loader to initializing the base environment and storing the application. Minor readability improvements include grouping imports with blank lines and using super().__init__ instead of an explicit base-class call.