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 concise and clearly structured. It uses explicit imports, type hints, and a docstring to clarify the class's purpose. The constructor handles a single optional parameter ('loader') before delegating to the parent class, making the logic easy to follow. Nesting is minimal and action granularity is clear, with each initialization step on its own line. The reading flow is natural, moving from imports to class definition to constructor logic. Minor deductions: the custom loader assignment could be slightly more explicit, and 't.Any' hides some typing detail, but overall the code is highly readable.
Run 2
The code is highly readable with clear structure and intent. It follows a logical import organization, separating standard library, third-party, and local imports. The class has a concise docstring explaining its purpose. The __init__ method uses a flat conditional with a single action, and the initialization is straightforward. Naming is descriptive and consistent with conventions. The code is minimal, avoiding unnecessary complexity or nesting. Overall, it is easy to understand and maintain.
Run 3
The code is generally readable but has some issues. The class structure is clear and the docstring is informative, explaining the Environment's purpose. The __init__ method is mostly flat and has a clear flow. However, the import section could be more concise by using a combined import statement for jinja2 components. The method signature uses `**options: t.Any` which is reasonable, but the conditional loader assignment is somewhat unclear — a comment explaining why the loader is created would help. The action granularity is good, with one logical operation per line. The reading flow is natural: check for loader, create if missing, then initialize. Overall, this is acceptable code, but the scattered imports and lack of comment on the loader creation reduce clarity.
Run 1
Code Structure: Imports and a single focused class are logically organized, although several imports are unused in this snippet. Nesting: Only one shallow conditional keeps the constructor easy to follow. Clarity of intent: Descriptive names, type annotations, and the docstring explain the Flask-specific environment; however, App is not defined or imported here, and the blueprint behavior described is not visible in this snippet. Code length: The implementation is concise with little unnecessary code beyond the unused imports. Action granularity: Each statement performs one clear action. Reading flow: Loader configuration, base initialization, and application assignment form a natural sequence. Additional blank lines between imports and the class would improve visual separation.
Run 2
Code structure is logical, with imports followed by a focused class and constructor. Nesting is minimal: only one simple conditional. Intent is clear from the descriptive docstring, meaningful names, and straightforward default-loader setup. The implementation is concise, although several imports are unused in this snippet. Action granularity is good, with one operation per line. Reading flow is natural, moving from loader configuration to base initialization and application storage. Minor readability issues include limited spacing between import groups and the class, an App annotation whose definition or import is not shown, and a docstring emphasizing blueprint behavior that is not directly demonstrated here.
Run 3
Code Structure: Imports and a focused class are logically organized, 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 clear, although the docstring describes blueprint behavior not directly shown here, and App is not imported in the snippet. Code length: The constructor is concise without unnecessary logic. Action granularity: Each statement performs one clear action. Reading flow: Initialization proceeds naturally from selecting a default loader to initializing the base environment and storing the application; additional spacing between import groups and the class would improve visual separation.