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": "ななし１",
"point": 5
},
"mem_1000000002": {
"nickname": "ななし２",
"point": 1
},
"mem_1000000003": {
"nickname": "ななし３",
"point": 3
},
"opened": True,
})
room = Room(room_id="abcdef",
members=[
Member("1000000001", "ななし１", point=None),
Member("1000000002", "ななし２", point=None),
Member("1000000003", "ななし３", 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": "ななし１", "point": None}
assert actual["mem_1000000002"] == {"nickname": "ななし２", "point": None}
assert actual["mem_1000000003"] == {"nickname": "ななし３", "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
