348 lines
10 KiB
Python
348 lines
10 KiB
Python
# piker: trading gear for hackers
|
|
# Copyright (C) 2018-present Tyler Goodlet (in stewardship of pikers)
|
|
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU Affero General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU Affero General Public License for more details.
|
|
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
# along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
"""
|
|
Time-series (remote) annotation APIs.
|
|
|
|
"""
|
|
from __future__ import annotations
|
|
from math import copysign
|
|
from typing import (
|
|
Any,
|
|
TYPE_CHECKING,
|
|
)
|
|
|
|
import polars as pl
|
|
import tractor
|
|
|
|
from piker.data._formatters import BGM
|
|
from piker.storage import log
|
|
from piker.toolz.profile import (
|
|
Profiler,
|
|
pg_profile_enabled,
|
|
ms_slower_then,
|
|
)
|
|
from piker.ui._style import get_fonts
|
|
|
|
if TYPE_CHECKING:
|
|
from piker.ui._remote_ctl import AnnotCtl
|
|
|
|
|
|
def humanize_duration(
|
|
seconds: float,
|
|
) -> str:
|
|
'''
|
|
Convert duration in seconds to short human-readable form.
|
|
|
|
Uses smallest appropriate time unit:
|
|
- d: days
|
|
- h: hours
|
|
- m: minutes
|
|
- s: seconds
|
|
|
|
Examples:
|
|
- 86400 -> "1d"
|
|
- 28800 -> "8h"
|
|
- 180 -> "3m"
|
|
- 45 -> "45s"
|
|
|
|
'''
|
|
abs_secs: float = abs(seconds)
|
|
|
|
if abs_secs >= 86400:
|
|
days: float = abs_secs / 86400
|
|
if days >= 10 or days == int(days):
|
|
return f'{int(days)}d'
|
|
return f'{days:.1f}d'
|
|
|
|
elif abs_secs >= 3600:
|
|
hours: float = abs_secs / 3600
|
|
if hours >= 10 or hours == int(hours):
|
|
return f'{int(hours)}h'
|
|
return f'{hours:.1f}h'
|
|
|
|
elif abs_secs >= 60:
|
|
mins: float = abs_secs / 60
|
|
if mins >= 10 or mins == int(mins):
|
|
return f'{int(mins)}m'
|
|
return f'{mins:.1f}m'
|
|
|
|
else:
|
|
if abs_secs >= 10 or abs_secs == int(abs_secs):
|
|
return f'{int(abs_secs)}s'
|
|
return f'{abs_secs:.1f}s'
|
|
|
|
|
|
async def markup_gaps(
|
|
fqme: str,
|
|
timeframe: float,
|
|
actl: AnnotCtl,
|
|
wdts: pl.DataFrame,
|
|
gaps: pl.DataFrame,
|
|
|
|
# XXX, switch on to see txt showing a "humanized" label of each
|
|
# gap's duration.
|
|
show_txt: bool = False,
|
|
|
|
# A/B comparison: render individual arrows alongside batch
|
|
# for visual comparison
|
|
show_individual_arrows: bool = False,
|
|
|
|
) -> dict[int, dict]:
|
|
'''
|
|
Remote annotate time-gaps in a dt-fielded ts (normally OHLC)
|
|
with rectangles.
|
|
|
|
'''
|
|
profiler = Profiler(
|
|
msg=f'markup_gaps() for {gaps.height} gaps',
|
|
disabled=False,
|
|
ms_threshold=0.0,
|
|
)
|
|
|
|
# XXX: force chart redraw FIRST to ensure PlotItem coordinate
|
|
# system is properly initialized before we position annotations!
|
|
# Without this, annotations may be misaligned on first creation
|
|
# due to Qt/pyqtgraph initialization race conditions.
|
|
await actl.redraw(
|
|
fqme=fqme,
|
|
timeframe=timeframe,
|
|
)
|
|
profiler('first `.redraw()` before annot creation')
|
|
|
|
log.info(
|
|
f'markup_gaps() called:\n'
|
|
f' fqme: {fqme}\n'
|
|
f' timeframe: {timeframe}s\n'
|
|
f' gaps.height: {gaps.height}\n'
|
|
)
|
|
|
|
# collect all annotation specs for batch submission
|
|
rect_specs: list[dict] = []
|
|
arrow_specs: list[dict] = []
|
|
text_specs: list[dict] = []
|
|
|
|
aids: dict[int] = {}
|
|
for i in range(gaps.height):
|
|
row: pl.DataFrame = gaps[i]
|
|
|
|
# the gap's RIGHT-most bar's OPEN value
|
|
# at that time (sample) step.
|
|
iend: int = row['index'][0]
|
|
|
|
# dt: datetime = row['dt'][0]
|
|
# dt_prev: datetime = row['dt_prev'][0]
|
|
# dt_end_t: float = dt.timestamp()
|
|
|
|
|
|
# TODO: can we eventually remove this
|
|
# once we figure out why the epoch cols
|
|
# don't match?
|
|
# TODO: FIX HOW/WHY these aren't matching
|
|
# and are instead off by 4hours (EST
|
|
# vs. UTC?!?!)
|
|
# end_t: float = row['time']
|
|
# assert (
|
|
# dt.timestamp()
|
|
# ==
|
|
# end_t
|
|
# )
|
|
|
|
# the gap's LEFT-most bar's CLOSE value
|
|
# at that time (sample) step.
|
|
prev_r: pl.DataFrame = wdts.filter(
|
|
pl.col('index') == iend - 1
|
|
)
|
|
# XXX: probably a gap in the (newly sorted or de-duplicated)
|
|
# dt-df, so we might need to re-index first..
|
|
dt: pl.Series = row['dt']
|
|
dt_prev: pl.Series = row['dt_prev']
|
|
if prev_r.is_empty():
|
|
|
|
# XXX, filter out any special ignore cases,
|
|
# - UNIX-epoch stamped datums
|
|
# - first row
|
|
if (
|
|
dt_prev.dt.epoch()[0] == 0
|
|
or
|
|
dt.dt.epoch()[0] == 0
|
|
):
|
|
log.warning('Skipping row with UNIX epoch timestamp ??')
|
|
continue
|
|
|
|
if wdts[0]['index'][0] == iend: # first row
|
|
log.warning('Skipping first-row (has no previous obvi) !!')
|
|
continue
|
|
|
|
# XXX, if the previous-row by shm-index is missing,
|
|
# meaning there is a missing sample (set), get the prior
|
|
# row by df index and attempt to use it?
|
|
i_wdts: pl.DataFrame = wdts.with_row_index(name='i')
|
|
i_row: int = i_wdts.filter(pl.col('index') == iend)['i'][0]
|
|
prev_row_by_i = wdts[i_row]
|
|
prev_r: pl.DataFrame = prev_row_by_i
|
|
|
|
# debug any missing pre-row
|
|
if tractor._state.is_debug_mode():
|
|
await tractor.pause()
|
|
|
|
istart: int = prev_r['index'][0]
|
|
# TODO: implement px-col width measure
|
|
# and ensure at least as many px-cols
|
|
# shown per rect as configured by user.
|
|
# gap_w: float = abs((iend - istart))
|
|
# if gap_w < 6:
|
|
# margin: float = 6
|
|
# iend += margin
|
|
# istart -= margin
|
|
|
|
opn: float = row['open'][0]
|
|
cls: float = prev_r['close'][0]
|
|
|
|
# get gap duration for humanized label
|
|
gap_dur_s: float = row['s_diff'][0]
|
|
gap_label: str = humanize_duration(gap_dur_s)
|
|
|
|
# XXX: get timestamps for server-side index lookup
|
|
start_time: float = prev_r['time'][0]
|
|
end_time: float = row['time'][0]
|
|
|
|
# BGM=0.16 is the normal diff from overlap between bars, SO
|
|
# just go slightly "in" from that "between them".
|
|
from_idx: int = BGM - .06 # = .10
|
|
lc: tuple[float, float] = (
|
|
istart + 1 - from_idx,
|
|
cls,
|
|
)
|
|
ro: tuple[float, float] = (
|
|
iend + from_idx,
|
|
opn,
|
|
)
|
|
|
|
diff: float = cls - opn
|
|
sgn: float = copysign(1, diff)
|
|
up_gap: bool = sgn == -1
|
|
down_gap: bool = sgn == 1
|
|
flat: bool = sgn == 0
|
|
|
|
color: str = 'dad_blue'
|
|
# TODO? mks more sense to have up/down coloring?
|
|
# color: str = {
|
|
# -1: 'lilypad_green', # up-gap
|
|
# 1: 'wine', # down-gap
|
|
# }[sgn]
|
|
|
|
# collect rect spec (no fqme/timeframe, added by batch
|
|
# API)
|
|
rect_spec: dict[str, Any] = dict(
|
|
meth='set_view_pos',
|
|
start_pos=lc,
|
|
end_pos=ro,
|
|
color=color,
|
|
update_label=False,
|
|
start_time=start_time,
|
|
end_time=end_time,
|
|
)
|
|
rect_specs.append(rect_spec)
|
|
|
|
direction: str = (
|
|
'down' if down_gap
|
|
else 'up'
|
|
)
|
|
|
|
# collect arrow spec
|
|
gap_time: float = row['time'][0]
|
|
arrow_spec: dict[str, Any] = dict(
|
|
x=iend, # fallback if timestamp lookup fails
|
|
y=cls,
|
|
time=gap_time, # for server-side index lookup
|
|
color=color,
|
|
alpha=169,
|
|
pointing=direction,
|
|
headLen=10,
|
|
headWidth=2.222,
|
|
pxMode=True,
|
|
)
|
|
arrow_specs.append(arrow_spec)
|
|
|
|
# add duration label to RHS of arrow
|
|
if up_gap:
|
|
anchor = (0, 0)
|
|
# ^XXX? i dun get dese dims.. XD
|
|
elif down_gap:
|
|
anchor = (0, 1) # XXX y, x?
|
|
else: # no-gap?
|
|
assert flat
|
|
anchor = (0, 0) # up from bottom
|
|
|
|
# collect text spec if enabled
|
|
if show_txt:
|
|
font, small_font = get_fonts()
|
|
font_size: int = small_font.px_size - 1
|
|
|
|
text_spec: dict[str, Any] = dict(
|
|
text=gap_label,
|
|
x=iend + 1, # fallback if timestamp lookup fails
|
|
y=cls,
|
|
time=gap_time, # server-side index lookup
|
|
color=color,
|
|
anchor=anchor,
|
|
font_size=font_size,
|
|
)
|
|
text_specs.append(text_spec)
|
|
|
|
# submit all annotations in single batch IPC msg
|
|
log.info(
|
|
f'Submitting batch annotations:\n'
|
|
f' rects: {len(rect_specs)}\n'
|
|
f' arrows: {len(arrow_specs)}\n'
|
|
f' texts: {len(text_specs)}\n'
|
|
)
|
|
profiler('built all annotation specs')
|
|
|
|
result: dict[str, list[int]] = await actl.add_batch(
|
|
fqme=fqme,
|
|
timeframe=timeframe,
|
|
rects=rect_specs,
|
|
arrows=arrow_specs,
|
|
texts=text_specs,
|
|
show_individual_arrows=show_individual_arrows,
|
|
)
|
|
profiler('batch `.add_batch()` IPC call complete')
|
|
|
|
# build aids dict from batch results
|
|
for aid in result['rects']:
|
|
aids[aid] = {'type': 'rect'}
|
|
for aid in result['arrows']:
|
|
aids[aid] = {'type': 'arrow'}
|
|
for aid in result['texts']:
|
|
aids[aid] = {'type': 'text'}
|
|
|
|
log.info(
|
|
f'Batch submission complete: {len(aids)} annotation(s) '
|
|
f'created'
|
|
)
|
|
profiler('built aids result dict')
|
|
|
|
# tell chart to redraw all its graphics view layers
|
|
await actl.redraw(
|
|
fqme=fqme,
|
|
timeframe=timeframe,
|
|
)
|
|
profiler('final `.redraw()` after annot creation')
|
|
|
|
return aids
|