10698801813

Committed 04 Sep 2024 09:19AM UTC coverage: 67.425% (+0.002%) from 67.423%

Build # 10698801813

Build Type

Pull #988

github

Committed by

nhoening

Commit Message

undo breaking change in Asset API (when no pagination is asked for), improve testing a bit

Signed-off-by: Nicolas Höning <nicolas@seita.nl>

Pull Request Pull Request #988: Speed up assets and accounts pages

Run Details

6141 of 9945 branches covered (61.75%)

Branch coverage included in aggregate %.

85 of 99 new or added lines in 9 files covered. (85.86%)

7 existing lines in 2 files now uncovered.

7700 of 10583 relevant lines covered (72.76%)

5.76 hits per line

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

88.89

/flexmeasures/ui/crud/assets/utils.py

from __future__ import annotations

import json
from flask import url_for
from flask_security import current_user
from typing import Optional, Dict
from sqlalchemy import select
from sqlalchemy.sql.expression import or_

from flexmeasures.auth.policy import check_access
from flexmeasures.data import db
from flexmeasures.data.models.generic_assets import GenericAsset, GenericAssetType
from flexmeasures.data.models.user import Account
from flexmeasures.data.models.time_series import Sensor
from flexmeasures.ui.crud.api_wrapper import InternalApi
from flexmeasures.utils.unit_utils import (
    is_energy_price_unit,
    is_energy_unit,
    is_power_unit,
)


def get_allowed_price_sensor_data(account_id: Optional[int]) -> Dict[int, str]:
    """
    Return a list of sensors which the user can add
    as consumption_price_sensor_id or production_price_sensor_id.
    For each sensor we get data as sensor_id: asset_name:sensor_name.
    """
    if not account_id:
        assets = db.session.scalars(
            select(GenericAsset).filter(GenericAsset.account_id.is_(None))
        ).all()
    else:
        assets = db.session.scalars(
            select(GenericAsset).filter(
                or_(
                    GenericAsset.account_id == account_id,
                    GenericAsset.account_id.is_(None),
                )
            )
        ).all()

    sensors_data = list()
    for asset in assets:
        sensors_data += [
            (sensor.id, asset.name, sensor.name, sensor.unit)
            for sensor in asset.sensors
        ]

    return {
        sensor_id: f"{asset_name}:{sensor_name}"
        for sensor_id, asset_name, sensor_name, sensor_unit in sensors_data
        if is_energy_price_unit(sensor_unit)
    }


def get_allowed_inflexible_sensor_data(account_id: Optional[int]) -> Dict[int, str]:
    """
    Return a list of sensors which the user can add
    as inflexible device sensors.
    This list is built using sensors with energy or power units
    within the current account (or among public assets when account_id argument is not specified).
    For each sensor we get data as sensor_id: asset_name:sensor_name.
    """
    query = None
    if not account_id:
        query = select(GenericAsset).filter(GenericAsset.account_id.is_(None))
    else:
        query = select(GenericAsset).filter(GenericAsset.account_id == account_id)
    assets = db.session.scalars(query).all()

    sensors_data = list()
    for asset in assets:
        sensors_data += [
            (sensor.id, asset.name, sensor.name, sensor.unit)
            for sensor in asset.sensors
        ]

    return {
        sensor_id: f"{asset_name}:{sensor_name}"
        for sensor_id, asset_name, sensor_name, sensor_unit in sensors_data
        if is_energy_unit(sensor_unit) or is_power_unit(sensor_unit)
    }


def process_internal_api_response(
    asset_data: dict, asset_id: int | None = None, make_obj=False
) -> GenericAsset | dict:
    """
    Turn data from the internal API into something we can use to further populate the UI.
    Either as an asset object or a dict for form filling.

    If we add other data by querying the database, we make sure the asset is not in the session afterwards.
    """

    def expunge_asset():
        # use if no insert is wanted from a previous query which flushes its results
        if asset in db.session:
            db.session.expunge(asset)

    asset_data.pop("status", None)  # might have come from requests.response
    if asset_id:
        asset_data["id"] = asset_id
    if make_obj:
        children = asset_data.pop("child_assets", [])

        asset_data.pop("sensors", [])
        asset_data.pop("owner", [])
        asset_type = asset_data.pop("generic_asset_type", [])

        asset = GenericAsset(
            **{
                **asset_data,
                **{"attributes": json.loads(asset_data.get("attributes", "{}"))},
            }
        )  # TODO: use schema?
        if "generic_asset_type_id" in asset_data:
            asset.generic_asset_type = db.session.get(
                GenericAssetType, asset_data["generic_asset_type_id"]
            )
        else:
            asset.generic_asset_type = db.session.get(
                GenericAssetType, asset_type.get("id", None)
            )
        expunge_asset()
        asset.owner = db.session.get(Account, asset_data["account_id"])
        expunge_asset()
        db.session.flush()
        if "id" in asset_data:
            asset.sensors = db.session.scalars(
                select(Sensor).filter_by(generic_asset_id=asset_data["id"])
            ).all()
            expunge_asset()
        if asset_data.get("parent_asset_id", None) is not None:
            asset.parent_asset = db.session.execute(
                select(GenericAsset).filter(
                    GenericAsset.id == asset_data["parent_asset_id"]
                )
            ).scalar_one_or_none()
            expunge_asset()

        child_assets = []
        for child in children:
            if "child_assets" in child:
                # not deeper than one level
                child.pop("child_assets")
            child_asset = process_internal_api_response(child, child["id"], True)
            child_assets.append(child_asset)
        asset.child_assets = child_assets
        expunge_asset()

        return asset
    return asset_data


def user_can_create_assets() -> bool:
    try:
        check_access(current_user.account, "create-children")
    except Exception:
        return False
    return True


def user_can_delete(asset) -> bool:
    try:
        check_access(asset, "delete")
    except Exception:
        return False
    return True


def get_assets_by_account(account_id: int | str | None) -> list[GenericAsset]:
    if account_id is not None:
        get_assets_response = InternalApi().get(
            url_for("AssetAPI:index"), query={"account_id": account_id}
        )
    else:
        get_assets_response = InternalApi().get(url_for("AssetAPI:public"))
    return [
        process_internal_api_response(ad, make_obj=True)
        for ad in get_assets_response.json()
    ]

1	from __future__ import annotations	8✔
2
3	import json	8✔
4	from flask import url_for	8✔
5	from flask_security import current_user	8✔
6	from typing import Optional, Dict	8✔
7	from sqlalchemy import select	8✔
8	from sqlalchemy.sql.expression import or_	8✔
9
10	from flexmeasures.auth.policy import check_access	8✔
11	from flexmeasures.data import db	8✔
12	from flexmeasures.data.models.generic_assets import GenericAsset, GenericAssetType	8✔
13	from flexmeasures.data.models.user import Account	8✔
14	from flexmeasures.data.models.time_series import Sensor	8✔
15	from flexmeasures.ui.crud.api_wrapper import InternalApi	8✔
16	from flexmeasures.utils.unit_utils import (	8✔
17	is_energy_price_unit,
18	is_energy_unit,
19	is_power_unit,
20	)
21
22
23	def get_allowed_price_sensor_data(account_id: Optional[int]) -> Dict[int, str]:	8✔
24	"""
25	Return a list of sensors which the user can add
26	as consumption_price_sensor_id or production_price_sensor_id.
27	For each sensor we get data as sensor_id: asset_name:sensor_name.
28	"""
29	if not account_id:	8✔
30	assets = db.session.scalars(	8✔
31	select(GenericAsset).filter(GenericAsset.account_id.is_(None))
32	).all()
33	else:
34	assets = db.session.scalars(	8✔
35	select(GenericAsset).filter(
36	or_(
37	GenericAsset.account_id == account_id,
38	GenericAsset.account_id.is_(None),
39	)
40	)
41	).all()
42
43	sensors_data = list()	8✔
44	for asset in assets:	8✔
45	sensors_data += [	8✔
46	(sensor.id, asset.name, sensor.name, sensor.unit)
47	for sensor in asset.sensors
48	]
49
50	return {	8✔
51	sensor_id: f"{asset_name}:{sensor_name}"
52	for sensor_id, asset_name, sensor_name, sensor_unit in sensors_data
53	if is_energy_price_unit(sensor_unit)
54	}
55
56
57	def get_allowed_inflexible_sensor_data(account_id: Optional[int]) -> Dict[int, str]:	8✔
58	"""
59	Return a list of sensors which the user can add
60	as inflexible device sensors.
61	This list is built using sensors with energy or power units
62	within the current account (or among public assets when account_id argument is not specified).
63	For each sensor we get data as sensor_id: asset_name:sensor_name.
64	"""
65	query = None	8✔
66	if not account_id:	8✔
67	query = select(GenericAsset).filter(GenericAsset.account_id.is_(None))	8✔
68	else:
69	query = select(GenericAsset).filter(GenericAsset.account_id == account_id)	8✔
70	assets = db.session.scalars(query).all()	8✔
71
72	sensors_data = list()	8✔
73	for asset in assets:	8✔
74	sensors_data += [	8✔
75	(sensor.id, asset.name, sensor.name, sensor.unit)
76	for sensor in asset.sensors
77	]
78
79	return {	8✔
80	sensor_id: f"{asset_name}:{sensor_name}"
81	for sensor_id, asset_name, sensor_name, sensor_unit in sensors_data
82	if is_energy_unit(sensor_unit) or is_power_unit(sensor_unit)
83	}
84
85
86	def process_internal_api_response(	8✔
87	asset_data: dict, asset_id: int \| None = None, make_obj=False
88	) -> GenericAsset \| dict:
89	"""
90	Turn data from the internal API into something we can use to further populate the UI.
91	Either as an asset object or a dict for form filling.
92
93	If we add other data by querying the database, we make sure the asset is not in the session afterwards.
94	"""
95
96	def expunge_asset():	8✔
97	# use if no insert is wanted from a previous query which flushes its results
98	if asset in db.session:	8✔
99	db.session.expunge(asset)	×
100
101	asset_data.pop("status", None) # might have come from requests.response	8✔
102	if asset_id:	8✔
103	asset_data["id"] = asset_id	8✔
104	if make_obj:	8✔
105	children = asset_data.pop("child_assets", [])	8✔
106
107	asset_data.pop("sensors", [])	8✔
108	asset_data.pop("owner", [])	8✔
109	asset_type = asset_data.pop("generic_asset_type", [])	8✔
110
111	asset = GenericAsset(	8✔
112	**{
113	**asset_data,
114	**{"attributes": json.loads(asset_data.get("attributes", "{}"))},
115	}
116	) # TODO: use schema?
117	if "generic_asset_type_id" in asset_data:	8✔
118	asset.generic_asset_type = db.session.get(	8✔
119	GenericAssetType, asset_data["generic_asset_type_id"]
120	)
121	else:
122	asset.generic_asset_type = db.session.get(	8✔
123	GenericAssetType, asset_type.get("id", None)
124	)
125	expunge_asset()	8✔
126	asset.owner = db.session.get(Account, asset_data["account_id"])	8✔
127	expunge_asset()	8✔
128	db.session.flush()	8✔
129	if "id" in asset_data:	8✔
130	asset.sensors = db.session.scalars(	8✔
131	select(Sensor).filter_by(generic_asset_id=asset_data["id"])
132	).all()
133	expunge_asset()	8✔
134	if asset_data.get("parent_asset_id", None) is not None:	8!
135	asset.parent_asset = db.session.execute(	×
136	select(GenericAsset).filter(
137	GenericAsset.id == asset_data["parent_asset_id"]
138	)
139	).scalar_one_or_none()
140	expunge_asset()	×
141
142	child_assets = []	8✔
143	for child in children:	8✔
NEW 144	if "child_assets" in child:	×
145	# not deeper than one level
NEW 146	child.pop("child_assets")	×
147	child_asset = process_internal_api_response(child, child["id"], True)	×
148	child_assets.append(child_asset)	×
149	asset.child_assets = child_assets	8✔
150	expunge_asset()	8✔
151
152	return asset	8✔
153	return asset_data	8✔
154
155
156	def user_can_create_assets() -> bool:	8✔
157	try:	8✔
158	check_access(current_user.account, "create-children")	8✔
159	except Exception:	8✔
160	return False	8✔
161	return True	8✔
162
163
164	def user_can_delete(asset) -> bool:	8✔
165	try:	8✔
166	check_access(asset, "delete")	8✔
167	except Exception:	8✔
168	return False	8✔
169	return True	8✔
170
171
172	def get_assets_by_account(account_id: int \| str \| None) -> list[GenericAsset]:	8✔
173	if account_id is not None:	8✔
174	get_assets_response = InternalApi().get(	8✔
175	url_for("AssetAPI:index"), query={"account_id": account_id}
176	)
177	else:
UNCOV 178	get_assets_response = InternalApi().get(url_for("AssetAPI:public"))	×
179	return [	8✔
180	process_internal_api_response(ad, make_obj=True)
181	for ad in get_assets_response.json()
182	]

FlexMeasures / flexmeasures / 10698801813

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