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_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