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 not ("loader" not in options):
pass
else:
options["loader"] = app.create_global_jinja_loader()
BaseEnvironment.__init__(self, **options)
self.app = app
Run 1
The code is generally readable but has a confusing conditional in __init__: 'if not ("loader" not in options): pass else: ...' is unnecessarily convoluted and could be written as 'if "loader" not in options: options["loader"] = ...'. This harms clarity of intent and reading flow. The class docstring is helpful, imports are clearly organized, and the overall structure is straightforward with minimal nesting. However, the conditional issue and redundant pass statement add unnecessary complexity. Action granularity is mostly one action per line, and the code is concise, but the awkward conditional prevents a higher score.
Run 2
The code is generally readable but has some confusing sections. The class docstring is clear and helpful. However, the conditional logic in __init__ is unnecessarily convoluted: 'if not ("loader" not in options): pass else: ...' could be simplified to 'if "loader" not in options: options["loader"] = ...'. The action granularity is reasonable, with one main action per line, and the reading flow is mostly natural. The type hints improve clarity. The main deduction comes from the needlessly complex conditional structure that obscures intent, making readers work harder than necessary to understand a simple check-and-set operation.
Run 3
The code has a clear class purpose and good type hints, but readability suffers from a convoluted conditional in __init__. The 'if not ("loader" not in options): pass else:...' construct is logically inverted and unnecessarily verbose, obscuring intent. A simpler 'if "loader" not in options:' would improve clarity. Multiple imports from the same module are stacked on separate lines, adding visual noise without benefit. The class docstring is helpful, but the method body's odd branching pattern disrupts natural reading flow. Overall structure is logical, nesting is shallow, and action granularity is mostly fine, but the conditional logic and import style lower the score.
Run 1
Code Structure: Imports and the class are logically organized, though several imports are unused in this snippet. Nesting: Shallow, but the empty if branch and else introduce unnecessary control flow. Clarity of intent: The docstring and type annotations help, but the double-negative condition obscures the simple intent of supplying a default loader. The App annotation has no visible definition or import. Code length: Short overall, although the pass branch is redundant. Action granularity: Each statement performs one action, making individual lines easy to follow. Reading flow: Generally natural, but readers must mentally simplify the condition; using if "loader" not in options would make initialization substantially clearer.
Run 2
Code Structure: Imports and a focused Environment subclass are logically organized. Nesting: Shallow, but the empty if branch and else unnecessarily complicate a simple default-setting operation. Clarity of intent: The docstring and descriptive names help, but the double-negative condition obscures the loader check; App is not defined or imported in the snippet, and the docstring describes behavior not directly demonstrated here. Code length: Short overall, though several imports are unused in this excerpt and the pass branch is redundant. Action granularity: Each statement performs one clear action. Reading flow: Initialization follows a natural sequence, but the awkward conditional interrupts it; using if "loader" not in options would improve readability.
Run 3
Code Structure: Imports and the small Environment subclass are logically organized. Nesting: Nesting is shallow, but the empty if branch and else create unnecessary control flow. Clarity of intent: The docstring and descriptive loader call help, but the double negative in `if not ("loader" not in options)` obscures a simple default-loader check. The App annotation has no visible import, and several imports are unused in this snippet. Code length: The implementation is short, though replacing the conditional with `if "loader" not in options` would remove redundant lines. Action granularity: Each line performs a single action, making individual operations easy to identify. Reading flow: Initialization proceeds naturally from loader configuration to superclass initialization and app assignment, but the inverted condition and pass interrupt that flow.