seolpyo-mplchart 1.4.1__py3-none-any.whl → 2.1.0__py3-none-any.whl

seolpyo_mplchart/_chart/cursor/d_segment.py

@@ -0,0 +1,359 @@
+from fractions import Fraction
+
+from matplotlib.axes import Axes
+from matplotlib.collections import LineCollection
+from matplotlib.text import Text
+from matplotlib.backend_bases import MouseEvent
+import pandas as pd
+
+from ..._config import ConfigData
+from ..._utils.nums import float_to_str
+from ..base.a_canvas import Figure
+
+
+class Base:
+    CONFIG: ConfigData
+
+    key_volume: str
+    _length_text: int
+    df: pd.DataFrame
+
+    watermark: str
+
+    v0: int
+    v1: int
+    vmiddle: int
+    vxmin: int
+    vxmax: int
+    price_ymin: int
+    price_ymax: int
+    volume_ymax: int
+
+    figure: Figure
+    ax_legend: Axes
+    ax_price: Axes
+    ax_volume: Axes
+    artist_watermark: Text
+    collection_candle: LineCollection
+    collection_volume: LineCollection
+    collection_ma: LineCollection
+
+    collection_price_crossline: LineCollection
+    collection_volume_crossline: LineCollection
+
+    artist_label_x: Text
+    artist_label_y: Text
+
+    collection_box_price: LineCollection
+    collection_box_volume: LineCollection
+
+    artist_info_candle: Text
+    artist_info_volume: Text
+
+    in_chart_price: bool
+    in_chart_volume: bool
+
+
+class CrosslineMixin(Base):
+    def _set_crossline(self, e: MouseEvent,):
+        x, y = (e.xdata, e.ydata)
+
+        if self.in_chart_price:
+            seg = [
+                [
+                    (x, self.price_ymin),
+                    (x, self.price_ymax),
+                ],
+                [
+                    (self.vxmin, y),
+                    (self.vxmax, y),
+                ]
+            ]
+            self.collection_price_crossline.set_segments(seg)
+            seg = [
+                [
+                    (x, 0),
+                    (x, self.volume_ymax),
+                ]
+            ]
+            self.collection_volume_crossline.set_segments(seg)
+        elif self.in_chart_volume:
+            seg = [
+                [
+                    (x, self.price_ymin),
+                    (x, self.price_ymax),
+                ]
+            ]
+            self.collection_price_crossline.set_segments(seg)
+            seg = [
+                [
+                    (x, 0),
+                    (x, self.volume_ymax),
+                ],
+                [
+                    (self.vxmin, y),
+                    (self.vxmax, y)
+                ]
+            ]
+            self.collection_volume_crossline.set_segments(seg)
+
+        return
+
+
+class LabelMixin(Base):
+    def _set_label_x(self, e: MouseEvent):
+        xdata, ydata = (e.xdata, e.xdata)
+        # print(f'{(x, xdata)=}')
+
+        if xdata < 0 or xdata is None:
+            return
+
+        try:
+            text = self.df.iloc[int(xdata)]['date']
+        except:
+            return
+        # print(f'{text=}')
+
+        display_coords = e.inaxes.transData.transform((xdata, ydata))
+        figure_coords = self.figure.transFigure.inverted()\
+            .transform(display_coords)
+        # print(f'{figure_coords=}')
+
+        artist = self.artist_label_x
+
+        artist.set_text(text)
+        artist.set_x(figure_coords[0])
+        self._set_label_x_position()
+        return 1
+
+    def _set_label_x_position(self):
+        artist = self.artist_label_x
+        renderer = self.figure.canvas.renderer
+
+        # Axes 하단 경계 좌표
+        boundary = self.ax_volume.get_position()\
+            .y0
+        # print(f'{y0=}')
+
+        if not artist.get_text():
+            artist.set_text(' ')
+
+        # Text bbox 너비
+        bbox = artist.get_bbox_patch()\
+            .get_window_extent(renderer)
+        bbox_size = bbox.height
+        # 밀어야 하는 값
+        fig_size = self.figure.bbox.height
+        offset = (bbox_size + 10) / fig_size
+        # print(f'{box_width_fig=}')
+
+        # x축 값(가격 또는 거래량)
+        # self.artist_label_y.set_x(x1)
+        y = boundary - (offset / 2)
+        # print(f'{(x1, x)=}')
+        artist.set_y(y)
+        return
+
+    def _set_label_y(self, e: MouseEvent, *, is_price_chart):
+        xdata, ydata = (e.xdata, e.ydata)
+        artist = self.artist_label_y
+
+        if is_price_chart:
+            text = float_to_str(ydata, digit=self.CONFIG.UNIT.digit) + self.CONFIG.UNIT.price
+        else:
+            text = float_to_str(ydata, digit=self.CONFIG.UNIT.digit_volume) + self.CONFIG.UNIT.volume
+
+        display_coords = e.inaxes.transData.transform((xdata, ydata))
+        figure_coords = self.figure.transFigure.inverted().transform(display_coords)
+
+        artist.set_text(text)
+        artist.set_y(figure_coords[1])
+        self._set_label_y_position()
+        return
+
+    def _set_label_y_position(self):
+        artist = self.artist_label_y
+        renderer = self.figure.canvas.renderer
+
+        # Axes 우측 경계 좌표
+        boundary = self.ax_volume.get_position()\
+            .x1
+        # print(f'{boundary=}')
+
+        if not artist.get_text():
+            artist.set_text(' ')
+
+        # Text bbox 너비
+        bbox = artist.get_bbox_patch()\
+            .get_window_extent(renderer)
+        bbox_size = bbox.width
+        # 밀어야 하는 값
+        fig_size = self.figure.bbox.width
+        offset = (bbox_size + 8) / fig_size
+        # print(f'{box_width_fig=}')
+
+        # x축 값(가격 또는 거래량)
+        # self.artist_label_y.set_x(x1)
+        x = boundary + (offset / 2)
+        # print(f'{(x1, x)=}')
+        artist.set_x(x)
+        return
+
+
+class BoxMixin(Base):
+    def _set_box_candle(self, segment):
+        self.collection_box_price.set_segments(segment)
+        return
+
+    def _set_box_volume(self, segment):
+        self.collection_box_volume.set_segments(segment)
+        return
+
+
+class InfoMixin(Base):
+    fraction = False
+
+    def _set_info_candle(self, ind):
+        text = self._get_info(ind, is_price=True)
+        self.artist_info_candle.set_text(text)
+
+        # 정보 텍스트를 중앙에 몰리게 설정할 수도 있지만,
+        # 그런 경우 차트를 가리므로 좌우 끝단에 위치하도록 설정
+        if self.vmiddle < ind:
+            self.artist_info_candle.set_x(self.v0)
+        else:
+            # self.artist_info_candle.set_x(self.vmax - self.x_distance)
+            # self.artist_info_candle.set_horizontalalignment('right')
+            # 텍스트박스 크기 가져오기
+            bbox = self.artist_info_candle.get_window_extent()\
+                .transformed(self.ax_price.transData.inverted())
+            width = bbox.x1 - bbox.x0
+            self.artist_info_candle.set_x(self.v1 - width)
+
+        self.artist_info_candle.draw(self.figure.canvas.renderer)
+        return
+
+    def _set_info_volume(self, ind):
+        text = self._get_info(ind, is_price=False)
+        self.artist_info_volume.set_text(text)
+
+        if self.vmiddle < ind:
+            self.artist_info_volume.set_x(self.v0)
+        else:
+            # self.artist_info_volume.set_x(self.vmax - self.x_distance)
+            # self.artist_info_volume.set_horizontalalignment('right')
+            # 텍스트박스 크기 가져오기
+            bbox = self.artist_info_volume.get_window_extent()\
+                .transformed(self.ax_price.transData.inverted())
+            width = bbox.x1 - bbox.x0
+            self.artist_info_volume.set_x(self.v1 - width)
+
+        self.artist_info_volume.draw(self.figure.canvas.renderer)
+        return
+
+    def get_info_kwargs(self, is_price: bool, **kwargs)-> dict:
+        """
+        get text info kwargs
+
+        Args:
+            is_price (bool): is price chart info or not
+
+        Returns:
+            dict[str, any]: text info kwargs
+        """
+        return kwargs
+
+    def _get_info(self, ind: int, is_price=True):
+        # print(f'{self._length_text=}')
+        series = self.df.iloc[ind]
+
+        dt = series['date']
+        if not self.key_volume:
+            v, vr = ('-', '-')
+        else:
+            v, vr = series.loc[['volume', 'rate_volume']]
+            # print(f'{self.CONFIG.UNIT.digit_volume=}')
+            v = float_to_str(v, digit=self.CONFIG.UNIT.digit_volume)
+            # if not v % 1:
+            #     v = int(v)
+            vr = f'{vr:+06,.2f}'
+
+        if is_price:
+            o, h, l, c = (series['open'], series['high'], series['low'], series['close'])
+            rate, compare = (series['rate'], series['compare'])
+            r = f'{rate:+06,.2f}'
+            Or, hr, lr = (series['rate_open'], series['rate_high'], series['rate_low'])
+
+            if self.fraction:
+                data = {}
+                c = round(c, self.CONFIG.UNIT.digit)
+                for value, key in [
+                    [c, 'close'],
+                    [compare, 'compare'],
+                    [o, 'open'],
+                    [h, 'high'],
+                    [l, 'low'],
+                ]:
+                    div = divmod(value, 1)
+                    if div[1]:
+                        if div[0]:
+                            data[key] = f'{float_to_str(div[0])} {Fraction((div[1]))}'
+                        else:
+                            data[key] = f'　 {Fraction((div[1]))}'
+                    else:
+                        data[key] = float_to_str(div[0])
+                # print(f'{data=}')
+
+                kwargs = self.get_info_kwargs(
+                    is_price=is_price,
+                    dt=dt,
+                    close=f'{data["close"]:>{self._length_text}}{self.CONFIG.UNIT.price}',
+                    rate=f'{r:>{self._length_text}}%',
+                    compare=f'{data["compare"]:>{self._length_text}}{self.CONFIG.UNIT.price}',
+                    open=f'{data["open"]:>{self._length_text}}{self.CONFIG.UNIT.price}', rate_open=f'{Or:+06,.2f}%',
+                    high=f'{data["high"]:>{self._length_text}}{self.CONFIG.UNIT.price}', rate_high=f'{hr:+06,.2f}%',
+                    low=f'{data["low"]:>{self._length_text}}{self.CONFIG.UNIT.price}', rate_low=f'{lr:+06,.2f}%',
+                    volume=f'{v:>{self._length_text}}{self.CONFIG.UNIT.volume}', rate_volume=f'{vr}%',
+                )
+                text = self.CONFIG.FORMAT.candle.format(**kwargs)
+            else:
+                o, h, l, c = (
+                    float_to_str(o, digit=self.CONFIG.UNIT.digit),
+                    float_to_str(h, digit=self.CONFIG.UNIT.digit),
+                    float_to_str(l, digit=self.CONFIG.UNIT.digit),
+                    float_to_str(c, digit=self.CONFIG.UNIT.digit),
+                )
+                com = float_to_str(compare, digit=self.CONFIG.UNIT.digit, plus=True)
+
+                kwargs = self.get_info_kwargs(
+                    is_price=is_price,
+                    dt=dt,
+                    close=f'{c:>{self._length_text}}{self.CONFIG.UNIT.price}',
+                    rate=f'{r:>{self._length_text}}%',
+                    compare=f'{com:>{self._length_text}}{self.CONFIG.UNIT.price}',
+                    open=f'{o:>{self._length_text}}{self.CONFIG.UNIT.price}', rate_open=f'{Or:+06,.2f}%',
+                    high=f'{h:>{self._length_text}}{self.CONFIG.UNIT.price}', rate_high=f'{hr:+06,.2f}%',
+                    low=f'{l:>{self._length_text}}{self.CONFIG.UNIT.price}', rate_low=f'{lr:+06,.2f}%',
+                    volume=f'{v:>{self._length_text}}{self.CONFIG.UNIT.volume}', rate_volume=f'{vr}%',
+                )
+                text = self.CONFIG.FORMAT.candle.format(**kwargs)
+        elif self.key_volume:
+            compare = self.df.loc[ind, 'compare_volume']
+            com = float_to_str(compare, digit=self.CONFIG.UNIT.digit_volume, plus=True)
+            kwargs = self.get_info_kwargs(
+                is_price=is_price,
+                dt=dt,
+                volume=f'{v:>{self._length_text}}{self.CONFIG.UNIT.volume}',
+                rate_volume=f'{vr:>{self._length_text}}%',
+                compare=f'{com:>{self._length_text}}{self.CONFIG.UNIT.volume}',
+            )
+            text = self.CONFIG.FORMAT.volume.format(**kwargs)
+        else:
+            text = ''
+
+        return text
+
+
+class SegmentMixin(CrosslineMixin, LabelMixin, BoxMixin, InfoMixin):
+    fraction = False
+

seolpyo_mplchart/_chart/cursor/e_axis.py

@@ -0,0 +1,65 @@
+from matplotlib.axes import Axes
+from matplotlib.text import Text
+
+from ..base.a_canvas import Figure
+
+
+
+class Base:
+    figure: Figure
+    ax_price: Axes
+    ax_volume: Axes
+
+    key_volume: str
+
+    vxmin: int
+    vxmax: int
+    price_ymin: int
+    price_ymax: int
+    volume_ymax: int
+
+    artist_info_candle: Text
+    artist_info_volume: Text
+    artist_label_x: Text
+    artist_label_y: Text
+
+    axis: callable
+
+
+class Mixin(Base):
+    def axis(self, xmin, *, xmax):
+        super().axis(xmin, xmax=xmax)
+        # print('cursor axis')
+
+        psub = (self.price_ymax - self.price_ymin)
+        self.min_height_box_candle = psub / 8
+
+        pydistance = psub / 20
+
+        self.min_height_box_volume = 10
+        if self.key_volume:
+            self.min_height_box_volume = self.volume_ymax / 4
+
+        vxsub = self.vxmax - self.vxmin
+        self.vmiddle = self.vxmax - int((vxsub) / 2)
+
+        vxdistance = vxsub / 50
+        self.v0, self.v1 = (self.vxmin + vxdistance, self.vxmax - vxdistance)
+
+        yvolume = self.volume_ymax * 0.85
+
+        # 정보 텍스트박스 y축 설정
+        self.artist_info_candle.set_y(self.price_ymax - pydistance)
+        self.artist_info_volume.set_y(yvolume)
+
+        return
+
+
+class AxisMixin(Mixin):
+    v0: int
+    v1: int
+    vmiddle: int
+
+    min_height_box_candle: float
+    min_height_box_volume: float
+

seolpyo_mplchart/_chart/cursor/g_event.py

@@ -0,0 +1,233 @@
+from matplotlib.axes import Axes
+from matplotlib.backend_bases import MouseEvent
+from matplotlib.collections import LineCollection
+from matplotlib.text import Text
+import pandas as pd
+
+from ..base.a_canvas import Figure
+
+
+class Base:
+    figure: Figure
+    ax_price: Axes
+    ax_volume: Axes
+
+    key_volume: str
+    df: pd.DataFrame
+
+    vxmin: int
+    vxmax: int
+    price_ymin: float
+    price_ymax: float
+    volume_ymax: float
+
+    collection_box_price: LineCollection
+    collection_box_volume: LineCollection
+    collection_price_crossline: LineCollection
+
+    index_list: list
+
+    min_height_box_candle: float
+    min_height_box_volume: float
+
+    connect_events: callable
+
+    artist_label_x: Text
+    artist_label_y: Text
+
+    in_chart = False
+    in_chart_price = False
+    in_chart_volume = False
+
+    in_candle = False
+    in_volume = False
+
+    _restore_region: callable
+
+    _set_crossline: callable
+    _draw_crossline: callable
+    _set_label_x: callable
+    _draw_label_x: callable
+
+    _set_label_y: callable
+    _draw_label_y: callable
+
+    _set_box_candle: callable
+    _draw_box_candle: callable
+    _set_box_volume: callable
+    _draw_box_volume: callable
+
+    _set_info_candle: callable
+    _draw_info_candle: callable
+    _set_info_volume: callable
+    _draw_info_volume: callable
+
+
+class AxMixin(Base):
+    def _check_ax(self, e: MouseEvent):
+        ax = e.inaxes
+        # print(f'{ax=}')
+        self.in_chart = False
+        self.in_chart_price, self.in_chart_volume = (False, False)
+
+        if e.xdata is None or e.ydata is None:
+            return
+
+        if self.vxmin <= e.xdata and e.xdata <= self.vxmax:
+            if ax is self.ax_price and (
+                self.price_ymin <= e.ydata and e.ydata <= self.price_ymax
+            ):
+                self.in_chart = True
+                self.in_chart_price = True
+            elif ax is self.ax_volume and (
+                0 <= e.ydata and e.ydata <= self.volume_ymax
+            ):
+                self.in_chart = True
+                self.in_chart_volume = True
+        return
+
+
+class BoxMixin(Base):
+    def _draw_box_artist(self, e: MouseEvent):
+        xdata, ydata = (e.xdata, e.ydata)
+        ind = int(xdata)
+
+        self.in_candle, self.in_volume = (False, False)
+
+        if self.in_chart_price:
+            series = self.df.iloc[ind]
+            # print(f'{series=}')
+            # 박스 크기
+            high = series['box_candle_top']
+            low = series['box_candle_bottom']
+            height = series['box_candle_height']
+            # print(f'{(low, high)=}')
+            # print(f'{height=}')
+
+            # 박스 높이 보정
+            if height < self.min_height_box_candle:
+                sub = (self.min_height_box_candle - height) / 2
+                high, low = (high+sub, low-sub)
+
+            # 커서가 캔들 사이에 있는지 확인
+            if low <= ydata and ydata <= high:
+                self.in_candle = True
+
+                # 캔들 강조
+                x0, x1 = (ind-0.3, ind+1.3)
+                segment = [(
+                    (x0, high),
+                    (x1, high),
+                    (x1, low),
+                    (x0, low),
+                    (x0, high)
+                )]
+                self._set_box_candle(segment)
+                self._draw_box_candle()
+
+                return 1
+        elif self.in_chart_volume and self.key_volume:
+            # 박스 크기
+            high = self.df.iloc[ind]['box_volume_top']
+            low = 0
+            if high < self.min_height_box_volume:
+                high = self.min_height_box_volume
+
+            if low <= ydata and ydata <= high:
+                # 거래량 강조
+                self.in_volume = True
+
+                x0, x1 = (ind-0.3, ind+1.3)
+                segment = [(
+                    (x0, high),
+                    (x1, high),
+                    (x1, low),
+                    (x0, low),
+                    (x0, high)
+                )]
+                self._set_box_volume(segment)
+                self._draw_box_volume()
+
+                return 1
+        return
+
+
+class InfoMixin(Base):
+    def _draw_info_artist(self, e: MouseEvent):
+        return
+
+
+class Mixin(AxMixin, BoxMixin, InfoMixin):
+    _in_mouse_move = False
+
+    def need_restore(self):
+        if self.collection_price_crossline.get_segments():
+            self.collection_price_crossline.set_segments([])
+            return True
+        return
+
+    def _on_move(self, e: MouseEvent):
+        # print(f'{not self._in_mouse_move=}')
+        if not self._in_mouse_move:
+            self._in_mouse_move = True
+            # print(f'{(e.xdata, e.ydata)=}')
+            self.on_move(e)
+            self._in_mouse_move = False
+        return
+
+    def on_move(self, e: MouseEvent):
+        self._check_ax(e)
+        self._on_move_action(e)
+        return
+
+    def _set_and_draw_crossline(self, e: MouseEvent):
+        self._set_crossline(e)
+        self._draw_crossline()
+
+        if self._set_label_x(e):
+            # print('draw label x')
+            self._draw_label_x()
+            if self._draw_box_artist(e):
+                ind = int(e.xdata)
+                if self.in_chart_price:
+                    self._set_info_candle(ind)
+                    self._draw_info_candle()
+                else:
+                    self._set_info_volume(ind)
+                    self._draw_info_volume()
+        self._set_label_y(e, is_price_chart=self.in_chart_price)
+        self._draw_label_y()
+
+        return
+
+    def _on_move_action(self, e: MouseEvent):
+        if self.in_chart:
+            self._restore_region()
+
+            self._set_and_draw_crossline(e)
+
+            self.figure.canvas.blit()
+            self.figure.canvas.flush_events()
+        elif self.need_restore():
+            self._restore_region()
+            self.figure.canvas.blit()
+            self.figure.canvas.flush_events()
+        return
+
+
+class EventMixin(Mixin):
+    in_chart = False
+    in_chart_price = False
+    in_chart_volume = False
+
+    in_candle = False
+    in_volume = False
+
+    _in_mouse_move = False
+
+    def connect_events(self):
+        super().connect_events()
+
+        self.figure.canvas.mpl_connect('motion_notify_event', lambda x: self._on_move(x))
+        return
+