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 highly readable with clear structure and intent. Imports are organized logically, grouped by source (stdlib, third-party, local modules), and each import is on its own line. The class definition is concise with a clear docstring explaining the Flask-specific behavior. The __init__ method demonstrates good action granularity—each logical step (checking for a loader, assigning a default, calling the parent constructor, storing the app reference) is on its own line, making the flow easy to follow. Nesting is minimal, with only a single conditional that is straightforward. The type hints and use of t.Any improve clarity. Variable naming is descriptive (options, app). The method is short and focused on initialization. Minor deduction could be made for the slightly dense conditional assignment on two lines, but overall the code is clean, purposeful, and easy to understand.
Run 3
The code is generally well-structured and readable. It has clear imports, a concise docstring explaining the class's purpose, and a straightforward __init__ method with flat nesting. Naming is clear, and the logic is easy to follow. Minor deductions: the BaseEnvironment.__init__ call slightly disrupts natural reading flow compared to using super(), and the type hint 'App' appears without a visible import, which could confuse readers. Overall, it is concise and maintainable.
Run 1
Code Structure: Imports followed by a single focused class and constructor provide logical organization, though several imports are unused in this snippet. Nesting: Only one shallow conditional keeps complexity low. Clarity of intent: Descriptive names and the docstring explain the environment's role, but the documented blueprint behavior is not shown, and the App annotation lacks a visible import. Code length: The implementation is concise with no unnecessary procedural code. Action granularity: Each statement performs one clear action. Reading flow: The constructor naturally progresses from selecting a default loader to initializing the base environment and storing the application; additional spacing between imports and the class would improve visual separation.
Run 2
Code Structure: Imports followed by a focused class and 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 the docstring communicate framework integration, although blueprint behavior is not demonstrated here and App is not defined or 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 supplying a default loader to initializing the base environment and storing the application. Additional spacing between import groups and before the class would improve visual readability.
Run 3
Code Structure: Imports and a focused environment subclass are logically organized, though several imports are unused in this snippet. Nesting: Only one shallow conditional keeps the constructor easy to follow. Clarity of intent: The class name, docstring, and loader initialization communicate its purpose, although the documented blueprint behavior is not visible 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: Initialization proceeds naturally from supplying a default loader to initializing the base environment and storing the application. Additional spacing between import groups and before the class would improve visual readability.