def setup_assets(db, setup_roles_users, setup_markets):
"""Make some asset types and add assets to known test users."""
data_source = DataSource(name="Seita", type="demo script")
db.session.add(data_source)
db.session.add(
AssetType(
name="solar",
is_producer=True,
can_curtail=True,
daily_seasonality=True,
yearly_seasonality=True,
)
)
db.session.add(
AssetType(
name="wind",
is_producer=True,
can_curtail=True,
daily_seasonality=True,
yearly_seasonality=True,
)
)
test_prosumer = find_user_by_email("*****@*****.**")
test_market = Market.query.filter_by(name="epex_da").one_or_none()
for asset_name in ["wind-asset-1", "wind-asset-2", "solar-asset-1"]:
asset = Asset(
name=asset_name,
asset_type_name="wind" if "wind" in asset_name else "solar",
event_resolution=timedelta(minutes=15),
capacity_in_mw=1,
latitude=10,
longitude=100,
min_soc_in_mwh=0,
max_soc_in_mwh=0,
soc_in_mwh=0,
unit="MW",
market_id=test_market.id,
)
asset.owner = test_prosumer
db.session.add(asset)
# one day of test data (one complete sine curve)
time_slots = pd.date_range(
datetime(2015, 1, 1), datetime(2015, 1, 1, 23, 45), freq="15T"
)
values = [random() * (1 + np.sin(x / 15)) for x in range(len(time_slots))]
for dt, val in zip(time_slots, values):
p = Power(
datetime=as_server_time(dt),
horizon=parse_duration("PT0M"),
value=val,
data_source_id=data_source.id,
)
p.asset = asset
db.session.add(p)
def create_test_battery_assets(
db: SQLAlchemy, setup_roles_users, setup_markets
) -> Dict[str, Asset]:
"""
Add two battery assets, set their capacity values and their initial SOC.
"""
db.session.add(
AssetType(
name="battery",
is_consumer=True,
is_producer=True,
can_curtail=True,
can_shift=True,
daily_seasonality=True,
weekly_seasonality=True,
yearly_seasonality=True,
)
)
test_battery = Asset(
name="Test battery",
owner_id=setup_roles_users["Test Prosumer User"].id,
asset_type_name="battery",
event_resolution=timedelta(minutes=15),
capacity_in_mw=2,
max_soc_in_mwh=5,
min_soc_in_mwh=0,
soc_in_mwh=2.5,
soc_datetime=as_server_time(datetime(2015, 1, 1)),
soc_udi_event_id=203,
latitude=10,
longitude=100,
market_id=setup_markets["epex_da"].id,
unit="MW",
)
db.session.add(test_battery)
test_battery_no_prices = Asset(
name="Test battery with no known prices",
owner_id=setup_roles_users["Test Prosumer User"].id,
asset_type_name="battery",
event_resolution=timedelta(minutes=15),
capacity_in_mw=2,
max_soc_in_mwh=5,
min_soc_in_mwh=0,
soc_in_mwh=2.5,
soc_datetime=as_server_time(datetime(2040, 1, 1)),
soc_udi_event_id=203,
latitude=10,
longitude=100,
market_id=setup_markets["epex_da"].id,
unit="MW",
)
db.session.add(test_battery_no_prices)
return {
"Test battery": test_battery,
"Test battery with no known prices": test_battery_no_prices,
}
def setup_ui_test_data(
db,
setup_accounts,
setup_roles_users,
setup_markets,
setup_sources,
setup_asset_types,
):
"""
Create another prosumer, without data, and an admin
Also, a weather sensor (and sensor type).
TODO: review if any of these are really needed (might be covered now by main conftest)
"""
print("Setting up data for UI tests on %s" % db.engine)
create_user(
username="******",
email="*****@*****.**",
password="******",
account_name=setup_accounts["Prosumer"].name,
user_roles=dict(name="admin", description="A site admin."),
)
test_user_ui = create_user(
username="******",
email="*****@*****.**",
password="******",
account_name=setup_accounts["Prosumer"].name,
)
asset = Asset(
name="solar pane 1",
display_name="Solar Pane 1",
asset_type_name="solar",
unit="MW",
capacity_in_mw=10,
latitude=10,
longitude=100,
min_soc_in_mwh=0,
max_soc_in_mwh=0,
soc_in_mwh=0,
)
db.session.add(asset)
asset.owner = test_user_ui
# Create 1 weather sensor
test_sensor_type = WeatherSensorType(name="irradiance")
db.session.add(test_sensor_type)
sensor = WeatherSensor(
name="irradiance_sensor",
weather_sensor_type_name="irradiance",
latitude=33.4843866,
longitude=126,
unit="kW/m²",
)
db.session.add(sensor)
print("Done setting up data for UI tests")
def setup_ui_test_data(db):
"""
Create another prosumer, without data, and an admin
Also, a weather sensor (and sensor type).
"""
print("Setting up data for UI tests on %s" % db.engine)
create_user(
username="******",
email="*****@*****.**",
password=hash_password("testtest"),
user_roles=dict(name="admin", description="A site admin."),
)
test_prosumer2 = create_user(
username="******",
email="*****@*****.**",
password=hash_password("testtest"),
user_roles=dict(name="Prosumer",
description="A Prosumer with one asset but no data."),
)
asset = Asset(
name="solar pane 1",
display_name="Solar Pane 1",
asset_type_name="solar",
unit="MW",
capacity_in_mw=10,
latitude=10,
longitude=100,
min_soc_in_mwh=0,
max_soc_in_mwh=0,
soc_in_mwh=0,
)
db.session.add(asset)
asset.owner = test_prosumer2
# Create 1 weather sensor
test_sensor_type = WeatherSensorType(name="radiation")
db.session.add(test_sensor_type)
sensor = WeatherSensor(
name="radiation_sensor",
weather_sensor_type_name="radiation",
latitude=33.4843866,
longitude=126,
unit="kW/m²",
)
db.session.add(sensor)
print("Done setting up data for UI tests")
def setup_fresh_test_data(
fresh_db,
setup_markets_fresh_db,
setup_roles_users_fresh_db,
setup_generic_asset_types_fresh_db,
app,
fresh_remove_seasonality_for_power_forecasts,
):
db = fresh_db
setup_roles_users = setup_roles_users_fresh_db
setup_markets = setup_markets_fresh_db
data_source = DataSource(name="Seita", type="demo script")
db.session.add(data_source)
db.session.flush()
for asset_name in ["wind-asset-2", "solar-asset-1"]:
asset = Asset(
name=asset_name,
asset_type_name="wind" if "wind" in asset_name else "solar",
event_resolution=timedelta(minutes=15),
capacity_in_mw=1,
latitude=10,
longitude=100,
min_soc_in_mwh=0,
max_soc_in_mwh=0,
soc_in_mwh=0,
unit="MW",
market_id=setup_markets["epex_da"].id,
)
asset.owner = setup_roles_users["Test Prosumer User"]
db.session.add(asset)
time_slots = pd.date_range(
datetime(2015, 1, 1), datetime(2015, 1, 1, 23, 45), freq="15T"
)
values = [random() * (1 + np.sin(x / 15)) for x in range(len(time_slots))]
beliefs = [
TimedBelief(
event_start=as_server_time(dt),
belief_horizon=parse_duration("PT0M"),
event_value=val,
sensor=asset.corresponding_sensor,
source=data_source,
)
for dt, val in zip(time_slots, values)
]
db.session.add_all(beliefs)
add_test_weather_sensor_and_forecasts(fresh_db, setup_generic_asset_types_fresh_db)
def setup_fresh_api_test_data(fresh_db, setup_roles_users_fresh_db):
db = fresh_db
setup_roles_users = setup_roles_users_fresh_db
from flexmeasures.data.models.assets import Asset, AssetType
# Create 5 test assets for the test_prosumer user
test_user = setup_roles_users["Test Prosumer User"]
test_asset_type = AssetType(name="test-type")
db.session.add(test_asset_type)
asset_names = ["CS 1", "CS 2", "CS 3", "CS 4", "CS 5"]
assets: List[Asset] = []
for asset_name in asset_names:
asset = Asset(
name=asset_name,
owner_id=test_user.id,
asset_type_name="test-type",
event_resolution=timedelta(minutes=15)
if not asset_name == "CS 4" else timedelta(hours=1),
capacity_in_mw=1,
latitude=100,
longitude=100,
unit="MW",
)
assets.append(asset)
db.session.add(asset)
def add_battery_assets(db: SQLAlchemy, setup_roles_users, setup_markets):
"""Add two battery assets, set their capacity values and their initial SOC."""
db.session.add(
AssetType(
name="battery",
is_consumer=True,
is_producer=True,
can_curtail=True,
can_shift=True,
daily_seasonality=True,
weekly_seasonality=True,
yearly_seasonality=True,
)
)
from flexmeasures.data.models.user import User, Role
user_datastore = SQLAlchemySessionUserDatastore(db.session, User, Role)
test_prosumer = user_datastore.find_user(email="*****@*****.**")
epex_da = Market.query.filter(Market.name == "epex_da").one_or_none()
battery = Asset(
name="Test battery",
asset_type_name="battery",
event_resolution=timedelta(minutes=15),
capacity_in_mw=2,
max_soc_in_mwh=5,
min_soc_in_mwh=0,
soc_in_mwh=2.5,
soc_datetime=as_server_time(datetime(2015, 1, 1)),
soc_udi_event_id=203,
latitude=10,
longitude=100,
market_id=epex_da.id,
unit="MW",
)
battery.owner = test_prosumer
db.session.add(battery)
battery = Asset(
name="Test battery with no known prices",
asset_type_name="battery",
event_resolution=timedelta(minutes=15),
capacity_in_mw=2,
max_soc_in_mwh=5,
min_soc_in_mwh=0,
soc_in_mwh=2.5,
soc_datetime=as_server_time(datetime(2040, 1, 1)),
soc_udi_event_id=203,
latitude=10,
longitude=100,
market_id=epex_da.id,
unit="MW",
)
battery.owner = test_prosumer
db.session.add(battery)
def process_internal_api_response(asset_data: dict,
asset_id: Optional[int] = None,
make_obj=False) -> Union[Asset, 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.
"""
asset_data.pop("status", None) # might have come from requests.response
if asset_id:
asset_data["id"] = asset_id
if make_obj:
asset_data["event_resolution"] = timedelta(
minutes=int(asset_data["event_resolution"]))
return Asset(**asset_data)
asset_data[
"event_resolution"] = asset_data["event_resolution"].seconds / 60
return asset_data
def setup_assets(
db, setup_roles_users, setup_markets, setup_sources, setup_asset_types
) -> Dict[str, Asset]:
"""Add assets to known test users.
Deprecated. Remove with Asset model."""
assets = []
for asset_name in ["wind-asset-1", "wind-asset-2", "solar-asset-1"]:
asset = Asset(
name=asset_name,
owner_id=setup_roles_users["Test Prosumer User"].id,
asset_type_name="wind" if "wind" in asset_name else "solar",
event_resolution=timedelta(minutes=15),
capacity_in_mw=1,
latitude=10,
longitude=100,
min_soc_in_mwh=0,
max_soc_in_mwh=0,
soc_in_mwh=0,
unit="MW",
market_id=setup_markets["epex_da"].id,
)
db.session.add(asset)
assets.append(asset)
# one day of test data (one complete sine curve)
time_slots = pd.date_range(
datetime(2015, 1, 1), datetime(2015, 1, 1, 23, 45), freq="15T"
)
values = [
random() * (1 + np.sin(x * 2 * np.pi / (4 * 24)))
for x in range(len(time_slots))
]
beliefs = [
TimedBelief(
event_start=as_server_time(dt),
belief_horizon=parse_duration("PT0M"),
event_value=val,
sensor=asset.corresponding_sensor,
source=setup_sources["Seita"],
)
for dt, val in zip(time_slots, values)
]
db.session.add_all(beliefs)
return {asset.name: asset for asset in assets}
def get_latest_power_as_plot(asset: Asset, small: bool = False) -> Tuple[str, str]:
"""Create a plot of an asset's latest power measurement as an embeddable html string (incl. javascript).
First returned string is the measurement time, second string is the html string."""
if current_app.config.get("FLEXMEASURES_MODE", "") == "play":
before = None # type:ignore
else:
before = server_now()
_, before = convert_query_window_for_demo((before, before))
latest_power = asset.latest_state(event_ends_before=before)
if latest_power is not None:
latest_power_value = latest_power.value
if current_app.config.get("FLEXMEASURES_MODE", "") == "demo":
latest_power_datetime = latest_power.datetime.replace(
year=datetime.now().year
)
else:
latest_power_datetime = latest_power.datetime
latest_measurement_time_str = localized_datetime_str(
latest_power_datetime + asset.event_resolution
)
else:
latest_power_value = 0
latest_measurement_time_str = "time unknown"
if latest_power_value < 0:
consumption = True
latest_power_value *= -1
else:
consumption = False
data = {
latest_measurement_time_str if not small else "": [0],
"Capacity in use": [latest_power_value],
"Remaining capacity": [asset.capacity_in_mw - latest_power_value],
}
percentage_capacity = latest_power_value / asset.capacity_in_mw
df = pd.DataFrame(data)
p = df.plot_bokeh(
kind="bar",
x=latest_measurement_time_str if not small else "",
y=["Capacity in use", "Remaining capacity"],
stacked=True,
colormap=[
"%s"
% Color(
hue=0.3 * min(1.0, 3 / 2 * percentage_capacity),
saturation=1,
luminance=min(0.5, 1 - percentage_capacity * 3 / 4),
).get_hex_l(), # 0% red, 38% yellow, 67% green, >67% darker green
"#f7ebe7",
],
alpha=0.7,
title=None,
xlabel=None,
ylabel="Power (%s)" % asset.unit,
zooming=False,
show_figure=False,
hovertool=None,
legend=None,
toolbar_location=None,
figsize=(200, 400) if not small else (100, 100),
ylim=(0, asset.capacity_in_mw),
xlim=(-0.5, 0.5),
)
p.xgrid.visible = False
for r in p.renderers:
try:
r.glyph.width = 1
except AttributeError:
pass
p.xaxis.ticker = []
p.add_layout(
BoxAnnotation(bottom=0, top=asset.capacity_in_mw, fill_color="#f7ebe7")
)
plot_html_str = pandas_bokeh.embedded_html(p)
hover_tool_str = "%s at %s %s (%s%% capacity).\nLatest state at %s." % (
"Consuming"
if consumption
else "Running"
if latest_power_value == 0
else "Producing",
round(latest_power_value, 3),
asset.unit,
round(100 * percentage_capacity),
latest_measurement_time_str,
)
return (
latest_measurement_time_str,
"""<div data-toggle="tooltip" data-placement="bottom" title="%s">%s</div>"""
% (hover_tool_str, plot_html_str),
)
def add_charging_station_assets(
db: SQLAlchemy, setup_roles_users, setup_markets
) -> Dict[str, Asset]:
"""Add uni- and bi-directional charging station assets, set their capacity value and their initial SOC."""
db.session.add(
AssetType(
name="one-way_evse",
is_consumer=True,
is_producer=False,
can_curtail=True,
can_shift=True,
daily_seasonality=True,
weekly_seasonality=True,
yearly_seasonality=True,
)
)
db.session.add(
AssetType(
name="two-way_evse",
is_consumer=True,
is_producer=True,
can_curtail=True,
can_shift=True,
daily_seasonality=True,
weekly_seasonality=True,
yearly_seasonality=True,
)
)
charging_station = Asset(
name="Test charging station",
owner_id=setup_roles_users["Test Prosumer User"].id,
asset_type_name="one-way_evse",
event_resolution=timedelta(minutes=15),
capacity_in_mw=2,
max_soc_in_mwh=5,
min_soc_in_mwh=0,
soc_in_mwh=2.5,
soc_datetime=as_server_time(datetime(2015, 1, 1)),
soc_udi_event_id=203,
latitude=10,
longitude=100,
market_id=setup_markets["epex_da"].id,
unit="MW",
)
db.session.add(charging_station)
bidirectional_charging_station = Asset(
name="Test charging station (bidirectional)",
owner_id=setup_roles_users["Test Prosumer User"].id,
asset_type_name="two-way_evse",
event_resolution=timedelta(minutes=15),
capacity_in_mw=2,
max_soc_in_mwh=5,
min_soc_in_mwh=0,
soc_in_mwh=2.5,
soc_datetime=as_server_time(datetime(2015, 1, 1)),
soc_udi_event_id=203,
latitude=10,
longitude=100,
market_id=setup_markets["epex_da"].id,
unit="MW",
)
db.session.add(bidirectional_charging_station)
return {
"Test charging station": charging_station,
"Test charging station (bidirectional)": bidirectional_charging_station,
}
def setup_api_test_data(db):
"""
Set up data for API v1 tests.
"""
print("Setting up data for API v1 tests on %s" % db.engine)
from flexmeasures.data.models.user import User, Role
from flexmeasures.data.models.assets import Asset, AssetType, Power
from flexmeasures.data.models.data_sources import DataSource
user_datastore = SQLAlchemySessionUserDatastore(db.session, User, Role)
# Create an anonymous user
create_user(
username="******",
email="*****@*****.**",
password=hash_password("testtest"),
user_roles=[
"Prosumer",
dict(name="anonymous", description="Anonymous test user"),
],
)
# Create 1 test asset for the anonymous user
test_prosumer = user_datastore.find_user(email="*****@*****.**")
test_asset_type = AssetType(name="test-type")
db.session.add(test_asset_type)
asset_names = ["CS 0"]
assets: List[Asset] = []
for asset_name in asset_names:
asset = Asset(
name=asset_name,
asset_type_name="test-type",
event_resolution=timedelta(minutes=15),
capacity_in_mw=1,
latitude=100,
longitude=100,
unit="MW",
)
asset.owner = test_prosumer
assets.append(asset)
db.session.add(asset)
# Create a test user without a USEF role
create_user(
username="******",
email="*****@*****.**",
password=hash_password("testtest"),
)
# Create 5 test assets for the test_prosumer user
test_prosumer = user_datastore.find_user(email="*****@*****.**")
asset_names = ["CS 1", "CS 2", "CS 3", "CS 4", "CS 5"]
assets: List[Asset] = []
for asset_name in asset_names:
asset = Asset(
name=asset_name,
asset_type_name="test-type",
event_resolution=timedelta(minutes=15),
capacity_in_mw=1,
latitude=100,
longitude=100,
unit="MW",
)
asset.owner = test_prosumer
if asset_name == "CS 4":
asset.event_resolution = timedelta(hours=1)
assets.append(asset)
db.session.add(asset)
# Add power forecasts to one of the assets, for two sources
cs_5 = Asset.query.filter(Asset.name == "CS 5").one_or_none()
test_supplier = user_datastore.find_user(email="*****@*****.**")
prosumer_data_source = DataSource.query.filter(
DataSource.user == test_prosumer).one_or_none()
supplier_data_source = DataSource.query.filter(
DataSource.user == test_supplier).one_or_none()
meter_data = []
for i in range(6):
p_1 = Power(
datetime=isodate.parse_datetime("2015-01-01T00:00:00Z") +
timedelta(minutes=15 * i),
horizon=timedelta(0),
value=(100.0 + i) * -1,
asset_id=cs_5.id,
data_source_id=prosumer_data_source.id,
)
p_2 = Power(
datetime=isodate.parse_datetime("2015-01-01T00:00:00Z") +
timedelta(minutes=15 * i),
horizon=timedelta(hours=0),
value=(1000.0 - 10 * i) * -1,
asset_id=cs_5.id,
data_source_id=supplier_data_source.id,
)
meter_data.append(p_1)
meter_data.append(p_2)
db.session.bulk_save_objects(meter_data)
print("Done setting up data for API v1 tests")
def add_charging_station_assets(db: SQLAlchemy, setup_roles_users, setup_markets):
"""Add uni- and bi-directional charging station assets, set their capacity value and their initial SOC."""
db.session.add(
AssetType(
name="one-way_evse",
is_consumer=True,
is_producer=False,
can_curtail=True,
can_shift=True,
daily_seasonality=True,
weekly_seasonality=True,
yearly_seasonality=True,
)
)
db.session.add(
AssetType(
name="two-way_evse",
is_consumer=True,
is_producer=True,
can_curtail=True,
can_shift=True,
daily_seasonality=True,
weekly_seasonality=True,
yearly_seasonality=True,
)
)
from flexmeasures.data.models.user import User, Role
user_datastore = SQLAlchemySessionUserDatastore(db.session, User, Role)
test_prosumer = user_datastore.find_user(email="*****@*****.**")
epex_da = Market.query.filter(Market.name == "epex_da").one_or_none()
charging_station = Asset(
name="Test charging station",
asset_type_name="one-way_evse",
event_resolution=timedelta(minutes=15),
capacity_in_mw=2,
max_soc_in_mwh=5,
min_soc_in_mwh=0,
soc_in_mwh=2.5,
soc_datetime=as_server_time(datetime(2015, 1, 1)),
soc_udi_event_id=203,
latitude=10,
longitude=100,
market_id=epex_da.id,
unit="MW",
)
charging_station.owner = test_prosumer
db.session.add(charging_station)
bidirectional_charging_station = Asset(
name="Test charging station (bidirectional)",
asset_type_name="two-way_evse",
event_resolution=timedelta(minutes=15),
capacity_in_mw=2,
max_soc_in_mwh=5,
min_soc_in_mwh=0,
soc_in_mwh=2.5,
soc_datetime=as_server_time(datetime(2015, 1, 1)),
soc_udi_event_id=203,
latitude=10,
longitude=100,
market_id=epex_da.id,
unit="MW",
)
bidirectional_charging_station.owner = test_prosumer
db.session.add(bidirectional_charging_station)
def setup_api_test_data(db):
"""
Set up data for API v1.1 tests.
"""
print("Setting up data for API v1.1 tests on %s" % db.engine)
from flexmeasures.data.models.user import User, Role
from flexmeasures.data.models.assets import Asset, AssetType
from flexmeasures.data.models.weather import WeatherSensor, WeatherSensorType
user_datastore = SQLAlchemySessionUserDatastore(db.session, User, Role)
# Create a user without proper registration as a data source
user = user_datastore.create_user(
username="******",
email="*****@*****.**",
password=hash_password("testtest"),
)
role = user_datastore.find_role("Prosumer")
user_datastore.add_role_to_user(user, role)
# Create a test user without a USEF role
create_user(
username="******",
email="*****@*****.**",
password=hash_password("testtest"),
)
# Create 3 test assets for the test_prosumer user
test_prosumer = user_datastore.find_user(email="*****@*****.**")
test_asset_type = AssetType(name="test-type")
db.session.add(test_asset_type)
asset_names = ["CS 1", "CS 2", "CS 3"]
assets: List[Asset] = []
for asset_name in asset_names:
asset = Asset(
name=asset_name,
asset_type_name="test-type",
event_resolution=timedelta(minutes=15),
capacity_in_mw=1,
latitude=100,
longitude=100,
unit="MW",
)
asset.owner = test_prosumer
assets.append(asset)
db.session.add(asset)
# Add power forecasts to the assets
cs_1 = Asset.query.filter(Asset.name == "CS 1").one_or_none()
cs_2 = Asset.query.filter(Asset.name == "CS 2").one_or_none()
cs_3 = Asset.query.filter(Asset.name == "CS 3").one_or_none()
data_source = DataSource.query.filter(
DataSource.user == test_prosumer).one_or_none()
power_forecasts = []
for i in range(6):
p_1 = Power(
datetime=isodate.parse_datetime("2015-01-01T00:00:00Z") +
timedelta(minutes=15 * i),
horizon=timedelta(hours=6),
value=(300 + i) * -1,
asset_id=cs_1.id,
data_source_id=data_source.id,
)
p_2 = Power(
datetime=isodate.parse_datetime("2015-01-01T00:00:00Z") +
timedelta(minutes=15 * i),
horizon=timedelta(hours=6),
value=(300 - i) * -1,
asset_id=cs_2.id,
data_source_id=data_source.id,
)
p_3 = Power(
datetime=isodate.parse_datetime("2015-01-01T00:00:00Z") +
timedelta(minutes=15 * i),
horizon=timedelta(hours=6),
value=(0 + i) * -1,
asset_id=cs_3.id,
data_source_id=data_source.id,
)
power_forecasts.append(p_1)
power_forecasts.append(p_2)
power_forecasts.append(p_3)
db.session.bulk_save_objects(power_forecasts)
# Create 2 weather sensors
test_sensor_type = WeatherSensorType(name="wind_speed")
db.session.add(test_sensor_type)
sensor = WeatherSensor(
name="wind_speed_sensor",
weather_sensor_type_name="wind_speed",
event_resolution=timedelta(minutes=5),
latitude=33.4843866,
longitude=126,
unit="m/s",
)
db.session.add(sensor)
test_sensor_type = WeatherSensorType(name="temperature")
db.session.add(test_sensor_type)
sensor = WeatherSensor(
name="temperature_sensor",
weather_sensor_type_name="temperature",
event_resolution=timedelta(minutes=5),
latitude=33.4843866,
longitude=126,
unit="°C",
)
db.session.add(sensor)
print("Done setting up data for API v1.1 tests")
def setup_api_test_data(db, setup_accounts, setup_roles_users, add_market_prices):
"""
Set up data for API v1.1 tests.
"""
print("Setting up data for API v1.1 tests on %s" % db.engine)
from flexmeasures.data.models.user import User, Role
from flexmeasures.data.models.assets import Asset, AssetType
user_datastore = SQLAlchemySessionUserDatastore(db.session, User, Role)
# Create a user without proper registration as a data source
user_datastore.create_user(
username="******",
email="*****@*****.**",
password=hash_password("testtest"),
account_id=setup_accounts["Prosumer"].id,
)
# Create 3 test assets for the test_user
test_user = setup_roles_users["Test Prosumer User"]
test_asset_type = AssetType(name="test-type")
db.session.add(test_asset_type)
asset_names = ["CS 1", "CS 2", "CS 3"]
assets: List[Asset] = []
for asset_name in asset_names:
asset = Asset(
name=asset_name,
owner_id=test_user.id,
asset_type_name="test-type",
event_resolution=timedelta(minutes=15),
capacity_in_mw=1,
latitude=100,
longitude=100,
unit="MW",
)
assets.append(asset)
db.session.add(asset)
# Add power forecasts to the assets
cs_1 = Asset.query.filter(Asset.name == "CS 1").one_or_none()
cs_2 = Asset.query.filter(Asset.name == "CS 2").one_or_none()
cs_3 = Asset.query.filter(Asset.name == "CS 3").one_or_none()
data_source = DataSource.query.filter(DataSource.user == test_user).one_or_none()
cs1_beliefs = [
TimedBelief(
event_start=isodate.parse_datetime("2015-01-01T00:00:00Z")
+ timedelta(minutes=15 * i),
belief_horizon=timedelta(hours=6),
event_value=(300 + i) * -1,
sensor=cs_1.corresponding_sensor,
source=data_source,
)
for i in range(6)
]
cs2_beliefs = [
TimedBelief(
event_start=isodate.parse_datetime("2015-01-01T00:00:00Z")
+ timedelta(minutes=15 * i),
belief_horizon=timedelta(hours=6),
event_value=(300 - i) * -1,
sensor=cs_2.corresponding_sensor,
source=data_source,
)
for i in range(6)
]
cs3_beliefs = [
TimedBelief(
event_start=isodate.parse_datetime("2015-01-01T00:00:00Z")
+ timedelta(minutes=15 * i),
belief_horizon=timedelta(hours=6),
event_value=(0 + i) * -1,
sensor=cs_3.corresponding_sensor,
source=data_source,
)
for i in range(6)
]
db.session.add_all(cs1_beliefs + cs2_beliefs + cs3_beliefs)
add_legacy_weather_sensors(db)
print("Done setting up data for API v1.1 tests")
def setup_api_test_data(db, setup_accounts, setup_roles_users,
add_market_prices):
"""
Set up data for API v1 tests.
"""
print("Setting up data for API v1 tests on %s" % db.engine)
from flexmeasures.data.models.assets import Asset, AssetType
from flexmeasures.data.models.data_sources import DataSource
# Create an anonymous user TODO: used for demo purposes, maybe "demo-user" would be a better name
test_anonymous_user = create_user(
username="******",
email="*****@*****.**",
password="******",
account_name=setup_accounts["Dummy"].name,
user_roles=[
dict(name="anonymous", description="Anonymous test user"),
],
)
# Create 1 test asset for the anonymous user
test_asset_type = AssetType(name="test-type")
db.session.add(test_asset_type)
asset_names = ["CS 0"]
assets: List[Asset] = []
for asset_name in asset_names:
asset = Asset(
name=asset_name,
owner_id=test_anonymous_user.id,
asset_type_name="test-type",
event_resolution=timedelta(minutes=15),
capacity_in_mw=1,
latitude=100,
longitude=100,
unit="MW",
)
assets.append(asset)
db.session.add(asset)
# Create 5 test assets for the test user
test_user = setup_roles_users["Test Prosumer User"]
asset_names = ["CS 1", "CS 2", "CS 3", "CS 4", "CS 5"]
assets: List[Asset] = []
for asset_name in asset_names:
asset = Asset(
name=asset_name,
owner_id=test_user.id,
asset_type_name="test-type",
event_resolution=timedelta(minutes=15)
if not asset_name == "CS 4" else timedelta(hours=1),
capacity_in_mw=1,
latitude=100,
longitude=100,
unit="MW",
)
assets.append(asset)
db.session.add(asset)
# Add power forecasts to one of the assets, for two sources
cs_5 = Asset.query.filter(Asset.name == "CS 5").one_or_none()
user1_data_source = DataSource.query.filter(
DataSource.user == test_user).one_or_none()
test_user_2 = setup_roles_users["Test Prosumer User 2"]
user2_data_source = DataSource.query.filter(
DataSource.user == test_user_2).one_or_none()
user1_beliefs = [
TimedBelief(
event_start=isodate.parse_datetime("2015-01-01T00:00:00Z") +
timedelta(minutes=15 * i),
belief_horizon=timedelta(0),
event_value=(100.0 + i) * -1,
sensor=cs_5.corresponding_sensor,
source=user1_data_source,
) for i in range(6)
]
user2_beliefs = [
TimedBelief(
event_start=isodate.parse_datetime("2015-01-01T00:00:00Z") +
timedelta(minutes=15 * i),
belief_horizon=timedelta(hours=0),
event_value=(1000.0 - 10 * i) * -1,
sensor=cs_5.corresponding_sensor,
source=user2_data_source,
) for i in range(6)
]
db.session.add_all(user1_beliefs + user2_beliefs)
print("Done setting up data for API v1 tests")