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, a: App, **b: t.Any) -> None:
if "loader" not in b:
b["loader"] = a.create_global_jinja_loader()
BaseEnvironment.__init__(self, **b)
self.app = a
Run 1
The code has a clear basic structure and a descriptive docstring, but readability is hurt by poor naming (single-letter variables like 'a' and 'b'), which makes intent ambiguous. The use of `BaseEnvironment.__init__(self, **b)` instead of `super().__init__(**b)` is less idiomatic and harder to follow. While nesting is low and action granularity is reasonable, the abbreviated parameter names and the non-standard initialization call reduce clarity and natural reading flow. The conditional loader setup is simple but could be more explicit. Overall, the code functions but requires extra effort to interpret due to opaque naming and a slightly awkward initialization pattern.
Run 2
The code is well-structured and readable. It benefits from clear import organization, a concise docstring explaining the class's specialized behavior, and a straightforward constructor that modifies only the necessary option before delegating to the parent class. Nesting is minimal, with only one conditional block. The use of type hints and `t.Any` adds clarity. Action granularity is good, with one meaningful operation per line. Overall, it is idiomatic Python and Jinja extension code, though the abstract context and incomplete `App` type hint prevent a perfect score.
Run 3
The code is generally readable and follows standard Python patterns. It has a clear structure with logical imports and a single class definition. Nesting is minimal, with only one conditional in the constructor. The intent is clear: extending Jinja's Environment for Flask blueprint awareness. However, readability is reduced by non-descriptive parameter names ('a', 'b'), which obscure intent and require reader inference. The class docstring is helpful but refers to Flask specifics without context. Action granularity is good, with one main action per line. The reading flow is natural, but the use of 'a' and 'b' disrupts clarity. Concise length and proper typing annotations are positive aspects.
Run 1
Code Structure: Imports and a single class are logically organized, though several imports are unused in this snippet and the class could use additional spacing. Nesting: Only one shallow conditional, making execution easy to follow. Clarity of intent: Inheritance, type annotations, and the loader setup communicate the purpose, but parameter names 'a' and 'b' are vague. The docstring describes blueprint behavior rather than directly explaining the constructor's loader configuration, and 'App' is not imported in the snippet. Code length: Compact without unnecessary implementation detail. 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, with cryptic parameter names providing the main distraction.
Run 2
Code Structure: Imports, class definition, and constructor are logically organized, although several imports are unused in this snippet. Nesting: Only one shallow conditional keeps the code easy to follow. Clarity of intent: The class name, docstring, and loader creation convey the purpose, but parameter names 'a' and 'b' obscure their roles; 'app' and 'options' would be clearer. The App annotation is not defined or imported here, and the docstring describes behavior not directly shown. Code length: The implementation is concise, though unused imports add clutter. Action granularity: Each statement performs one action. Reading flow: Execution proceeds naturally from providing a default loader to initializing the base environment and storing the application, but missing blank lines between import groups and before the class slightly reduce readability.
Run 3
Code Structure: Imports and a single class with a short initializer are logically organized. Nesting: Only one shallow conditional makes the control flow easy to follow. Clarity of intent: The superclass, docstring, and loader setup communicate the broad purpose, but parameter names 'a' and 'b' obscure their roles. The docstring describes blueprint behavior not directly visible here, and 'App' is not imported in the snippet. Code length: The implementation is concise, although several imports are unused in the shown code. Action granularity: Each statement performs one action, with no compressed multi-action lines. Reading flow: The initializer naturally progresses from choosing a default loader to initializing the environment and storing the application. Missing blank lines between import groups and before the class slightly weaken visual organization.