7743683116

Committed 01 Feb 2024 03:31PM UTC coverage: 66.516% (-0.1%) from 66.619%

Build # 7743683116

Build Type

push

github

Committed by

GustaafL

Commit Message

refactor: move comments and variable setting

Signed-off-by: GustaafL <guus@seita.nl>

Run Details

3815 of 6400 branches covered (0.0%)

Branch coverage included in aggregate %.

17 of 43 new or added lines in 2 files covered. (39.53%)

11 existing lines in 3 files now uncovered.

6813 of 9578 relevant lines covered (71.13%)

2.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

60.98

/flexmeasures/app.py

"""
Starting point of the Flask application.
"""

from __future__ import annotations

import time
from copy import copy
import os
from pathlib import Path
from datetime import date

from flask import Flask, g, request
from flask.cli import load_dotenv
from flask_mail import Mail
from flask_sslify import SSLify
from flask_json import FlaskJSON
from flask_cors import CORS
from flexmeasures.utils.config_utils import use_documentation_config, use_testing_config

from redis import Redis
from rq import Queue


def create(  # noqa C901
    env: str | None = None,
    path_to_config: str | None = None,
    plugins: list[str] | None = None,
) -> Flask:
    """
    Create a Flask app and configure it.

    Set the environment by setting FLEXMEASURES_ENV as environment variable (also possible in .env).
    Or, overwrite any FLEXMEASURES_ENV setting by passing an env in directly (useful for testing for instance).

    A path to a config file can be passed in (otherwise a config file will be searched in the home or instance directories).

    Also, a list of plugins can be set. Usually this works as a config setting, but this is useful for automated testing.
    """

    from flexmeasures.utils.config_utils import read_config, configure_logging
    from flexmeasures.utils.app_utils import set_secret_key, init_sentry
    from flexmeasures.utils.error_utils import add_basic_error_handlers

    # Create app

    configure_logging()  # do this first, see https://flask.palletsprojects.com/en/2.0.x/logging
    # we're loading dotenv files manually & early (can do Flask.run(load_dotenv=False)),
    # as we need to know the ENV now (for it to be recognized by Flask()).
    load_dotenv()

    # Below sets app.config["ENV"] = os.environ.get("FLASK_ENV") or "production"
    app = Flask("flexmeasures")

    # Overwrite the setting of app.config["ENV"] to "production" instead the "FLASK_ENV" environment variable.
    # Otherwise, the in the future deprecated "FLASK_ENV" can create issues.
    if os.environ.get("FLASK_ENV"):
        app.config["ENV"] = "production"

    if env == "documentation":
        use_documentation_config(app, path_to_config=path_to_config)
    elif env == "testing":
        use_testing_config(app)
        from fakeredis import FakeStrictRedis

        redis_conn = FakeStrictRedis(
            host="redis", port="1234"
        )  # dummy connection details
    else:
        read_config(app, custom_path_to_config=path_to_config, env=env)

    if plugins:
        app.config["FLEXMEASURES_PLUGINS"] += plugins
    add_basic_error_handlers(app)
    if (
        app.config.get("FLEXMEASURES_ENV") not in ("development", "documentation")
        and not app.testing
    ):
        init_sentry(app)

    app.mail = Mail(app)
    FlaskJSON(app)
    CORS(app)

    # configure Redis (for redis queue)
    if not app.testing:
        redis_conn = Redis(
            app.config["FLEXMEASURES_REDIS_URL"],
            port=app.config["FLEXMEASURES_REDIS_PORT"],
            db=app.config["FLEXMEASURES_REDIS_DB_NR"],
            password=app.config["FLEXMEASURES_REDIS_PASSWORD"],
        )
        """ FWIW, you could use redislite like this (not on non-recent os.name=="nt" systems or PA, sadly):
            from redislite import Redis
            redis_conn = Redis("MY-DB-NAME", unix_socket_path="/tmp/my-redis.socket",
            )
        """
    app.redis_connection = redis_conn
    app.queues = dict(
        forecasting=Queue(connection=redis_conn, name="forecasting"),
        scheduling=Queue(connection=redis_conn, name="scheduling"),
        # reporting=Queue(connection=redis_conn, name="reporting"),
        # labelling=Queue(connection=redis_conn, name="labelling"),
        # alerting=Queue(connection=redis_conn, name="alerting"),
    )

    # Some basic security measures

    set_secret_key(app)
    if app.config.get("SECURITY_PASSWORD_SALT", None) is None:
        app.config["SECURITY_PASSWORD_SALT"] = app.config["SECRET_KEY"]
    if app.config.get("FLEXMEASURES_ENV") not in ("documentation", "development"):
        SSLify(app)

    # Prepare profiling, if needed

    if app.config.get("FLEXMEASURES_PROFILE_REQUESTS", False):
        Path("profile_reports").mkdir(parents=True, exist_ok=True)
        try:
            import pyinstrument  # noqa F401
        except ImportError:
            app.logger.warning(
                "FLEXMEASURES_PROFILE_REQUESTS is True, but pyinstrument not installed ― I cannot produce profiling reports for requests."
            )

    # Register database and models, including user auth security handlers

    from flexmeasures.data import register_at as register_db_at

    register_db_at(app)

    # Register Reporters and Schedulers
    from flexmeasures.utils.coding_utils import get_classes_module
    from flexmeasures.data.models import reporting, planning

    reporters = get_classes_module("flexmeasures.data.models", reporting.Reporter)
    schedulers = get_classes_module("flexmeasures.data.models", planning.Scheduler)

    app.data_generators = dict()
    app.data_generators["reporter"] = copy(
        reporters
    )  # use copy to avoid mutating app.reporters
    app.data_generators["scheduler"] = schedulers

    # deprecated: app.reporters and app.schedulers
    app.reporters = reporters
    app.schedulers = schedulers

    def get_reporters():
        app.logger.warning(
            '`app.reporters` is deprecated. Use `app.data_generators["reporter"]` instead.'
        )
        return app.data_generators["reporter"]

    setattr(app, "reporters", get_reporters())

    # add auth policy

    from flexmeasures.auth import register_at as register_auth_at

    register_auth_at(app)

    # Register the CLI

    from flexmeasures.cli import register_at as register_cli_at

    register_cli_at(app)

    # Register the API

    from flexmeasures.api import register_at as register_api_at

    register_api_at(app)

    # Register plugins
    # If plugins register routes, they'll have precedence over standard UI
    # routes (first registration wins). However, we want to control "/" separately.

    from flexmeasures.utils.app_utils import root_dispatcher
    from flexmeasures.utils.plugin_utils import register_plugins

    app.add_url_rule("/", view_func=root_dispatcher)
    register_plugins(app)

    # Register the UI

    from flexmeasures.ui import register_at as register_ui_at

    register_ui_at(app)

    # Global template variables for both our own templates and external templates
    @app.context_processor
    def set_global_template_variables():
        return {"queue_names": app.queues.keys()}

    # Profile endpoints (if needed, e.g. during development)

    @app.before_request
    def before_request():
        if app.config.get("FLEXMEASURES_PROFILE_REQUESTS", False):
            g.start = time.time()
            try:
                import pyinstrument  # noqa F401

                g.profiler = pyinstrument.Profiler(async_mode="disabled")
                g.profiler.start()
            except ImportError:
                pass

    @app.teardown_request
    def teardown_request(exception=None):
        if app.config.get("FLEXMEASURES_PROFILE_REQUESTS", False):
            diff = time.time() - g.start
            if all([kw not in request.url for kw in ["/static", "favicon.ico"]]):
                app.logger.info(
                    f"[PROFILE] {str(round(diff, 2)).rjust(6)} seconds to serve {request.url}."
                )
                if not hasattr(g, "profiler"):
                    return app
                g.profiler.stop()
                output_html = g.profiler.output_html(timeline=True)
                endpoint = request.endpoint
                if endpoint is None:
                    endpoint = "unknown"
                today = date.today()
                profile_filename = f"pyinstrument_{endpoint}.html"
                profile_output_path = Path(
                    "profile_reports", today.strftime("%Y-%m-%d")
                )
                profile_output_path.mkdir(parents=True, exist_ok=True)
                with open(
                    os.path.join(profile_output_path, profile_filename), "w+"
                ) as f:
                    f.write(output_html)

    return app

1	"""	4✔
2	Starting point of the Flask application.
3	"""
4
5	from __future__ import annotations	4✔
6
7	import time	4✔
8	from copy import copy	4✔
9	import os	4✔
10	from pathlib import Path	4✔
11	from datetime import date	4✔
12
13	from flask import Flask, g, request	4✔
14	from flask.cli import load_dotenv	4✔
15	from flask_mail import Mail	4✔
16	from flask_sslify import SSLify	4✔
17	from flask_json import FlaskJSON	4✔
18	from flask_cors import CORS	4✔
19	from flexmeasures.utils.config_utils import use_documentation_config, use_testing_config	4✔
20
21	from redis import Redis	4✔
22	from rq import Queue	4✔
23
24
25	def create( # noqa C901	4✔
26	env: str \| None = None,
27	path_to_config: str \| None = None,
28	plugins: list[str] \| None = None,
29	) -> Flask:
30	"""
31	Create a Flask app and configure it.
32
33	Set the environment by setting FLEXMEASURES_ENV as environment variable (also possible in .env).
34	Or, overwrite any FLEXMEASURES_ENV setting by passing an env in directly (useful for testing for instance).
35
36	A path to a config file can be passed in (otherwise a config file will be searched in the home or instance directories).
37
38	Also, a list of plugins can be set. Usually this works as a config setting, but this is useful for automated testing.
39	"""
40
41	from flexmeasures.utils.config_utils import read_config, configure_logging	4✔
42	from flexmeasures.utils.app_utils import set_secret_key, init_sentry	4✔
43	from flexmeasures.utils.error_utils import add_basic_error_handlers	4✔
44
45	# Create app
46
47	configure_logging() # do this first, see https://flask.palletsprojects.com/en/2.0.x/logging	4✔
48	# we're loading dotenv files manually & early (can do Flask.run(load_dotenv=False)),
49	# as we need to know the ENV now (for it to be recognized by Flask()).
50	load_dotenv()	4✔
51
52	# Below sets app.config["ENV"] = os.environ.get("FLASK_ENV") or "production"
53	app = Flask("flexmeasures")	4✔
54
55	# Overwrite the setting of app.config["ENV"] to "production" instead the "FLASK_ENV" environment variable.
56	# Otherwise, the in the future deprecated "FLASK_ENV" can create issues.
57	if os.environ.get("FLASK_ENV"):	4✔
NEW 58	app.config["ENV"] = "production"	×
59
60	if env == "documentation":	4✔
NEW 61	use_documentation_config(app, path_to_config=path_to_config)	×
62	elif env == "testing":	4✔
63	use_testing_config(app)	4✔
64	from fakeredis import FakeStrictRedis	4✔
65
66	redis_conn = FakeStrictRedis(	4✔
67	host="redis", port="1234"
68	) # dummy connection details
69	else:
NEW 70	read_config(app, custom_path_to_config=path_to_config, env=env)	×
71
72	if plugins:	4✔
UNCOV 73	app.config["FLEXMEASURES_PLUGINS"] += plugins	×
74	add_basic_error_handlers(app)	4✔
75	if (	4✔
76	app.config.get("FLEXMEASURES_ENV") not in ("development", "documentation")
77	and not app.testing
78	):
79	init_sentry(app)	×
80
81	app.mail = Mail(app)	4✔
82	FlaskJSON(app)	4✔
83	CORS(app)	4✔
84
85	# configure Redis (for redis queue)
86	if not app.testing:	4✔
UNCOV 87	redis_conn = Redis(	×
88	app.config["FLEXMEASURES_REDIS_URL"],
89	port=app.config["FLEXMEASURES_REDIS_PORT"],
90	db=app.config["FLEXMEASURES_REDIS_DB_NR"],
91	password=app.config["FLEXMEASURES_REDIS_PASSWORD"],
92	)
93	""" FWIW, you could use redislite like this (not on non-recent os.name=="nt" systems or PA, sadly):
94	from redislite import Redis
95	redis_conn = Redis("MY-DB-NAME", unix_socket_path="/tmp/my-redis.socket",
96	)
97	"""
98	app.redis_connection = redis_conn	4✔
99	app.queues = dict(	4✔
100	forecasting=Queue(connection=redis_conn, name="forecasting"),
101	scheduling=Queue(connection=redis_conn, name="scheduling"),
102	# reporting=Queue(connection=redis_conn, name="reporting"),
103	# labelling=Queue(connection=redis_conn, name="labelling"),
104	# alerting=Queue(connection=redis_conn, name="alerting"),
105	)
106
107	# Some basic security measures
108
109	set_secret_key(app)	4✔
110	if app.config.get("SECURITY_PASSWORD_SALT", None) is None:	4✔
111	app.config["SECURITY_PASSWORD_SALT"] = app.config["SECRET_KEY"]	×
112	if app.config.get("FLEXMEASURES_ENV") not in ("documentation", "development"):	4✔
113	SSLify(app)	4✔
114
115	# Prepare profiling, if needed
116
117	if app.config.get("FLEXMEASURES_PROFILE_REQUESTS", False):	4!
118	Path("profile_reports").mkdir(parents=True, exist_ok=True)	×
119	try:	×
120	import pyinstrument # noqa F401	×
121	except ImportError:	×
122	app.logger.warning(	×
123	"FLEXMEASURES_PROFILE_REQUESTS is True, but pyinstrument not installed ― I cannot produce profiling reports for requests."
124	)
125
126	# Register database and models, including user auth security handlers
127
128	from flexmeasures.data import register_at as register_db_at	4✔
129
130	register_db_at(app)	4✔
131
132	# Register Reporters and Schedulers
133	from flexmeasures.utils.coding_utils import get_classes_module	4✔
134	from flexmeasures.data.models import reporting, planning	4✔
135
136	reporters = get_classes_module("flexmeasures.data.models", reporting.Reporter)	4✔
137	schedulers = get_classes_module("flexmeasures.data.models", planning.Scheduler)	4✔
138
139	app.data_generators = dict()	4✔
140	app.data_generators["reporter"] = copy(	4✔
141	reporters
142	) # use copy to avoid mutating app.reporters
143	app.data_generators["scheduler"] = schedulers	4✔
144
145	# deprecated: app.reporters and app.schedulers
146	app.reporters = reporters	4✔
147	app.schedulers = schedulers	4✔
148
149	def get_reporters():	4✔
150	app.logger.warning(	4✔
151	'`app.reporters` is deprecated. Use `app.data_generators["reporter"]` instead.'
152	)
153	return app.data_generators["reporter"]	4✔
154
155	setattr(app, "reporters", get_reporters())	4✔
156
157	# add auth policy
158
159	from flexmeasures.auth import register_at as register_auth_at	4✔
160
161	register_auth_at(app)	4✔
162
163	# Register the CLI
164
165	from flexmeasures.cli import register_at as register_cli_at	4✔
166
167	register_cli_at(app)	4✔
168
169	# Register the API
170
171	from flexmeasures.api import register_at as register_api_at	4✔
172
173	register_api_at(app)	4✔
174
175	# Register plugins
176	# If plugins register routes, they'll have precedence over standard UI
177	# routes (first registration wins). However, we want to control "/" separately.
178
179	from flexmeasures.utils.app_utils import root_dispatcher	4✔
180	from flexmeasures.utils.plugin_utils import register_plugins	4✔
181
182	app.add_url_rule("/", view_func=root_dispatcher)	4✔
183	register_plugins(app)	4✔
184
185	# Register the UI
186
187	from flexmeasures.ui import register_at as register_ui_at	4✔
188
189	register_ui_at(app)	4✔
190
191	# Global template variables for both our own templates and external templates
192	@app.context_processor	4✔
193	def set_global_template_variables():	4✔
194	return {"queue_names": app.queues.keys()}	4✔
195
196	# Profile endpoints (if needed, e.g. during development)
197
198	@app.before_request	4✔
199	def before_request():	4✔
200	if app.config.get("FLEXMEASURES_PROFILE_REQUESTS", False):	4✔
201	g.start = time.time()	×
202	try:	×
203	import pyinstrument # noqa F401	×
204
205	g.profiler = pyinstrument.Profiler(async_mode="disabled")	×
206	g.profiler.start()	×
207	except ImportError:	×
208	pass	×
209
210	@app.teardown_request	4✔
211	def teardown_request(exception=None):	4✔
212	if app.config.get("FLEXMEASURES_PROFILE_REQUESTS", False):	4✔
213	diff = time.time() - g.start	×
214	if all([kw not in request.url for kw in ["/static", "favicon.ico"]]):	×
215	app.logger.info(	×
216	f"[PROFILE] {str(round(diff, 2)).rjust(6)} seconds to serve {request.url}."
217	)
218	if not hasattr(g, "profiler"):	×
219	return app	×
220	g.profiler.stop()	×
221	output_html = g.profiler.output_html(timeline=True)	×
222	endpoint = request.endpoint	×
223	if endpoint is None:	×
224	endpoint = "unknown"	×
225	today = date.today()	×
226	profile_filename = f"pyinstrument_{endpoint}.html"	×
227	profile_output_path = Path(	×
228	"profile_reports", today.strftime("%Y-%m-%d")
229	)
230	profile_output_path.mkdir(parents=True, exist_ok=True)	×
231	with open(	×
232	os.path.join(profile_output_path, profile_filename), "w+"
233	) as f:
234	f.write(output_html)	×
235
236	return app	4✔

FlexMeasures / flexmeasures / 7743683116

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous