def test_market_with_most_expensive_offer(self):
m1 = MagicMock(spec=Market)
o1 = MagicMock(spec=Offer)
o1.price = 12
o1.energy = 1
m2 = MagicMock(spec=Market)
o2 = MagicMock(spec=Offer)
o2.price = 12
o2.energy = 1
m3 = MagicMock(spec=Market)
o3 = MagicMock(spec=Offer)
o3.price = 12
o3.energy = 1
markets = OrderedDict()
markets[DateTime(2018, 1, 1, 12, 0, 0)] = m1
markets[DateTime(2018, 1, 1, 12, 15, 0)] = m2
markets[DateTime(2018, 1, 1, 12, 30, 0)] = m3
self.area._markets = MagicMock(spec=AreaMarkets)
self.area._markets.markets = markets
m1.sorted_offers = [o1, o1]
m2.sorted_offers = [o2, o2]
m3.sorted_offers = [o3, o3]
assert self.area.market_with_most_expensive_offer is m1
o1.price = 19
o2.price = 20
o3.price = 18
assert self.area.market_with_most_expensive_offer is m2
o1.price = 18
o2.price = 19
o3.price = 20
assert self.area.market_with_most_expensive_offer is m3
def test_flex_time_zone_changes(
year, month, day, hour, minute, second, microsecond, tzinfo,
fold, granularity):
"""Test time zone changes for FlexTime class"""
full_dt_info = DateTimeInfo(
year, month, day, hour, minute, second, microsecond, tzinfo, fold)
gval = granularity.value
dt_info = FlexTime.form_info(
full_dt_info, granularity=gval, truncate=True, default=False)
flex_dt = FlexTime(*dt_info)
dt_info_native = FlexTime.form_info(
full_dt_info, granularity=gval, truncate=True, default=True,
tz_instance=True)
base_dt = DateTime(**dt_info_native._asdict())
assert flex_dt == base_dt
flex_dt_utc = flex_dt.astimezone(UTC)
base_dt_utc = base_dt.astimezone(timezone(UTC))
assert flex_dt_utc == base_dt_utc
assert type(flex_dt_utc) is type(flex_dt)
flex_dt_there_and_back_again = flex_dt_utc.astimezone(tzinfo)
base_dt_there_and_back_again = base_dt_utc.astimezone(timezone(tzinfo))
assert flex_dt_there_and_back_again == base_dt_there_and_back_again
assert flex_dt_there_and_back_again == flex_dt
def test_export_unmatched_loads_support_the_all_devices_parameter(self):
house1 = Area("House1", [self.area1, self.area2])
self.grid = Area("Grid", [house1, self.area3])
self.grid._markets.past_markets = {}
for i in range(1, 11):
timeslot = DateTime(2018, 1, 1, 12 + i, 0, 0)
self.strategy1.state.desired_energy_Wh[timeslot] = 100
self.strategy2.state.desired_energy_Wh[timeslot] = 100
self.strategy3.state.desired_energy_Wh[timeslot] = 100
mock_market = MagicMock(spec=Market)
mock_market.time_slot = timeslot
mock_market.traded_energy = {
"load1": -0.101,
"load2": -0.101,
"load3": -0.07
}
house1._markets.past_markets[timeslot] = mock_market
self.grid._markets.past_markets[timeslot] = mock_market
unmatched_loads = export_unmatched_loads(self.grid, all_devices=True)
print(unmatched_loads)
assert self.area3.name in unmatched_loads["areas"]
assert unmatched_loads["areas"][
self.area3.name]["unmatched_load_count"] == 10
assert unmatched_loads["unmatched_load_count"] == 10
assert not unmatched_loads["all_loads_met"]
def test_export_unmatched_loads_reports_cell_tower_areas(self):
house1 = Area("House1", [self.area1, self.area2])
ct_strategy = MagicMock(spec=CellTowerLoadHoursStrategy)
ct_strategy.state = MagicMock(spec=LoadState)
ct_strategy.state.desired_energy_Wh = {}
cell_tower = Area("Cell Tower", strategy=ct_strategy)
self.grid = Area("Grid", [house1, cell_tower])
for i in range(1, 11):
timeslot = DateTime(2018, 1, 1, 12 + i, 0, 0)
self.strategy1.state.desired_energy_Wh[timeslot] = 100
self.strategy2.state.desired_energy_Wh[timeslot] = 100
mock_market = MagicMock(spec=Market)
mock_market.time_slot = timeslot
mock_market.traded_energy = {"load1": -0.09, "load2": -0.099}
house1._markets.past_markets[timeslot] = mock_market
mock_market_ct = MagicMock(spec=Market)
mock_market_ct.time_slot = timeslot
mock_market_ct.traded_energy = {"Cell Tower": -0.4}
ct_strategy.state.desired_energy_Wh[timeslot] = 1000
cell_tower._markets.past_markets[timeslot] = mock_market_ct
self.grid._markets.past_markets[timeslot] = mock_market
unmatched_loads = export_unmatched_loads(self.grid)
assert unmatched_loads["unmatched_load_count"] == 30
assert not unmatched_loads["all_loads_met"]
def test_should_works_with_datetime_formatter(self):
decorator = format_parameters({"param_a": format_datetime})
endpoint = mock.MagicMock()
decorated_endpoint = decorator(endpoint)
decorated_endpoint(param_a='2020-01-01T0:0:00+00:00')
endpoint.assert_called_once_with(
param_a=DateTime(2020, 1, 1, 0, tzinfo=Timezone('UTC')))
def deflex(self, native=False):
"""Deflex instance by creating copy with parent DateTime"""
dt_info = self.form_info(self,
granularity=self.MAX_GRANULARITY,
default=True,
tz_instance=True)
dt_kwds = dt_info._asdict()
return (datetime.datetime(**dt_kwds) if native else DateTime(
**dt_kwds))
def create_profile_from_daily_profile(n_days=365, year=2019, daily_profile_fn=None, out_fn=None,
separator=","):
if daily_profile_fn is None:
raise ValueError("No daily_profile_fn was provided")
header, daily_profile_dict = read_daily_profile_todict(daily_profile_fn, separator)
profile_dict = {}
for day in range(1, n_days):
for time, value in daily_profile_dict.items():
profile_dict[DateTime(year, 1, 1).add(
days=day - 1, hours=time.hour, minutes=time.minute)] = value
if out_fn is None:
out_fn = daily_profile_fn.replace(".csv", "_year.csv")
write_profile_todict(profile_dict, header, out_fn, separator)
def test_export_unmatched_loads_is_reported_correctly_for_predefined_load_strategy(
self):
house1 = Area("House1", [self.area1, self.area3])
self.grid = Area("Grid", [house1])
self.grid._markets.past_markets = {}
for i in range(1, 11):
timeslot = DateTime(2018, 1, 1, 12 + i, 0, 0)
mock_market = MagicMock(spec=Market)
mock_market.time_slot = timeslot
self.strategy1.state.desired_energy_Wh[timeslot] = 100
self.strategy3.state.desired_energy_Wh[timeslot] = 80
mock_market.traded_energy = {"load1": -0.099, "load3": -0.079}
house1._markets.past_markets[timeslot] = mock_market
self.grid._markets.past_markets[timeslot] = mock_market
unmatched_loads = export_unmatched_loads(self.grid)
assert unmatched_loads["unmatched_load_count"] == 20
assert not unmatched_loads["all_loads_met"]
def test_core_flex_time_interactions(
year, month, day, hour, minute, second, microsecond, tzinfo,
fold, granularity):
"""Test core interactions for FlexTime class"""
full_dt_info = DateTimeInfo(
year, month, day, hour, minute, second, microsecond, tzinfo, fold)
gval = granularity.value
dt_info = FlexTime.form_info(
full_dt_info, granularity=gval, truncate=True, default=False)
dt_info_native = FlexTime.form_info(
full_dt_info, granularity=gval, truncate=True, default=True,
tz_instance=True)
dt_native_kwargs = dt_info_native._asdict()
native_dt = datetime(**dt_native_kwargs)
base_dt = DateTime(**dt_info_native._asdict())
flex_dt = FlexTime(*dt_info)
assert flex_dt.info == dt_info
assert flex_dt.deflex() == base_dt
assert flex_dt.deflex(native=True) == native_dt
flex_dt_via_copy = flex_dt.copy()
assert flex_dt_via_copy is not flex_dt
assert flex_dt_via_copy == flex_dt
flex_dt_via_cast_native = FlexTime.cast(native_dt, granularity=granularity)
assert flex_dt_via_cast_native == flex_dt
assert flex_dt_via_cast_native is not flex_dt
flex_dt_via_cast_base = FlexTime.cast(base_dt, granularity=granularity)
assert flex_dt_via_cast_base == flex_dt
assert flex_dt_via_cast_base is not flex_dt
flex_dt_via_cast_flex = FlexTime.cast(flex_dt, granularity=granularity)
assert flex_dt_via_cast_flex is flex_dt
def test_is_past():
with pendulum.test(DateTime(2000, 1, 1)):
d = pendulum.now()
assert not d.is_past()
d = d.subtract(days=1)
assert d.is_past()
def test_is_future():
with pendulum.test(DateTime(2000, 1, 1)):
d = pendulum.now()
assert not d.is_future()
d = d.add(days=1)
assert d.is_future()
from run import PVOutput
from pendulum import DateTime
import csv
from pathlib import Path
siteId = '57775'
directory = Path('directory'+siteId)
if not directory.exists():
directory.mkdir()
# if not logged in then this will only work for th last 14 days
testDate = DateTime(2019, 2, 1)
pvo = PVOutput()
pvo.login('username', 'password')
for idx in range(1,140):
dateString = testDate.to_date_string()
print('creating file ', dateString)
try:
data = pvo.getIntradayData(testDate, siteId)
except NameError as e:
print(e)
print("missing data for " + dateString)
testDate = testDate.add(days=1)
continue
with open(directory.as_posix() + f'/{dateString}.csv','w', newline='') as csvFile:
dataFile = csv.writer(csvFile)
dataFile.writerow(data.headers)
def test_flex_time_instantiation(
year, month, day, hour, minute, second, microsecond, tzinfo,
fold, granularity):
"""Test core instantiation methods for FlexTime class"""
full_dt_info = DateTimeInfo(
year, month, day, hour, minute, second, microsecond, tzinfo, fold)
gval = granularity.value
dt_info = FlexTime.form_info(
full_dt_info, granularity=gval, truncate=True, default=False)
dt_tuple = tuple(dt_info)
dt_info_with_defaults = FlexTime.form_info(
full_dt_info, granularity=gval, truncate=True, default=True)
dt_info_native = FlexTime.form_info(
full_dt_info, granularity=gval, truncate=True, default=True,
tz_instance=True)
dt_native_kwargs = dt_info_native._asdict()
native_dt = datetime(**dt_native_kwargs)
dt_native_args = dt_info_native[:FlexTime.FOLD_IDX]
native_dt_via_args = datetime(fold=fold, *dt_native_args)
assert native_dt == native_dt_via_args
dt_naive_kwargs = dt_info_native._asdict()
del dt_naive_kwargs[FlexTime.TZINFO_TAG]
naive_dt = datetime(**dt_naive_kwargs)
dt_naive_args = dt_info_native[:FlexTime.TZINFO_IDX]
naive_dt_via_args = datetime(fold=fold, *dt_naive_args)
assert naive_dt == naive_dt_via_args
# base_dt = DateTime(**dt_info_with_defaults._asdict())
base_dt = DateTime(**dt_info_native._asdict())
# base_dt_via_args = DateTime(*dt_info_with_defaults)
base_dt_via_args = DateTime(fold=fold, *dt_native_args)
assert base_dt == base_dt_via_args
assert native_dt == base_dt
flex_dt = FlexTime(**dt_info._asdict())
flex_dt_via_args = FlexTime(tzinfo=dt_info.tzinfo, *dt_info[:gval])
assert flex_dt == flex_dt_via_args
assert flex_dt == base_dt
assert flex_dt == native_dt # True only if not in DST
for dt in (dt_info, dt_tuple, native_dt, naive_dt, base_dt, flex_dt,
flex_dt.info):
tz = dt_info.tzinfo if dt is naive_dt else None
dt_info_null_backfill = FlexTime.form_info(
dt, tz=tz, granularity=granularity, truncate=True, default=False)
assert dt_info_null_backfill == dt_info
dt_info_default_backfill = FlexTime.form_info(
dt, tz=tz, granularity=granularity, truncate=True, default=True)
assert dt_info_default_backfill == dt_info_with_defaults
flex_dt_via_instance = FlexTime.instance(dt, tz=tz,
granularity=granularity)
assert flex_dt_via_instance == flex_dt
assert flex_dt_via_instance is not flex_dt
assert flex_dt_via_instance.info == dt_info # True only if not in DST