def convert(self, value, param, ctx):
matches = re.findall(self.SYNTAX_REGEX, value, re.IGNORECASE)
# If nothing matches ==> unknown syntax ==> fallback to DateTime parsing
if not matches:
return super().convert(value, param, ctx)
base = pendulum.duration()
for match in matches:
unit = self.MAPPING[match[1].lower()]
base += pendulum.duration(**{unit: int(match[0])})
return base
def test_in_french():
pi = pendulum.duration(
years=2, months=3, days=1177, seconds=7284, microseconds=1000000
)
expected = "2 ans 3 mois 168 semaines 1 jour 2 heures 1 minute 25 secondes"
assert pi.in_words(locale="fr") == expected
def test_ls(self, cmd, fake, factories):
midpoint = pendulum.now(tz='utc') - pendulum.duration(days=2)
start = fake.date_time_between(start_date="-5d", end_date=midpoint,)
factories.TimeEntryFactory(start=start, stop=fake.date_time_between(start_date=start, end_date=midpoint,))
start = fake.date_time_between(start_date="-5d", end_date=midpoint,)
factories.TimeEntryFactory(start=start, stop=fake.date_time_between(start_date=start, end_date=midpoint,))
start = fake.date_time_between(start_date="-5d", end_date=midpoint,)
factories.TimeEntryFactory(start=start, stop=fake.date_time_between(start_date=start, end_date=midpoint,))
start = fake.date_time_between(start_date=midpoint, end_date='now',)
factories.TimeEntryFactory(start=start)
start = fake.date_time_between(start_date=midpoint, end_date='now',)
factories.TimeEntryFactory(start=start)
start = fake.date_time_between(start_date=midpoint, end_date='now',)
factories.TimeEntryFactory(start=start)
start = fake.date_time_between(start_date=midpoint, end_date='now',)
factories.TimeEntryFactory(start=start)
result = cmd('ls')
parsed = result.parse_list()
assert len(parsed) == 7
result = cmd('ls --start \'{}\''.format(midpoint.format('MMM D HH:mm:ss')))
parsed = result.parse_list()
assert len(parsed) == 4
result = cmd('ls --stop \'{}\''.format(midpoint.format('MMM D HH:mm:ss')))
parsed = result.parse_list()
assert len(parsed) == 3
def test_all():
pi = pendulum.duration(
years=2, months=3, days=1177, seconds=7284, microseconds=1000000
)
expected = "2 years 3 months 168 weeks 1 day 2 hours 1 minute 25 seconds"
assert pi.in_words() == expected
def test_all():
pi = pendulum.duration(
years=2, months=3, days=1177, seconds=7284, microseconds=1000000
)
assert_duration(pi, 2, 3, 168, 1, 2, 1, 25)
assert 1997 == pi.days
assert 7285 == pi.seconds
def test_as_timedelta():
pi = pendulum.duration(seconds=3456.123456)
assert_duration(pi, 0, 0, 0, 0, 0, 57, 36, 123456)
delta = pi.as_timedelta()
assert isinstance(delta, timedelta)
assert 3456.123456 == delta.total_seconds()
assert 3456 == delta.seconds
def get_durations(log_records):
"""Calculate visit duration per day per IP"""
timezone = cherrypy.engine.publish(
"registry:local_timezone"
).pop()
maximums = defaultdict(int)
minimums = defaultdict(int)
for row in log_records:
timestamp = row["unix_timestamp"]
formatted_timestamp = pendulum.from_timestamp(
timestamp
).in_timezone(timezone).format('YYYY-MM-DD')
lookup_key = (row["ip"], formatted_timestamp)
if lookup_key not in maximums or timestamp > maximums[lookup_key]:
maximums[lookup_key] = timestamp
continue
if lookup_key not in minimums or timestamp < minimums[lookup_key]:
minimums[lookup_key] = timestamp
durations = {
lookup_key: pendulum.duration(
seconds=(maximums[lookup_key] - minimums[lookup_key])
)
for lookup_key in maximums
if minimums[lookup_key] > 0
}
return durations
def time_duration(**kwargs):
"""Convert a time interval expressed in one or more units to a human
readable string.
This is a wrapper for the Pendulum Duration class, so kwargs
should match the keywords supported there.
"""
return pendulum.duration(**kwargs).in_words()
def test_repr():
pi = pendulum.duration(
years=2, months=3, days=1177, seconds=7284, microseconds=1000000
)
expected = (
"Duration(years=2, months=3, weeks=168, days=1, hours=2, minutes=1, seconds=25)"
)
assert repr(pi) == expected
def test_device_operating_hours_deduction_with_partial_trade(
load_hours_strategy_test5, market_test2):
market_test2.most_affordable_energy = 0.1
load_hours_strategy_test5.event_activate()
# load_hours_strategy_test5.area.past_markets = {TIME: market_test2}
load_hours_strategy_test5.event_market_cycle()
load_hours_strategy_test5.event_tick()
assert round(((float(load_hours_strategy_test5.accept_offer.call_args[0][1].energy) *
1000 / load_hours_strategy_test5.energy_per_slot_Wh) *
(load_hours_strategy_test5.area.config.slot_length / duration(hours=1))), 2) == \
round(((0.1/0.155) * 0.25), 2)
def test_duration_from_string_success(self):
"""
This test verifies that the duration_from_string method can be used to
parse a duration from a string with expected formats
"""
expected_duration = pendulum.duration(days=12, hours=1, seconds=1)
computed_duration = duration_from_string('12d1h1s')
assert computed_duration == expected_duration
expected_duration = pendulum.duration(months=1, hours=2, minutes=3)
computed_duration = duration_from_string('1 Month 2 Hours 3 minutes')
assert computed_duration == expected_duration
expected_duration = pendulum.duration(days=1, minutes=2, seconds=3)
computed_duration = duration_from_string('1day,2min,3sec')
assert computed_duration == expected_duration
expected_duration = pendulum.duration(months=1, minutes=2)
computed_duration = duration_from_string('1mo,2m')
assert computed_duration == expected_duration
def cleanse_time(time_):
if isinstance(time_, int):
now = pendulum.now()
date = pendulum.DateTime(
now.year, now.month,
now.day) + pendulum.duration(seconds=time_)
time_ = date.strftime('%H:%M:%S')
if isinstance(time_, str):
pendulum.DateTime.strptime(time_, '%H:%M:%S')
return time_
def grant_subscription_with_promotion_code(self,
promotion_code=None,
now=None):
type_and_duration = self.redeem_promotion_client.get_promo_information(
promotion_code)
if not type_and_duration:
raise UserException(
f'User `{self.id}` - Promotion code is not valid',
[PromotionCodeError.NOT_VALID])
now = now or pendulum.now('utc')
if self.item.get('subscriptionGrantedAt') and self.item.get(
'subscriptionExpiresAt'):
now = pendulum.parse(self.item.get('subscriptionExpiresAt'))
promotion_type = type_and_duration.get('type')
duration = type_and_duration.get('duration')
if promotion_type != 'Diamond':
raise UserException(
f'User `{self.id}` - Promotion type is not DIAMOND')
grant_code = None
if duration == SubscriptionGrantCode.FREE_FOR_LIFE:
grant_code = SubscriptionGrantCode.FREE_FOR_LIFE
expires_at = now + SUBSCRIPTION_GRANT_DURATION[grant_code]
else:
expires_at = now + pendulum.duration(days=float(duration))
try:
self.item = self.dynamo.update_subscription(
self.id,
UserSubscriptionLevel.DIAMOND,
granted_at=now,
expires_at=expires_at,
grant_code=grant_code,
promotion_code=promotion_code,
)
except UserAlreadyGrantedSubscription as err:
raise UserException(
f'User `{self.id}` has already granted themselves a subscription bonus',
[PromotionCodeError.ALREADY_GRANTED],
) from err
# store user promotion code record
self.dynamo.add_user_promoted_record(
user_id=self.id,
promotion_code=promotion_code,
promotion_type=promotion_type,
granted_at=now,
expires_at=expires_at,
)
return self
def test_add_project(self, cmd, fake, config, factories):
project = factories.ProjectFactory()
start = pendulum.instance(fake.past_datetime(start_date='-9d'))
end = start + pendulum.duration(hours=2)
cmd('projects ls')
result = cmd('add \'{}\' \'{}\' \'{}\' --project \'{}\''
.format(start.format('MMM D HH:mm:ss'), end.format('MMM D HH:mm:ss'), fake.sentence(), project.name))
assert result.obj.exit_code == 0
entry = TimeEntry.objects.get(result.created_id(), config=config) # type: TimeEntry
assert entry.project == project
start = pendulum.instance(fake.past_datetime(start_date='-9d'))
end = start + pendulum.duration(hours=2)
result = cmd('add \'{}\' \'{}\' \'{}\' --project \'{}\''
.format(start.format('MMM D HH:mm:ss'), end.format('MMM D HH:mm:ss'), fake.sentence(), project.id))
assert result.obj.exit_code == 0
entry = TimeEntry.objects.get(result.created_id(), config=config) # type: TimeEntry
assert entry.project == project
def test_correct_interpolation_power_profile():
slot_length = 20
GlobalConfig.slot_length = duration(minutes=slot_length)
profile_path = pathlib.Path(d3a_path +
'/resources/Solar_Curve_W_sunny.csv')
profile = read_arbitrary_profile(InputProfileTypes.POWER,
str(profile_path))
times = list(profile)
for ii in range(len(times) - 1):
assert abs(
(times[ii] - times[ii + 1]).in_seconds()) == slot_length * 60
def _create_market_mocks(self, num_of_markets=3):
market_mocks = [
create_autospec(OneSidedMarket) for _ in range(num_of_markets)
]
slot_time = self.slot_times[0]
for market_mock in market_mocks:
market_mock.time_slot = slot_time
market_mock.id = uuid.uuid4()
slot_time += duration(minutes=15)
return market_mocks
def check_load_profile(context):
if isinstance(context._device_profile, str):
context._device_profile = context._device_profile_dict
house1 = list(
filter(lambda x: x.name == "House 1",
context.simulation.area.children))[0]
load = list(filter(lambda x: x.name == "H1 Load", house1.children))[0]
for timepoint, energy in load.strategy.state.desired_energy_Wh.items():
assert energy == context._device_profile[timepoint] / \
(duration(hours=1) / load.config.slot_length)
def setUp(self):
self.appliance = MagicMock(spec=SimpleAppliance)
self.strategy1 = MagicMock(spec=LoadHoursStrategy)
self.strategy1.state = MagicMock(spec=LoadState)
self.strategy1.state.desired_energy_Wh = {}
self.strategy2 = MagicMock(spec=LoadHoursStrategy)
self.strategy2.state = MagicMock(spec=LoadState)
self.strategy2.state.desired_energy_Wh = {}
self.strategy3 = MagicMock(spec=DefinedLoadStrategy)
self.strategy3.state = MagicMock(spec=LoadState)
self.strategy3.state.desired_energy_Wh = {}
self.config = MagicMock(spec=SimulationConfig)
self.config.slot_length = duration(minutes=15)
self.config.tick_length = duration(seconds=15)
self.config.start_date = today(tz=TIME_ZONE)
self.config.grid_fee_type = 1
self.area1 = Area("load1",
None,
None,
self.strategy1,
self.appliance,
self.config,
None,
grid_fee_percentage=0)
self.area2 = Area("load2",
None,
None,
self.strategy2,
self.appliance,
self.config,
None,
grid_fee_percentage=0)
self.area3 = Area("load3",
None,
None,
self.strategy3,
self.appliance,
self.config,
None,
grid_fee_percentage=0)
def pv_profile_scenario(context):
predefined_pv_scenario = {
"name":
"Grid",
"children": [{
"name": "Commercial Energy Producer",
"type": "CommercialProducer",
"energy_rate": 15.5
}, {
"name":
"House 1",
"children": [{
"name": "H1 Load",
"type": "LoadHours",
"avg_power_W": 400,
"hrs_per_day": 24
}, {
"name": "H1 PV",
"type": "PVProfile",
"panel_count": 1,
"power_profile": context._device_profile
}]
}, {
"name":
"House 2",
"children": [{
"name": "H2 Storage",
"type": "Storage",
"initial_capacity_kWh": 5,
"battery_capacity_kWh": 12.5,
}]
}]
}
context._settings = SimulationConfig(tick_length=duration(seconds=15),
slot_length=duration(minutes=15),
duration=duration(hours=24),
market_count=4,
cloud_coverage=0,
market_maker_rate=30,
iaa_fee=5)
context._settings.area = predefined_pv_scenario
def run_sim_multiday(context, scenario, start_date, total_duration,
slot_length, tick_length):
root_logger = logging.getLogger()
root_logger.setLevel(logging.CRITICAL)
if start_date == "None":
start_date = today(tz=TIME_ZONE)
else:
start_date = from_format(start_date, DATE_FORMAT)
simulation_config = SimulationConfig(duration(hours=int(total_duration)),
duration(minutes=int(slot_length)),
duration(seconds=int(tick_length)),
market_count=1,
cloud_coverage=0,
market_maker_rate=30,
iaa_fee=1,
start_date=start_date)
slowdown = 0
seed = 0
paused = False
pause_after = duration()
repl = False
no_export = True
export_path = None
export_subdir = None
context.simulation = Simulation(
scenario,
simulation_config,
None,
slowdown,
seed,
paused,
pause_after,
repl,
no_export,
export_path,
export_subdir,
)
context.simulation.run()
def run_sim(context, scenario, total_duration, slot_length, tick_length,
market_count):
root_logger = logging.getLogger()
root_logger.setLevel(logging.CRITICAL)
simulation_config = SimulationConfig(duration(hours=int(total_duration)),
duration(minutes=int(slot_length)),
duration(seconds=int(tick_length)),
market_count=int(market_count),
cloud_coverage=0,
market_maker_rate=30,
external_connection_enabled=False)
slowdown = 0
seed = 0
paused = False
pause_after = duration()
repl = False
no_export = True
export_path = None
export_subdir = None
try:
context.simulation = Simulation(
scenario,
simulation_config,
None,
slowdown,
seed,
paused,
pause_after,
repl,
no_export,
export_path,
export_subdir,
)
context.simulation.run()
except Exception as er:
root_logger.critical(
f"Error reported when running the simulation: {er}")
context.sim_error = er
class Config(object):
"""Base Configuration for the Application Instance"""
# Secret Key
SECRET_KEY = os.environ.get('SECRET_KEY') or 'you-will-never-guess'
# Database Configuration
USER = os.environ.get('POSTGRES_USER') or 'mindful'
PASSWORD = os.environ.get('POSTGRES_PASSWORD') or 'secret-passkey'
DATABASE_NAME = os.environ.get('POSTGRES_DB') or 'mindful_db'
SQL_HOST = 'db'
SQL_PORT = os.environ.get('POSTGRES_PORT') or 5432
SQLALCHEMY_DATABASE_URI = f'postgresql+psycopg2://{USER}:{PASSWORD}@{SQL_HOST}:{SQL_PORT}/{DATABASE_NAME}' or \
"sqlite:///{}".format(os.path.join(APP_DIR, 'app.db'))
SQLALCHEMY_TRACK_MODIFICATIONS = False
# Mail Configuration
MAIL_SERVER = os.environ.get('MAIL_SERVER') or None
MAIL_USE_TLS = True
MAIL_PORT = os.environ.get('MAIL_PORT') or None
MAIL_USERNAME = os.environ.get('MAIL_USERNAME') or None
MAIL_PASSWORD = os.environ.get('MAIL_PASSWORD') or None
# Authentication Configurations
JWT_ACCESS_LIFESPAN = pendulum.duration(hours=24)
JWT_REFRESH_LIFESPAN = pendulum.duration(days=30)
PRAETORIAN_CONFIRMATION_SENDER = MAIL_USERNAME
PRAETORIAN_CONFIRMATION_SUBJECT = 'Welcome to Mindful [Please Confirm your email!]'
PRAETORIAN_CONFIRMATION_TEMPLATE = os.path.join(TEMPLATE_DIR,
'registration_email.html')
OAUTH_CREDENTIALS = {
'google': {
'id': os.environ.get('GOOGLE_OAUTH_CLIENTID'),
'secret': os.environ.get('GOOGLE_OAUTH_CLIENT_SECRET')
}
}
CLIENT_URL = "http://localhost:8080/#"
def convert_energy_profile_to_power(input_profile, output_file):
profile = _readCSV(input_profile)
# Create a minute-resolution profile, filling the empty slots with previous values
profile = _fill_gaps_in_profile(profile)
GlobalConfig.sim_duration = duration(days=1) - duration(minutes=1)
output_dict = default_profile_dict(0)
for k, v in output_dict.items():
# Average market slot values
iter_duration = duration(minutes=0)
averaged_value = 0
while iter_duration < GlobalConfig.slot_length:
averaged_value += profile[k + iter_duration]
iter_duration += duration(minutes=1)
averaged_value /= GlobalConfig.slot_length.minutes
output_dict[k] = averaged_value
power_profile = {k: convert_energy_to_power(float(v)) for k, v in output_dict.items()}
with open(output_file, 'w') as csv_file:
writer = csv.writer(csv_file)
for key, value in power_profile.items():
writer.writerow([key, value])
def test_add_tags(self, cmd, fake, config):
start = pendulum.instance(fake.past_datetime(start_date='-9d'))
end = start + pendulum.duration(hours=2)
result = cmd('add \'{}\' \'{}\' \'{}\' --tags \'some tag,another tag\''.format(start.format('MMM D HH:mm:ss'),
end.format('MMM D HH:mm:ss'),
fake.sentence()))
assert result.obj.exit_code == 0
entry = TimeEntry.objects.get(result.created_id(), config=config) # type: TimeEntry
assert len(entry.tags) == 2
assert 'some tag' in entry.tags
assert 'another tag' in entry.tags
def event_activate(self):
self.energy_per_slot_Wh = (self.avg_power_W /
(duration(hours=1) / self.area.config.slot_length))
self._simulation_start_timestamp = self.area.now
self.hrs_per_day = {day: self._initial_hrs_per_day
for day in range(self.area.config.duration.days + 1)}
for slot_time in generate_market_slot_list(self.area):
if self._allowed_operating_hours(slot_time):
self.energy_requirement_Wh[slot_time] = self.energy_per_slot_Wh
self.state.desired_energy_Wh[slot_time] = self.energy_per_slot_Wh
def purchase(request):
'''
购买商品的逻辑
返回是否成功
'''
if request.method == "POST":
user = request.user
ss_user = user.ss_user
goodId = request.POST.get('goodId')
good = Goods.objects.get(pk=goodId)
if user.balance < good.money:
registerinfo = {
'title': '金额不足！',
'subtitle': '请去捐赠界面/联系站长充值',
'status': 'error',
}
else:
# 验证成功进行提权操作
ss_user.enable = True
ss_user.transfer_enable += good.transfer
user.balance -= good.money
now = pendulum.now()
days = pendulum.duration(days=good.days)
if (user.level == good.level and user.level_expire_time > now):
user.level_expire_time += days
else:
user.level_expire_time = now + days
user.level = good.level
user.save()
ss_user.save()
# 增加购买记录
record = PurchaseHistory(good=good,
user=user,
money=good.money,
purchtime=timezone.now())
record.save()
# 增加返利记录
inviter = User.objects.filter(pk=user.invited_by).first()
if inviter:
rebaterecord = RebateRecord(user_id=inviter.pk,
money=good.money *
Decimal(settings.INVITE_PERCENT))
inviter.balance += rebaterecord.money
inviter.save()
rebaterecord.save()
registerinfo = {
'title': '购买成功',
'subtitle': '请在用户中心检查最新信息',
'status': 'success',
}
return JsonResponse(registerinfo)
else:
return HttpResponse('errors')
def test_timehistogram_pendulum():
fig = Figure()
fig.with_colors = False
day = duration(days=1)
now = datetime(2018, 1, 16, 11, 9, 42, 100)
x = [now - i * day for i in range(10)]
fig.histogram(x, bins=8)
print(fig.show())
assert _histogram == fig.show()
def minute_profile_dict(val):
if val is None:
val = 0
if GlobalConfig.sim_duration > duration(days=1):
outdict = dict((GlobalConfig.start_date.add(days=day, hours=hour, minutes=minute), val)
for day, hour, minute in
product(range(GlobalConfig.sim_duration.days + 1), range(24), range(60)))
else:
outdict = dict((GlobalConfig.start_date.add(hours=hour, minutes=minute), val)
for hour, minute in product(range(24), range(60)))
return outdict
async def on_command_error(ctx, error):
mention = ctx.author.mention
# If user uses command before cooldown gets over
if isinstance(error, commands.CommandOnCooldown):
retry = pendulum.duration(seconds=error.retry_after).in_words()
await ctx.send(f"Retry after {retry}! Have patience, {mention}!")
# If missing permissions for executing commands
if isinstance(error, commands.MissingPermissions):
await ctx.send(f"You are not allowed to do that, {mention}.")
def setUp(self):
self.appliance = MagicMock(spec=SimpleAppliance)
self.strategy1 = MagicMock(spec=LoadHoursStrategy)
self.strategy1.state = MagicMock(spec=LoadState)
self.strategy1.state.desired_energy_Wh = {}
self.strategy2 = MagicMock(spec=LoadHoursStrategy)
self.strategy2.state = MagicMock(spec=LoadState)
self.strategy2.state.desired_energy_Wh = {}
self.strategy3 = MagicMock(spec=DefinedLoadStrategy)
self.strategy3.state = MagicMock(spec=LoadState)
self.strategy3.state.desired_energy_Wh = {}
self.config = MagicMock(spec=SimulationConfig)
self.config.slot_length = duration(minutes=15)
self.config.tick_length = duration(seconds=15)
self.area1 = Area("load1", None, self.strategy1, self.appliance,
self.config, None)
self.area2 = Area("load2", None, self.strategy2, self.appliance,
self.config, None)
self.area3 = Area("load3", None, self.strategy3, self.appliance,
self.config, None)
def run_sim(context, scenario, total_duration, slot_length, tick_length,
iaa_fee, market_count):
root_logger = logging.getLogger()
root_logger.setLevel(logging.CRITICAL)
simulation_config = SimulationConfig(duration(hours=int(total_duration)),
duration(minutes=int(slot_length)),
duration(seconds=int(tick_length)),
market_count=int(market_count),
cloud_coverage=0,
market_maker_rate=30,
iaa_fee=int(iaa_fee))
slowdown = 0
seed = 0
paused = False
pause_after = duration()
repl = False
export = False
export_path = None
reset_on_finish = False
reset_on_finish_wait = duration()
exit_on_finish = True
exit_on_finish_wait = duration()
api_url = "http://localhost:5000/api"
context.simulation = Simulation(scenario, simulation_config, slowdown,
seed, paused, pause_after, repl, export,
export_path, reset_on_finish,
reset_on_finish_wait, exit_on_finish,
exit_on_finish_wait, api_url)
context.simulation.run()
def run_sim_with_config_setting(context, cloud_coverage, iaa_fee, scenario):
root_logger = logging.getLogger()
root_logger.setLevel(logging.CRITICAL)
simulation_config = SimulationConfig(
duration(hours=int(24)),
duration(minutes=int(60)),
duration(seconds=int(60)),
market_count=4,
cloud_coverage=int(cloud_coverage),
market_maker_rate=context._market_maker_rate,
iaa_fee=int(iaa_fee))
slowdown = 0
seed = 0
paused = False
pause_after = duration()
repl = False
export = False
export_path = None
reset_on_finish = False
reset_on_finish_wait = duration()
exit_on_finish = True
exit_on_finish_wait = duration()
api_url = "http://localhost:5000/api"
context.simulation = Simulation(scenario, simulation_config, slowdown,
seed, paused, pause_after, repl, export,
export_path, reset_on_finish,
reset_on_finish_wait, exit_on_finish,
exit_on_finish_wait, api_url)
context.simulation.run()
def test_correct_time_expansion_read_arbitrary_profile():
market_maker_rate = 30
if GlobalConfig.IS_CANARY_NETWORK:
GlobalConfig.sim_duration = duration(hours=3)
expected_last_time_slot = today(tz=TIME_ZONE).add(
days=CN_PROFILE_EXPANSION_DAYS - 1, hours=23, minutes=45)
mmr = read_arbitrary_profile(InputProfileTypes.IDENTITY,
market_maker_rate)
assert list(mmr.keys())[-1] == expected_last_time_slot
GlobalConfig.sim_duration = duration(hours=30)
expected_last_time_slot = today(tz=TIME_ZONE).add(
days=CN_PROFILE_EXPANSION_DAYS - 1, hours=23, minutes=45)
mmr = read_arbitrary_profile(InputProfileTypes.IDENTITY,
market_maker_rate)
assert list(mmr.keys())[-1] == expected_last_time_slot
else:
GlobalConfig.sim_duration = duration(hours=3)
mmr = read_arbitrary_profile(InputProfileTypes.IDENTITY,
market_maker_rate)
assert (list(mmr.keys())[-1] - today(tz=TIME_ZONE)).days == 0
GlobalConfig.sim_duration = duration(hours=36)
mmr = read_arbitrary_profile(InputProfileTypes.IDENTITY,
market_maker_rate)
assert (list(mmr.keys())[-1] - today(tz=TIME_ZONE)).days == 1
GlobalConfig.sim_duration = duration(hours=48)
mmr = read_arbitrary_profile(InputProfileTypes.IDENTITY,
market_maker_rate)
assert list(mmr.keys())[-1] == today(tz=TIME_ZONE).add(days=1,
hours=23,
minutes=45)
GlobalConfig.sim_duration = duration(hours=49)
mmr = read_arbitrary_profile(InputProfileTypes.IDENTITY,
market_maker_rate)
assert list(mmr.keys())[-1] == today(tz=TIME_ZONE).add(days=2,
minutes=45)
def test_farthest_with_equals():
instance = pendulum.datetime(2015, 5, 28, 12, 0, 0)
dt1 = pendulum.datetime(2015, 5, 28, 12, 0, 0)
dt2 = pendulum.datetime(2015, 5, 28, 14, 0, 0)
farthest = instance.farthest(dt1, dt2)
assert farthest == dt2
dts = [
pendulum.datetime(2015, 5, 28, 16, 0, 0) + pendulum.duration(hours=x)
for x in range(4)
]
farthest = instance.farthest(dt1, dt2, *dts)
assert farthest == dts[-1]
def _update_progress_info(self, slot_no, slot_count):
run_duration = (DateTime.now(tz=TIME_ZONE) - self.run_start -
duration(seconds=self.paused_time))
self.progress_info.eta = (run_duration /
(slot_no + 1) * slot_count) - run_duration
self.progress_info.elapsed_time = run_duration
self.progress_info.percentage_completed = (slot_no +
1) / slot_count * 100
self.progress_info.current_slot_str = get_market_slot_time_str(
slot_no, self.simulation_config)
self.progress_info.next_slot_str = get_market_slot_time_str(
slot_no + 1, self.simulation_config)
def _init_price_update(self, fit_to_limit, energy_rate_increase_per_update, update_interval,
use_market_maker_rate, initial_buying_rate, final_buying_rate):
validate_load_device_price(fit_to_limit=fit_to_limit,
energy_rate_increase_per_update=energy_rate_increase_per_update)
if update_interval is None:
update_interval = \
duration(minutes=ConstSettings.GeneralSettings.DEFAULT_UPDATE_INTERVAL)
self.use_market_maker_rate = use_market_maker_rate
if isinstance(update_interval, int):
update_interval = duration(minutes=update_interval)
BidEnabledStrategy.__init__(self)
self.bid_update = \
UpdateFrequencyMixin(initial_rate=initial_buying_rate,
final_rate=final_buying_rate,
fit_to_limit=fit_to_limit,
energy_rate_change_per_update=energy_rate_increase_per_update,
update_interval=update_interval, rate_limit_object=min)
self.fit_to_limit = fit_to_limit
def set_last_disable_dating_date(self, user_id):
query_kwargs = {
'Key': self.pk(user_id),
'UpdateExpression':
'SET gsiA3PartitionKey = :gsia3pk, gsiA3SortKey = :gsia3sk',
'ExpressionAttributeValues': {
':gsia3pk':
'userDisableDatingDate',
':gsia3sk': (pendulum.now('utc') +
pendulum.duration(days=30)).to_date_string(),
},
}
return self.client.update_item(query_kwargs)
def test_finite_plant_max_power(context, plant_name):
grid = context.simulation.area
finite = list(filter(lambda x: x.name == plant_name, grid.children))[0]
for market in grid.past_markets:
trades_sold = []
for trade in market.trades:
assert trade.buyer is not finite.name
if trade.seller == finite.name:
trades_sold.append(trade)
assert sum([trade.offer.energy for trade in trades_sold]) <= \
finite.strategy.max_available_power_kW[market.time_slot] / \
(duration(hours=1) / finite.config.slot_length)
def _init_price_update(self, update_interval, initial_selling_rate,
final_selling_rate, use_market_maker_rate,
fit_to_limit, energy_rate_decrease_per_update):
# Instantiate instance variables that should not be shared with child classes
self.final_selling_rate = final_selling_rate
self.use_market_maker_rate = use_market_maker_rate
if update_interval is None:
update_interval = \
duration(minutes=ConstSettings.GeneralSettings.DEFAULT_UPDATE_INTERVAL)
if isinstance(update_interval, int):
update_interval = duration(minutes=update_interval)
PVValidator.validate_rate(
fit_to_limit=fit_to_limit,
energy_rate_decrease_per_update=energy_rate_decrease_per_update)
self.offer_update = TemplateStrategyOfferUpdater(
initial_selling_rate, final_selling_rate, fit_to_limit,
energy_rate_decrease_per_update, update_interval)
def test_farthest_with_equals():
instance = pendulum.datetime(2015, 5, 28, 12, 0, 0)
dt1 = pendulum.datetime(2015, 5, 28, 12, 0, 0)
dt2 = pendulum.datetime(2015, 5, 28, 14, 0, 0)
farthest = instance.farthest(dt1, dt2)
assert farthest == dt2
dts = [
pendulum.datetime(2015, 5, 28, 16, 0, 0) + pendulum.duration(hours=x)
for x in range(4)
]
farthest = instance.farthest(dt1, dt2, *dts)
assert farthest == dts[-1]
def test_add_duration():
duration = pendulum.duration(
years=2, months=3, days=6, seconds=45, microseconds=123456
)
d = pendulum.datetime(2015, 3, 14, 3, 12, 15, 654321)
d = d + duration
assert 2017 == d.year
assert 6 == d.month
assert 20 == d.day
assert 3 == d.hour
assert 13 == d.minute
assert 0 == d.second
assert 777777 == d.microsecond
def test_subtract_duration():
duration = pendulum.duration(
years=2, months=3, days=6, seconds=16, microseconds=654321
)
d = pendulum.datetime(2015, 3, 14, 3, 12, 15, 777777)
d = d - duration
assert 2012 == d.year
assert 12 == d.month
assert 8 == d.day
assert 3 == d.hour
assert 11 == d.minute
assert 59 == d.second
assert 123456 == d.microsecond
def test_farthest_with_datetime():
instance = pendulum.datetime(2015, 5, 28, 12, 0, 0)
dt1 = datetime(2015, 5, 28, 11, 0, 0, tzinfo=pendulum.UTC)
dt2 = datetime(2015, 5, 28, 14, 0, 0, tzinfo=pendulum.UTC)
farthest = instance.farthest(dt1, dt2)
assert_datetime(farthest, 2015, 5, 28, 14, 0, 0)
dts = [
pendulum.datetime(2015, 5, 28, 16, 0, 0) + pendulum.duration(hours=x)
for x in range(4)
]
farthest = instance.farthest(dt1, dt2, *dts)
assert_datetime(farthest, 2015, 5, 28, 19, 0, 0)
def test_closest_with_datetime():
instance = pendulum.datetime(2015, 5, 28, 12, 0, 0)
dt1 = datetime(2015, 5, 28, 11, 0, 0)
dt2 = datetime(2015, 5, 28, 14, 0, 0)
closest = instance.closest(dt1, dt2)
assert_datetime(closest, 2015, 5, 28, 11, 0, 0)
dts = [
pendulum.datetime(2015, 5, 28, 16, 0, 0) + pendulum.duration(hours=x)
for x in range(4)
]
closest = instance.closest(dt1, dt2, *dts)
assert_datetime(closest, 2015, 5, 28, 11, 0, 0)
def test_continue(self, cmd, config, factories):
some_entry = factories.TimeEntryFactory()
start = pendulum.now('utc')
stop = start + pendulum.duration(seconds=10)
last_entry = factories.TimeEntryFactory(start=start, stop=stop)
result = cmd('continue')
assert result.obj.exit_code == 0
continuing_entry = TimeEntry.objects.current(config=config)
assert last_entry.description == continuing_entry.description
assert last_entry.id != continuing_entry.id
continuing_entry.stop_and_save()
result = cmd('continue \'{}\''.format(some_entry.description))
assert result.obj.exit_code == 0
continuing_entry = TimeEntry.objects.current(config=config)
assert continuing_entry.description == some_entry.description
def test_closest():
instance = pendulum.datetime(2015, 5, 28, 12, 0, 0)
dt1 = pendulum.datetime(2015, 5, 28, 11, 0, 0)
dt2 = pendulum.datetime(2015, 5, 28, 14, 0, 0)
closest = instance.closest(dt1, dt2)
assert closest == dt1
closest = instance.closest(dt2, dt1)
assert closest == dt1
dts = [
pendulum.datetime(2015, 5, 28, 16, 0, 0) + pendulum.duration(hours=x)
for x in range(4)
]
closest = instance.closest(*dts)
assert closest == dts[0]
closest = instance.closest(*(dts[::-1]))
assert closest == dts[0]
def test_farthest():
instance = pendulum.datetime(2015, 5, 28, 12, 0, 0)
dt1 = pendulum.datetime(2015, 5, 28, 11, 0, 0)
dt2 = pendulum.datetime(2015, 5, 28, 14, 0, 0)
farthest = instance.farthest(dt1, dt2)
assert farthest == dt2
farthest = instance.farthest(dt2, dt1)
assert farthest == dt2
dts = [
pendulum.datetime(2015, 5, 28, 16, 0, 0) + pendulum.duration(hours=x)
for x in range(4)
]
farthest = instance.farthest(*dts)
assert farthest == dts[-1]
farthest = instance.farthest(*(dts[::-1]))
assert farthest == dts[-1]
f = pendulum.datetime(2010, 1, 1, 0, 0, 0)
assert f == instance.farthest(f, *(dts))
def test_weeks():
pi = pendulum.duration(days=365)
assert_duration(pi, weeks=52)
pi = pendulum.duration(days=13)
assert_duration(pi, weeks=1)
def test_defaults():
pi = pendulum.duration()
assert_duration(pi, 0, 0, 0, 0, 0, 0, 0)
def test_float_years_and_months():
with pytest.raises(ValueError):
pendulum.duration(years=1.5)
with pytest.raises(ValueError):
pendulum.duration(months=1.5)
def test_week_to_string():
assert str(pendulum.duration(days=364)) == "52 weeks"
assert str(pendulum.duration(days=7)) == "1 week"
def test_invert():
pi = pendulum.duration(days=1177, seconds=7284, microseconds=1000000)
assert not pi.invert
pi = pendulum.duration(days=-1177, seconds=-7284, microseconds=-1000000)
assert pi.invert
def test_minutes():
pi = pendulum.duration(seconds=60 * 3)
assert_duration(pi, 0, 0, 0, 0, 0, 3, 0)
pi = pendulum.duration(seconds=60 * 3 + 12)
assert_duration(pi, 0, 0, 0, 0, 0, 3, 12)
def test_hours():
pi = pendulum.duration(seconds=3600 * 3)
assert_duration(pi, 0, 0, 0, 0, 3, 0, 0)
def test_days():
pi = pendulum.duration(days=6)
assert_duration(pi, 0, 0, 0, 6, 0, 0, 0)
pi = pendulum.duration(days=16)
assert_duration(pi, 0, 0, 2, 2, 0, 0, 0)
def test_add_duration():
duration = pendulum.duration(years=2, months=3, days=18)
d = pendulum.Date(2015, 3, 14)
new = d + duration
assert_date(new, 2017, 7, 2)
def test_months():
pi = pendulum.duration(months=3)
assert_duration(pi, months=3, weeks=0)
assert 90 == pi.days
def test_years():
pi = pendulum.duration(years=2)
assert_duration(pi, years=2, weeks=0)
assert 730 == pi.days
