def test_backtest(default_conf, fee, mocker, testdatadir) -> None: default_conf['ask_strategy']['use_sell_signal'] = False mocker.patch('freqtrade.exchange.Exchange.get_fee', fee) patch_exchange(mocker) backtesting = Backtesting(default_conf) pair = 'UNITTEST/BTC' timerange = TimeRange('date', None, 1517227800, 0) data = history.load_data(datadir=testdatadir, timeframe='5m', pairs=['UNITTEST/BTC'], timerange=timerange) processed = backtesting.strategy.ohlcvdata_to_dataframe(data) min_date, max_date = get_timerange(processed) results = backtesting.backtest( processed=processed, stake_amount=default_conf['stake_amount'], start_date=min_date, end_date=max_date, max_open_trades=10, position_stacking=False, ) assert not results.empty assert len(results) == 2 expected = pd.DataFrame({ 'pair': [pair, pair], 'profit_percent': [0.0, 0.0], 'profit_abs': [0.0, 0.0], 'open_time': pd.to_datetime([ Arrow(2018, 1, 29, 18, 40, 0).datetime, Arrow(2018, 1, 30, 3, 30, 0).datetime ], utc=True), 'close_time': pd.to_datetime([ Arrow(2018, 1, 29, 22, 35, 0).datetime, Arrow(2018, 1, 30, 4, 10, 0).datetime ], utc=True), 'open_index': [78, 184], 'close_index': [125, 192], 'trade_duration': [235, 40], 'open_at_end': [False, False], 'open_rate': [0.104445, 0.10302485], 'close_rate': [0.104969, 0.103541], 'sell_reason': [SellType.ROI, SellType.ROI] }) pd.testing.assert_frame_equal(results, expected) data_pair = processed[pair] for _, t in results.iterrows(): ln = data_pair.loc[data_pair["date"] == t["open_time"]] # Check open trade rate alignes to open rate assert ln is not None assert round(ln.iloc[0]["open"], 6) == round(t["open_rate"], 6) # check close trade rate alignes to close rate or is between high and low ln = data_pair.loc[data_pair["date"] == t["close_time"]] assert (round(ln.iloc[0]["open"], 6) == round(t["close_rate"], 6) or round(ln.iloc[0]["low"], 6) < round( t["close_rate"], 6) < round(ln.iloc[0]["high"], 6))
def get_time_arrows( self) -> Tuple[Optional[Arrow], Optional[Arrow], Optional[Arrow]]: if not self.year: return None, None, None open_arrow, start_arrow, end_arrow = None, None, None if self.open_hour: open_arrow = Arrow(year=self.year, month=self.month, day=self.day, tzinfo=pytz.timezone("Asia/Tokyo"), hour=self.open_hour, minute=self.open_minute) if self.start_hour: start_arrow = Arrow(year=self.year, month=self.month, day=self.day, tzinfo=pytz.timezone("Asia/Tokyo"), hour=self.start_hour, minute=self.start_minute) if self.end_hour: end_arrow = Arrow(year=self.year, month=self.month, day=self.day, tzinfo=pytz.timezone("Asia/Tokyo"), hour=self.end_hour, minute=self.end_minute) open_or_start_hour = self.open_hour or self.start_hour open_or_start_minute = self.open_minute or self.start_minute if open_or_start_hour and\ (open_or_start_hour > self.end_hour or (open_or_start_hour == self.end_hour and open_or_start_minute >= self.end_minute)): end_arrow = end_arrow.replace(days=1) return open_arrow, start_arrow, end_arrow
def test_generate_optimizer(mocker, default_conf) -> None: default_conf.update({'config': 'config.json.example'}) default_conf.update({'timerange': None}) default_conf.update({'spaces': 'all'}) default_conf.update({'hyperopt_min_trades': 1}) trades = [ ('POWR/BTC', 0.023117, 0.000233, 100) ] labels = ['currency', 'profit_percent', 'profit_abs', 'trade_duration'] backtest_result = pd.DataFrame.from_records(trades, columns=labels) mocker.patch( 'freqtrade.optimize.hyperopt.Hyperopt.backtest', MagicMock(return_value=backtest_result) ) mocker.patch( 'freqtrade.optimize.hyperopt.get_timeframe', MagicMock(return_value=(Arrow(2017, 12, 10), Arrow(2017, 12, 13))) ) patch_exchange(mocker) mocker.patch('freqtrade.optimize.hyperopt.load', MagicMock()) optimizer_param = { 'adx-value': 0, 'fastd-value': 35, 'mfi-value': 0, 'rsi-value': 0, 'adx-enabled': False, 'fastd-enabled': True, 'mfi-enabled': False, 'rsi-enabled': False, 'trigger': 'macd_cross_signal', 'sell-adx-value': 0, 'sell-fastd-value': 75, 'sell-mfi-value': 0, 'sell-rsi-value': 0, 'sell-adx-enabled': False, 'sell-fastd-enabled': True, 'sell-mfi-enabled': False, 'sell-rsi-enabled': False, 'sell-trigger': 'macd_cross_signal', 'roi_t1': 60.0, 'roi_t2': 30.0, 'roi_t3': 20.0, 'roi_p1': 0.01, 'roi_p2': 0.01, 'roi_p3': 0.1, 'stoploss': -0.4, } response_expected = { 'loss': 1.9840569076926293, 'result': ' 1 trades. Avg profit 2.31%. Total profit 0.00023300 BTC ' '( 2.31Σ%). Avg duration 100.0 mins.', 'params': optimizer_param } hyperopt = Hyperopt(default_conf) generate_optimizer_value = hyperopt.generate_optimizer(list(optimizer_param.values())) assert generate_optimizer_value == response_expected
def generate_control_chart(tickets: List[Issue], chart_class: Type[IChart] = Chart) -> None: if not tickets: print('No data. Check that the JSON file was correctly populated ' + 'when you ran the `fetch` command.') return completed_cycle_times: List[CycleTime] = list( sorted( (get_cycle_time(ticket) for ticket in tickets if ticket.completed is not None and ticket.started is not None), key=attrgetter("completed"), )) if not completed_cycle_times: print('Could not process cycle time, check that the statuses ' + 'in config.yaml are correct.') return cycle_time_plot = CycleTimeScatterPlot(cycle_times=completed_cycle_times, data_source=ColumnDataSource) average_cycle_time_plot = AverageCycleTimePlot( cycle_times=completed_cycle_times, data_source=ColumnDataSource) rolling_cycle_time_plot = RollingAverageCycleTimePlot( cycle_times=completed_cycle_times, data_source=ColumnDataSource) cycle_time_deviation_plot = CycleTimeDeviationPlot( cycle_times=completed_cycle_times, data_source=ColumnDataSource) start_date, end_date = ( completed_cycle_times[0].completed, completed_cycle_times[-1].completed, ) chart = chart_class( x=Axis( label="Closed (date)", values=[ d[0].date().isoformat() for d in Arrow.span_range( "day", Arrow(start_date.year, start_date.month, start_date.day), Arrow(end_date.year, end_date.month, end_date.day), ) ], size=1800, ), y=Axis(label="Cycle time (days)", values=None, size=900), label="Ticket", tooltips=[ ("Ticket", "@label"), ("Closed (date)", "@x"), ("Cycle time (days)", "@y"), ], ) cycle_time_plot.draw(chart) average_cycle_time_plot.draw(chart) rolling_cycle_time_plot.draw(chart) cycle_time_deviation_plot.draw(chart) chart.render()
def fire_arrow(sk_settings, screen, knight, arrows_right, arrows_left): '''Create and fire an arrow.''' if knight.shoot_right: new_arrow = Arrow(sk_settings, screen, knight, 6, 0, 15, 4) arrows_right.add(new_arrow) elif knight.shoot_left: new_arrow = Arrow(sk_settings, screen, knight, -6, 0, 15, 4) arrows_left.add(new_arrow)
def test_split_time(): result = tools.split_time( Arrow(1, 1, 1, 1, 1).datetime, Arrow(2, 2, 2, 2, 2).datetime) assert result['n_days'] == 396 assert result['remainder_start'] == timedelta(0, 82740) assert result['remainder_stop'] == timedelta(0, 7320) assert result['start_day'] == Arrow(1, 1, 2, 0, 0).datetime assert result['stop_day'] == Arrow(2, 2, 2, 0, 0).datetime
def test(): print(Pattern([ PBase('C'), POpen, PSkip(10), PSearch(DNA('ICFPPCFI')), PClose, ])) icfp = DNA('ICFP') assert_eq(icfp[0:2], DNA('IC')) assert_eq(icfp[2:0], empty()) assert_eq(icfp[2:2], empty()) assert_eq(icfp[2:3], DNA('F')) assert_eq(icfp[2], F) assert_eq(icfp[2:6], DNA('FP')) assert_eq(icfp[2:None], DNA('FP')) assert_eq(icfp[6], '') # Spec is poorly typed for this case. dna = DNA('ABC') dna.pop(1) assert_eq(dna, 'BC') mp3_clue = 'IIPIFFCPICPICIICIPCCCPIICIPPPFFCFFFFIIC' prefix = mp3_clue a = Arrow(prefix_str=prefix) p = a.consume_pattern() t = a.consume_template() assert_eq( str(p), '(<IFPFP>)<7>', '\n\tdna_in=%s\n\tdna_out=%s ' % (prefix, str(a.dna))) assert_eq( str(t), '[0^0]CCICCCC', '\n\tdna_in=%s\n\tdna_out=%s ' % (prefix, str(a.dna))) cases = {'CIIC': 'I', 'IIPIPICPIICICIIF': '(<2>)P'} for prefix in cases: a = Arrow(prefix_str=prefix) p = a.consume_pattern() assert_eq( str(p), cases[prefix], '\n\tdna_in=%s\n\tdna_out=%s ' % (prefix, str(a.dna))) cases = {'IPPPICIIC': '[0^0]P'} for prefix in cases: a = Arrow(prefix_str=prefix) t = a.consume_template() assert_eq( str(t), cases[prefix], '\n\tdna_in=%s\n\tdna_out=%s ' % (prefix, str(a.dna))) build.testColors()
def test_for_utc_timezone(): tz = 'Europe/Warsaw' _run_test_between_dates(since=Arrow(year=2020, month=6, day=11, hour=7, tzinfo=tz), until=Arrow(year=2020, month=6, day=11, hour=8, tzinfo=tz))
def test_hyperopt_format_results(hyperopt): bt_result = { 'results': pd.DataFrame({"pair": ["UNITTEST/BTC", "UNITTEST/BTC", "UNITTEST/BTC", "UNITTEST/BTC"], "profit_ratio": [0.003312, 0.010801, 0.013803, 0.002780], "profit_abs": [0.000003, 0.000011, 0.000014, 0.000003], "open_date": [Arrow(2017, 11, 14, 19, 32, 00).datetime, Arrow(2017, 11, 14, 21, 36, 00).datetime, Arrow(2017, 11, 14, 22, 12, 00).datetime, Arrow(2017, 11, 14, 22, 44, 00).datetime], "close_date": [Arrow(2017, 11, 14, 21, 35, 00).datetime, Arrow(2017, 11, 14, 22, 10, 00).datetime, Arrow(2017, 11, 14, 22, 43, 00).datetime, Arrow(2017, 11, 14, 22, 58, 00).datetime], "open_rate": [0.002543, 0.003003, 0.003089, 0.003214], "close_rate": [0.002546, 0.003014, 0.003103, 0.003217], "trade_duration": [123, 34, 31, 14], "is_open": [False, False, False, True], "stake_amount": [0.01, 0.01, 0.01, 0.01], "sell_reason": [SellType.ROI, SellType.STOP_LOSS, SellType.ROI, SellType.FORCE_SELL] }), 'config': hyperopt.config, 'locks': [], 'final_balance': 0.02, 'rejected_signals': 2, 'backtest_start_time': 1619718665, 'backtest_end_time': 1619718665, } results_metrics = generate_strategy_stats({'XRP/BTC': None}, '', bt_result, Arrow(2017, 11, 14, 19, 32, 00), Arrow(2017, 12, 14, 19, 32, 00), market_change=0) results_explanation = HyperoptTools.format_results_explanation_string(results_metrics, 'BTC') total_profit = results_metrics['profit_total_abs'] results = { 'loss': 0.0, 'params_dict': None, 'params_details': None, 'results_metrics': results_metrics, 'results_explanation': results_explanation, 'total_profit': total_profit, 'current_epoch': 1, 'is_initial_point': True, } result = HyperoptTools._format_explanation_string(results, 1) assert ' 0.71%' in result assert 'Total profit 0.00003100 BTC' in result assert '0:50:00 min' in result
def create_arrows(self): self.arrows.append( Arrow(direction=-1, pos=self.arrows_pos, style=self.style, damage=self.stats['Damage'], speed=(self.stats['Speed'], self.stats['Speed']))) self.arrows.append( Arrow(direction=1, pos=self.arrows_pos, style=self.style, damage=self.stats['Damage'], speed=(self.stats['Speed'], self.stats['Speed'])))
def test_zone_to_zone(self): dt_1 = datetime.utcnow() + timedelta(hours=-2) dt_2 = datetime.utcnow() + timedelta(hours=2) arr_1 = Arrow(dt_1, timedelta(hours=-2)) arr_2 = Arrow(dt_2, timedelta(hours=2)) result_1 = arr_1.to(timedelta(hours=2)) result_2 = arr_2.to(timedelta(hours=-2)) self.assert_dt_equal(result_1.datetime, arr_2.datetime) self.assert_dt_equal(result_2.datetime, arr_1.datetime)
def generate_control_chart(tickets: List[Issue], chart_class: Type[IChart] = Chart) -> None: if not tickets: return completed_cycle_times: List[CycleTime] = list( sorted( (get_cycle_time(ticket) for ticket in tickets if ticket.completed is not None and ticket.started is not None), key=attrgetter("completed"), )) cycle_time_plot = CycleTimeScatterPlot(cycle_times=completed_cycle_times, data_source=ColumnDataSource) average_cycle_time_plot = AverageCycleTimePlot( cycle_times=completed_cycle_times, data_source=ColumnDataSource) rolling_cycle_time_plot = RollingAverageCycleTimePlot( cycle_times=completed_cycle_times, data_source=ColumnDataSource) cycle_time_deviation_plot = CycleTimeDeviationPlot( cycle_times=completed_cycle_times, data_source=ColumnDataSource) start_date, end_date = ( completed_cycle_times[0].completed, completed_cycle_times[-1].completed, ) chart = chart_class( x=Axis( label="Closed (date)", values=[ d[0].date().isoformat() for d in Arrow.span_range( "day", Arrow(start_date.year, start_date.month, start_date.day), Arrow(end_date.year, end_date.month, end_date.day), ) ], size=1800, ), y=Axis(label="Cycle time (days)", values=None, size=900), label="Ticket", tooltips=[ ("Ticket", "@label"), ("Closed (date)", "@x"), ("Cycle time (days)", "@y"), ], ) cycle_time_plot.draw(chart) average_cycle_time_plot.draw(chart) rolling_cycle_time_plot.draw(chart) cycle_time_deviation_plot.draw(chart) chart.render()
def test_backtest(default_conf, fee, mocker) -> None: mocker.patch('freqtrade.exchange.Exchange.get_fee', fee) patch_exchange(mocker) backtesting = Backtesting(default_conf) pair = 'UNITTEST/BTC' data = optimize.load_data(None, ticker_interval='5m', pairs=['UNITTEST/BTC']) data = trim_dictlist(data, -200) data_processed = backtesting.tickerdata_to_dataframe(data) results = backtesting.backtest({ 'stake_amount': default_conf['stake_amount'], 'processed': data_processed, 'max_open_trades': 10, 'position_stacking': False }) assert not results.empty assert len(results) == 2 expected = pd.DataFrame({ 'pair': [pair, pair], 'profit_percent': [0.00029975, 0.00056708], 'profit_abs': [1.49e-06, 7.6e-07], 'open_time': [ Arrow(2018, 1, 29, 18, 40, 0).datetime, Arrow(2018, 1, 30, 3, 30, 0).datetime ], 'close_time': [ Arrow(2018, 1, 29, 22, 40, 0).datetime, Arrow(2018, 1, 30, 4, 20, 0).datetime ], 'open_index': [77, 183], 'close_index': [125, 193], 'trade_duration': [240, 50], 'open_at_end': [False, False], 'open_rate': [0.104445, 0.10302485], 'close_rate': [0.105, 0.10359999], 'sell_reason': [SellType.ROI, SellType.ROI] }) pd.testing.assert_frame_equal(results, expected) data_pair = data_processed[pair] for _, t in results.iterrows(): ln = data_pair.loc[data_pair["date"] == t["open_time"]] # Check open trade rate alignes to open rate assert ln is not None assert round(ln.iloc[0]["open"], 6) == round(t["open_rate"], 6) # check close trade rate alignes to close rate ln = data_pair.loc[data_pair["date"] == t["close_time"]] assert round(ln.iloc[0]["open"], 6) == round(t["close_rate"], 6)
def run_game(): pygame.init() pygame.mixer.init() pygame.mixer.pre_init(44100, 16, 2, 4096) # frequency, size, channels, buffersize pygame.mixer.init() ai_settings = Settings() screen = pygame.display.set_mode( (ai_settings.screen_height, ai_settings.screen_width)) pygame.display.set_caption("ALIEN INVASION") play_button = Button(ai_settings, screen, "Play") stats = GameStats(ai_settings) sb = Scoreboard(ai_settings, screen, stats) arrow = Arrow(ai_settings, screen) bg_color = (100, 230, 200) num_of_arrows = Group() num_of_balloons = Group() gf.create_fleet(ai_settings, screen, arrow, num_of_balloons) pygame.mixer.music.load('sounds/bgmmusic.wav') pygame.mixer.music.play(-1) while True: gf.check_events(ai_settings, screen, stats, sb, play_button, arrow, num_of_arrows, num_of_balloons) if stats.game_active: arrow.update() num_of_arrows.update() gf.update_each_arrows(ai_settings, screen, stats, sb, play_button, arrow, num_of_balloons, num_of_arrows) gf.update_balloons(ai_settings, stats, sb, screen, arrow, num_of_balloons, num_of_arrows) gf.update_screen(ai_settings, screen, stats, sb, arrow, num_of_arrows, num_of_balloons, play_button)
def describe_relative(events, day): ''' Convert a set of events to a set of statements relative to the given date. ''' punc = '.,?!' stmnts = [] day = utc.localize(datetime.combine(day, datetime.min.time())) for e in events: if e.all_day and e.start == day: s = f'Today: {e.summary}' # Work around some quirks in the Arrow.humanize() method elif e.all_day and e.start == day + timedelta(days=1): s = f'Tomorrow: {e.summary}' elif e.all_day and e.start == day + timedelta(days=2): s = f'In two days: {e.summary}' elif e.all_day and e.start < day: s = f'Ongoing: {e.summary}' else: a = Arrow(*e.start.timetuple()[:5]) s = f'{a.humanize()}: {e.summary}' # Close of the sentence to give the correct speach pattern to Alexa if s[-1] not in punc: s += '.' stmnts.append(s) return stmnts
def test_initialize_room_部屋を初期化する(self, sut, getter, putter): putter({ "room_id": "abcdef", "mem_1000000001": { "nickname": "ななし1", "point": 5 }, "mem_1000000002": { "nickname": "ななし2", "point": 1 }, "mem_1000000003": { "nickname": "ななし3", "point": 3 }, "opened": True, }) room = Room(room_id="abcdef", members=[ Member("1000000001", "ななし1", point=None), Member("1000000002", "ななし2", point=None), Member("1000000003", "ななし3", point=None), ]) now = Arrow(2020, 11, 22) sut.initialize_room(room, now) actual = getter("abcdef") assert actual["opened"] is False assert actual["mem_1000000001"] == {"nickname": "ななし1", "point": None} assert actual["mem_1000000002"] == {"nickname": "ななし2", "point": None} assert actual["mem_1000000003"] == {"nickname": "ななし3", "point": None} assert actual["ttl"] == 1606089600
def __init__(self, gram, source, position=0, start_date=Arrow(1970, 1, 1).datetime, stop_date=utcnow().datetime): super(Map, self).__init__() if isinstance(gram, Gram): self.str_type = gram.str_type self.term = gram.term self.n = len(gram) elif isinstance(gram, StringLike): gram = Gram(gram) self.str_type = gram.str_type self.term = gram.term self.n = len(gram) else: raise TypeError("{} must be StringLike or Gram".format(self.term)) if source not in c['Comment'].collection_names(): raise ValueError("{} is not a collection in Comment") self.dictionary = c['Dictionary'][self.str_type.__name__] self.start_date = start_date self.stop_date = stop_date self.position = position self.source = source self.__fromdb__()
def test_arrow(self): arr = Arrow(datetime.utcnow() + timedelta(hours=-1)) result = arrow().humanize(arr, fix=False) self.assertEqual(result, '1 hour')
def run_game(): #初始化游戏并创建一个屏幕对象 pygame.init() screen = pygame.display.set_mode((1200, 800)) so_setting = Setting() pygame.display.set_caption("Shot one") #新建对象 bow = Bow(so_setting, screen) arrow = Arrow(so_setting, screen, bow) heart = Heart(so_setting, screen) score = Scoreboard(so_setting, screen) #游戏的主循环 while True: gf.check_events(arrow, bow) #更新三个对象 gf.update_bow(bow) gf.update_arrow(arrow, heart, so_setting, score) gf.update_heart(heart) #更新屏幕 gf.update_screen(screen, so_setting, bow, arrow, heart, score) #显示最新的屏幕 pygame.display.flip()
def test_vector(): with pytest.raises(ValueError): objects.Vector(n=1, str_type=objects.String, count_type=objects.Activation, source='Blue') with pytest.raises(ValueError): objects.Vector(n=1, str_type='Frayed', count_type=objects.Tf, source='test') with pytest.raises(TypeError): objects.Vector(n=1, str_type=objects.String, count_type='Lemma', source='test', start_date='now') for count_type in objects.Count.__subclasses__(): for gram_length in gram_length_list: for str_type in objects.StringLike.__subclasses__(): vector = objects.Vector(n=gram_length, str_type=str_type, count_type=count_type, source='test') assert vector.n == gram_length assert vector.start_date == Arrow(1970, 1, 1, 0, 0).datetime assert len(vector) >= 100
def unpickle(self, vertices, arrows, crossings, hot=None): """ Builds a link diagram from the following data: * vertices: a list of (x,y)-coordinates for the vertices; * arrows: a list of pairs of integers (start, end), giving the indices in the vertex list of the endpoints of each arrow; * crossings: a list of quadruples (under, over, is_virtual, label), giving the indices in the arrow list of each pair of crossing arrows, a boolean indicating if the crossing is virtual, and an assigned label. * an optional argument "hot" giving the index of one vertex which was being added at the time the diagram was pickled """ for x, y in vertices: X, Y = float(x), float(y) self.Vertices.append(Vertex(X, Y, self.canvas)) for start, end in arrows: S, E = self.Vertices[int(start)], self.Vertices[int(end)] self.Arrows.append(Arrow(S, E, self.canvas)) for under, over, is_virtual, label in crossings: U, O, V, L = self.Arrows[int(under)], self.Arrows[int(over)], bool( is_virtual), str(label) self.Crossings.append(Crossing(O, U, V, L))
def screen_record(): x, y, w, h = 0, 50, 1024, 768 meta = MetaData.from_screen(w - x, h - y) arrow = Arrow(meta.width) last_time = 0 with mss() as sct: # Part of the screen to capture monitor = {"top": y, "left": x, "width": w, "height": h} while True: frame = numpy.array(sct.grab(monitor)) try: processed_img = process_img(frame, meta) lines = find_lines(processed_img) p = separate_lines(lines) cv2.circle(frame, (int(p.x), int(p.y)), 2, [0, 255, 255], 10) arrow.add_point(int(p.x)) except: pass draw_arrow(frame, arrow, meta.width) cv2.imshow("OpenCV/Numpy normal", frame) fps = "fps: {}".format(1 / (time.time() - last_time)) last_time = time.time() print(fps) # Press "q" to quit if cv2.waitKey(50) & 0xFF == ord("q"): cv2.destroyAllWindows() break
def test_one_arg_iso_calendar_tzinfo_kwarg(self): result = self.factory.get((2004, 1, 7), tzinfo="America/Chicago") expected = Arrow(2004, 1, 4, tzinfo="America/Chicago") assert_datetime_equality(result, expected)
def __init__(self, source, n, str_type, count_type, start_date=Arrow(1970, 1, 1).datetime, stop_date=utcnow().datetime): super(Vector, self).__init__(n=n, str_type=str_type) if source not in c['Comment'].collection_names(): raise ValueError( "{} is not a collection in the Comment database".format( source)) if str_type not in StringLike.__subclasses__(): raise ValueError( "{} is not a valid string type class".format(str_type)) for date in [start_date, stop_date]: if not isinstance(date, datetime): raise TypeError( "{} is not a datetime.datetime object".format(date)) self.count_type = count_type self.start_date = Arrow.fromdatetime(start_date).datetime self.stop_date = Arrow.fromdatetime(stop_date).datetime self.body = c['Body'][source] self.cache = c['BodyCache'][source] self.comment = c['Comment'][source] self.__fromdb__()
def run_game(): pygame.init() ai_settings = Settings() screen = pygame.display.set_mode( (ai_settings.screen_width, ai_settings.screen_height)) pygame.display.set_caption("Monster Invasion") #Make the play button play_button = Button(ai_settings, screen, "Play") #create an instance to store game stats and create a score board stats = GameStats(ai_settings) sb = Scoreboard(ai_settings, screen, stats) #manke an arrow, a gorup of bullets,and a group of monsters arrow = Arrow(ai_settings, screen) #make a group to store bullets in bullets = Group() monsters = Group() gf.create_fleet(ai_settings, screen, arrow, monsters) print('here') arrow.blitme() #start the main loop for the game while True: gf.check_events(ai_settings, screen, stats, sb, play_button, arrow, monsters, bullets) if stats.game_active: arrow.update() gf.update_bullets(ai_settings, screen, stats, sb, arrow, monsters, bullets) gf.update_monsters(ai_settings, screen, stats, sb, arrow, monsters, bullets) gf.update_screen(ai_settings, screen, stats, sb, arrow, monsters, bullets, play_button)
def test_render(test_client, snapshot, app): app.redis.get.side_effect = lambda key: { 'statuses': json.dumps({ 'swahamish': False }).encode(), 'data': pickle.dumps([ Pet( location='Rapture', image=None, breed=None, color=None, gender=None, found_on=Arrow(2020, 1, 1), source='rapture', url='https://rapture.io/lost-and-found', ) ]), 'last_updated': b'2020-01-01T00:00', }[key] render = test_client.get('/') assert render.status_code == 200 snapshot.assert_match(render.get_data().decode())
def test_calculate_max_drawdown2(): values = [ 0.011580, 0.010048, 0.011340, 0.012161, 0.010416, 0.010009, 0.020024, -0.024662, -0.022350, 0.020496, -0.029859, -0.030511, 0.010041, 0.010872, -0.025782, 0.010400, 0.012374, 0.012467, 0.114741, 0.010303, 0.010088, -0.033961, 0.010680, 0.010886, -0.029274, 0.011178, 0.010693, 0.010711 ] dates = [Arrow(2020, 1, 1).shift(days=i) for i in range(len(values))] df = DataFrame(zip(values, dates), columns=['profit', 'open_date']) # sort by profit and reset index df = df.sort_values('profit').reset_index(drop=True) df1 = df.copy() drawdown, hdate, ldate, hval, lval = calculate_max_drawdown( df, date_col='open_date', value_col='profit') # Ensure df has not been altered. assert df.equals(df1) assert isinstance(drawdown, float) # High must be before low assert hdate < ldate # High value must be higher than low value assert hval > lval assert drawdown == 0.091755 df = DataFrame(zip(values[:5], dates[:5]), columns=['profit', 'open_date']) with pytest.raises(ValueError, match='No losing trade, therefore no drawdown.'): calculate_max_drawdown(df, date_col='open_date', value_col='profit')
def video_record(video): meta = MetaData.from_video(video) cap = cv2.VideoCapture(video) arrow = Arrow(meta.width) cpt_frame = 0 while cap.isOpened(): ret, frame = cap.read() cpt_frame += 1 if ret: try: processed_img = process_img(frame, meta) lines = find_lines(processed_img) l1, l2 = separate_lines(lines) p = intersect_droit(l1, l2) arrow.add_point(int(p.x)) processed_img = cv2.cvtColor(processed_img, cv2.COLOR_GRAY2BGR) cv2.imshow('window', processed_img) draw_infos(frame, p, l1, l2) draw_arrow(frame, arrow, meta.width) cv2.imshow('window', frame) except: pass # draw_arrow(frame, arrow, meta.width) # cv2.imshow('window', frame) if cv2.waitKey(25) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows()
def prep_arrownumbers(self): self.arrownumbers = Group() for arrow_number in range(self.stats.bow_left): arrow = Arrow(self.ai_settings, self.screen) arrow.rect.x = 10 + arrow_number * arrow.rect.width arrow.rect.y = 10 self.arrownumbers.add(arrow)
def split_time(start_date, stop_date): """ Split start and stop datetime objects into a period of whole days, and the remainder on either end, and return it as a dictionary """ result = {} offset = timedelta(0) if start_date.time(): offset = timedelta(1) result['start_day'] = Arrow(start_date.year, start_date.month, start_date.day).datetime + offset result['remainder_start'] = result['start_day'] - start_date result['stop_day'] = Arrow(stop_date.year, stop_date.month, stop_date.day).datetime result['remainder_stop'] = stop_date - result['stop_day'] result['n_days'] = (result['stop_day'] - result['start_day']).days return result