seolpyo-mplchart 0.1.3.1__py3-none-any.whl → 2.0.0.3__py3-none-any.whl

seolpyo_mplchart/_chart/_draw/_lim.py

@@ -0,0 +1,265 @@
+from matplotlib.backend_bases import PickEvent
+from matplotlib.text import Text
+import numpy as np
+
+from ._data import BaseMixin as Base
+
+
+class EventMixin(Base):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.connect_events()
+        return
+
+    def connect_events(self):
+        self._connect_events()
+        return
+
+    def _connect_events(self):
+        self.figure.canvas.mpl_connect('pick_event', lambda x: self.on_pick(x))
+        return
+
+    def on_pick(self, e):
+        self._on_pick(e)
+        return
+
+    def _on_pick(self, e):
+        self._pick_ma_action(e)
+        return
+
+    def _pick_ma_action(self, e: PickEvent):
+        handle = e.artist
+        ax = handle.axes
+        # print(f'{(ax is self.ax_legend)=}')
+        if ax is not self.ax_legend:
+            return
+
+        visible = handle.get_alpha() == 0.2
+        handle.set_alpha(1.0 if visible else 0.2)
+
+        n = int(handle.get_label())
+        if visible:
+            self._visible_ma = {i for i in self.CONFIG.MA.ma_list if i in self._visible_ma or i == n}
+        else:
+            self._visible_ma = {i for i in self._visible_ma if i != n}
+
+        alphas = [(1 if i in self._visible_ma else 0) for i in reversed(self.CONFIG.MA.ma_list)]
+        self.collection_ma.set_alpha(alphas)
+
+        self.figure.canvas.draw()
+        return
+
+
+class LimMixin(EventMixin):
+    candle_on_ma = True
+
+    def _set_data(self, df, *args, **kwargs):
+        super()._set_data(df, *args, **kwargs)
+
+        self.set_segments()
+
+        vmin, vmax = self.get_default_lim()
+        self.axis(vmin, xmax=vmax, simpler=False, draw_ma=True)
+
+        # 노출 영역에 맞게 collection segment 조정하기
+        self.set_collections(self.vxmin, xmax=self.vxmax, simpler=False, draw_ma=True)
+        return
+
+    def axis(self, xmin, *, xmax, simpler=False, draw_ma=True):
+        self._axis(xmin, xmax=xmax, simpler=simpler, draw_ma=draw_ma)
+        return
+
+    def _convert_xlim(self, xmin, *, xmax):
+        if xmin < 0:
+            xmin = 0
+        if xmax < 1:
+            xmax = 1
+        return (xmin, xmax)
+
+    def _get_price_ylim(self, xmin, *, xmax):
+        ymin, ymax = (self.df['low'][xmin:xmax].min(), self.df['high'][xmin:xmax].max())
+        ysub = ymax - ymin
+        if ysub < 15:
+            ysub = 15
+        yspace = ysub / 14
+        ymin = ymin - yspace
+        ymax = ymax + yspace
+        if ymin == ymax:
+            if ymax:
+                ymin, ymax = (round(ymax * 0.9), round(ymax * 1.1))
+            else:
+                ymin, ymax = (0, 10)
+        return (ymin, ymax)
+
+    def _get_volume_ylim(self, xmin, *, xmax):
+        if not self.key_volume:
+            ymax = 1
+        else:
+            series = self.df['volume'][xmin:xmax]
+            # print(f'{series=}')
+            ymax = series.max()
+            yspace = ymax / 5
+            ymax = ymax + yspace
+            if ymax < 1:
+                ymax = 1
+        # print(f'{ymax=}')
+        return (0, ymax)
+
+    def _axis(self, xmin, xmax, simpler=False, draw_ma=True):
+        self.set_collections(xmin, xmax=xmax, simpler=simpler, draw_ma=draw_ma)
+
+        self.vxmin, self.vxmax = (xmin, xmax)
+        xmin, xmax = self._convert_xlim(xmin, xmax=xmax)
+
+        self.price_ymin, self.price_ymax = self._get_price_ylim(xmin, xmax=xmax)
+
+        # 주가 차트 xlim
+        self.ax_price.set_xlim(self.vxmin, xmax)
+        # 주가 차트 ylim
+        self.ax_price.set_ylim(self.price_ymin, self.price_ymax)
+
+        # 거래량 차트 xlim
+        self.ax_volume.set_xlim(self.vxmin, xmax)
+        self.key_volume_ymax = 1
+        if self.key_volume:
+            _, self.key_volume_ymax = self._get_volume_ylim(xmin, xmax=xmax)
+            # 거래량 차트 ylim
+            self.ax_volume.set_ylim(0, self.key_volume_ymax)
+
+        # x축에 일부 date 표시하기
+        # x tick 외부 눈금 표시
+        self.ax_volume.xaxis.set_ticks_position('bottom')
+        xhalf = (xmax-xmin) // 2
+        xmiddle = xmin + xhalf
+        indices = []
+        aligns = ['left', 'center', 'center']
+        for idx in [xmin, xmiddle, xmax-1]:
+            if idx <= self.index_list[-1]:
+                indices.append(idx)
+        # print(f'{indices=}')
+        if xmin == 0 and self.vxmin < 0:
+            if xhalf / 2 < xmin - indices[-1]:
+                indices = [indices[-1]]
+                aligns = aligns[2:]
+            else:
+                indices = [0, indices[-1]]
+                aligns = aligns[1:]
+        elif len(indices) < 2:
+            if xmin - indices[-1] < xhalf / 2:
+                indices = [xmin, self.index_list[-1]]
+                aligns = [aligns[0], aligns[0]]
+        elif len(indices) < 3:
+            indices[-1] = self.index_list[-1]
+            aligns = aligns[:2]
+        
+        date_list = [self.df.iloc[idx]['date'] for idx in indices]
+        # 라벨을 노출할 틱 위치
+        self.ax_volume.set_xticks([idx+0.5 for idx in indices])
+        # 라벨
+        self.ax_volume.set_xticklabels(date_list)
+        labels: list[Text] = self.ax_volume.get_xticklabels()
+        for label, align in zip(labels, aligns):
+            # 라벨 텍스트 정렬
+            label.set_horizontalalignment(align)
+        return
+
+    def set_collections(self, xmin, *, xmax, simpler=False, draw_ma=True):
+        self._set_collections(xmin, index_end=xmax, simpler=simpler, draw_ma=draw_ma)
+        return
+
+    def _set_collections(self, index_start, *, index_end, simpler, draw_ma):
+        return
+
+    def get_default_lim(self):
+        return (0, self.index_list[-1]+1)
+
+
+class CollectionMixin(LimMixin):
+    limit_candle = 400
+    limit_wick = 2_000
+    limit_volume = 200
+    limit_ma = None
+
+    def _set_collections(self, index_start, *, index_end, simpler, draw_ma):
+        if index_start < 0:
+            index_start = 0
+        indsub = index_end - index_start
+        # print(f'{indsub=:,}')
+
+        if not self.limit_candle or indsub < self.limit_candle:
+            # print('candle')
+            self._set_candle_segments(index_start, index_end=index_end)
+            self._set_volume_segments(index_start, index_end=index_end)
+        else:
+            self._set_volume_wick_segments(index_start, index_end, simpler=simpler)
+
+            if not self.limit_wick or indsub < self.limit_wick:
+                # print('wick')
+                self._set_candle_wick_segments(index_start, index_end)
+            else:
+                # print('line')
+                self._set_priceline_segments(index_start, index_end)
+
+        self._set_ma_segments(index_start, index_end, draw_ma)
+        return
+
+    def _set_candle_segments(self, index_start, index_end):
+        self.collection_candle.set_segments(self.segment_candle[index_start:index_end])
+        self.collection_candle.set_facecolor(self.facecolor_candle[index_start:index_end])
+        self.collection_candle.set_edgecolor(self.edgecolor_candle[index_start:index_end])
+        return
+
+    def _set_candle_wick_segments(self, index_start, index_end):
+        self.collection_candle.set_segments(self.segment_candle_wick[index_start:index_end])
+        self.collection_candle.set_facecolor([])
+        self.collection_candle.set_edgecolor(self.edgecolor_candle[index_start:index_end])
+        return
+
+    def _set_priceline_segments(self, index_start, index_end):
+        self.collection_candle.set_segments(self.segment_priceline[:, index_start:index_end])
+        self.collection_candle.set_facecolor([])
+        self.collection_candle.set_edgecolor(self.CONFIG.CANDLE.line_color)
+        return
+
+    def _set_ma_segments(self, index_start, index_end, draw_ma):
+        if not draw_ma:
+            self.collection_ma.set_segments([])
+        else:
+            self.collection_ma.set_segments(self.segment_ma[:, index_start:index_end])
+            self.collection_ma.set_edgecolor(self.edgecolor_ma)
+        return
+
+    def _set_volume_segments(self, index_start, index_end):
+        if not self.key_volume:
+            self.collection_volume.set_segments([])
+            return
+        self.collection_volume.set_segments(self.segment_volume[index_start:index_end])
+        self.collection_volume.set_linewidth(0.7)
+        self.collection_volume.set_facecolor(self.facecolor_volume[index_start:index_end])
+        self.collection_volume.set_edgecolor(self.edgecolor_volume[index_start:index_end])
+        return
+
+    def _set_volume_wick_segments(self, index_start, index_end, simpler):
+        if not self.key_volume:
+            self.collection_volume.set_segments([])
+            return
+        seg_volume = self.segment_volume_wick[index_start:index_end]
+        seg_facecolor_volume = self.facecolor_volume[index_start:index_end]
+        seg_edgecolor_volume = self.edgecolor_volume[index_start:index_end]
+        if simpler:
+            values = seg_volume[:, 1, 1]
+            top_index = np.argsort(-values)[:self.limit_volume]
+            seg_volume = seg_volume[top_index]
+            seg_facecolor_volume = seg_facecolor_volume[top_index]
+            seg_edgecolor_volume = seg_edgecolor_volume[top_index]
+        self.collection_volume.set_segments(seg_volume)
+        self.collection_volume.set_linewidth(1.3)
+        self.collection_volume.set_facecolor(seg_facecolor_volume)
+        self.collection_volume.set_edgecolor(seg_edgecolor_volume)
+        return
+
+
+class BaseMixin(CollectionMixin):
+    pass
+

seolpyo_mplchart/_chart/_slider/__init__.py

@@ -0,0 +1 @@
+from ._nav import BaseMixin, Chart

seolpyo_mplchart/_chart/_slider/_base.py

@@ -0,0 +1,268 @@
+import matplotlib.pyplot as plt
+from matplotlib.axes import Axes
+from matplotlib.collections import LineCollection
+from matplotlib.text import Text
+
+from ..._config import SLIDERCONFIG, SliderConfigData
+from .._cursor import BaseMixin as Base
+
+
+class PlotMixin(Base):
+    slider_top = True
+    CONFIG: SliderConfigData
+
+    def __init__(self, config=SLIDERCONFIG, *args, **kwargs):
+        super().__init__(config=config, *args, **kwargs)
+        return
+
+    def add_axes(self):
+        if self.slider_top:
+            self.figure, axes = plt.subplots(
+                4, # row 수
+                figsize=self.CONFIG.FIGURE.figsize, # 기본 크기
+                height_ratios=(
+                    self.CONFIG.FIGURE.RATIO.slider,
+                    self.CONFIG.FIGURE.RATIO.legend,
+                    self.CONFIG.FIGURE.RATIO.price, self.CONFIG.FIGURE.RATIO.volume
+                ) # row 크기 비율
+            )
+            axes: list[Axes]
+            self.ax_slider, self.ax_legend, self.ax_price, self.ax_volume = axes
+        else:
+            self.figure, axes = plt.subplots(
+                5, # row 수
+                figsize=self.CONFIG.FIGURE.figsize, # 기본 크기
+                height_ratios=(
+                    self.CONFIG.FIGURE.RATIO.legend,
+                    self.CONFIG.FIGURE.RATIO.price, self.CONFIG.FIGURE.RATIO.volume,
+                    self.CONFIG.FIGURE.RATIO.none,
+                    self.CONFIG.FIGURE.RATIO.slider
+                ) # row 크기 비율
+            )
+            axes: list[Axes]
+            self.ax_legend, self.ax_price, self.ax_volume, ax_none, self.ax_slider = axes
+
+            ax_none.set_axis_off()
+            ax_none.xaxis.set_animated(True)
+            ax_none.yaxis.set_animated(True)
+
+        self.ax_slider.set_label('slider ax')
+        self.ax_legend.set_label('legend ax')
+        self.ax_price.set_label('price ax')
+        self.ax_volume.set_label('volume ax')
+        self.ax_legend.set_axis_off()
+
+        # y ticklabel foramt 설정
+        self.ax_slider.yaxis.set_major_formatter(lambda x, _: self.CONFIG.UNIT.func(x, word=self.CONFIG.UNIT.price, digit=self.CONFIG.UNIT.digit))
+        self.ax_price.yaxis.set_major_formatter(lambda x, _: self.CONFIG.UNIT.func(x, word=self.CONFIG.UNIT.price, digit=self.CONFIG.UNIT.digit))
+        self.ax_volume.yaxis.set_major_formatter(lambda x, _: self.CONFIG.UNIT.func(x, word=self.CONFIG.UNIT.volume, digit=self.CONFIG.UNIT.digit))
+
+        # 공통 설정
+        for ax in (self.ax_slider, self.ax_price, self.ax_volume):
+            ax.xaxis.set_animated(True)
+            ax.yaxis.set_animated(True)
+
+            # x tick 외부 눈금 표시하지 않기
+            ax.xaxis.set_ticks_position('none')
+            # x tick label 제거
+            ax.set_xticklabels([])
+            # y tick 우측으로 이동
+            ax.tick_params(
+                left=False, right=True, labelleft=False, labelright=True,
+                colors=self.CONFIG.AX.TICK.edgecolor
+            )
+        return
+
+    def _set_axes(self):
+        super()._set_axes()
+
+        self.ax_slider.set_facecolor(self.CONFIG.AX.facecolor)
+        self.ax_slider.grid(**self.CONFIG.AX.GRID.__dict__)
+
+        # 틱 색상
+        self.ax_slider.tick_params('both', colors=self.CONFIG.AX.TICK.edgecolor)
+        # 틱 라벨 색상
+        ticklabels: list[Text] = self.ax_slider.get_xticklabels() + self.ax_slider.get_yticklabels()
+        for ticklabel in ticklabels:
+            ticklabel.set_color(self.CONFIG.AX.TICK.fontcolor)
+        return
+
+    def _set_figure(self):
+        self.figure.canvas.manager.set_window_title('Seolpyo MPLChart')
+
+        # 차트 비율 변경
+        # print(f'{self.CONFIG.FIGURE.RATIO.volume=}')
+        gs = self.ax_price.get_subplotspec().get_gridspec()
+        if len(self.figure.axes) == 4:
+            gs.set_height_ratios([
+                self.CONFIG.FIGURE.RATIO.slider,
+                self.CONFIG.FIGURE.RATIO.legend,
+                self.CONFIG.FIGURE.RATIO.price, self.CONFIG.FIGURE.RATIO.volume,
+            ])
+        else:
+            gs.set_height_ratios([
+                self.CONFIG.FIGURE.RATIO.legend,
+                self.CONFIG.FIGURE.RATIO.price, self.CONFIG.FIGURE.RATIO.volume,
+                self.CONFIG.FIGURE.RATIO.none,
+                self.CONFIG.FIGURE.RATIO.slider,
+            ])
+        self.figure.tight_layout()
+
+        # 플롯간 간격 설정(Configure subplots)
+        self.figure.subplots_adjust(**self.CONFIG.FIGURE.ADJUST.__dict__)
+
+        self.figure.set_facecolor(self.CONFIG.FIGURE.facecolor)
+        return
+
+
+class CollectionMixin(PlotMixin):
+    def add_artists(self):
+        super().add_artists()
+
+        # 슬라이더에 그려질 주가 선형 차트
+        self.collection_slider = LineCollection([], animated=True)
+        self.ax_slider.add_artist(self.collection_slider)
+
+        # 슬라이더 네비게이터
+        self.collection_navigator = LineCollection([], animated=True, alpha=(0.3, 1.0))
+        self.ax_slider.add_artist(self.collection_navigator)
+
+        # 현재 위치 표시용 line
+        self.collection_slider_vline = LineCollection(segments=[], animated=True)
+        self.ax_slider.add_artist(self.collection_slider_vline)
+
+        # 현대 위치에 해당하는 date 출력용 text
+        self.artist_text_slider = Text(text='', animated=True, horizontalalignment='center', verticalalignment='top')
+        self.ax_slider.add_artist(self.artist_text_slider)
+
+        self._set_slider_artists()
+        return
+
+    def _set_slider_artists(self):
+        edgecolors = [self.CONFIG.SLIDER.NAVIGATOR.facecolor, self.CONFIG.SLIDER.NAVIGATOR.edgecolor]
+        self.collection_navigator.set_edgecolor(edgecolors)
+
+        kwargs = self.CONFIG.CURSOR.CROSSLINE.__dict__
+        kwargs.update({'segments': [], 'animated': True})
+        self.collection_slider_vline.set(**kwargs)
+
+        kwargs = self.CONFIG.CURSOR.TEXT.to_dict()
+        kwargs.update({'text': ' ', 'animated': True})
+        self.artist_text_slider.set(**kwargs)
+        return
+
+    def _set_artists(self):
+        super()._set_artists()
+
+        self._set_slider_artists()
+        self._set_slider_collection()
+        return
+
+    def _set_slider_collection(self):
+        keys = []
+        for i in reversed(self.CONFIG.MA.ma_list):
+            keys.append('x')
+            keys.append(f'ma{i}')
+
+        series = self.df[keys + ['x', 'close']]
+        series['x'] = series['x'] - 0.5
+        segment_slider = series.values
+        sizes = [segment_slider.shape[0], len(self.CONFIG.MA.ma_list)+1, 2]
+        segment_slider = segment_slider.reshape(*sizes).swapaxes(0, 1)
+        self.collection_slider.set_segments(segment_slider)
+
+        linewidth = []
+        ma_colors = []
+        for n, _ in enumerate(self.CONFIG.MA.ma_list):
+            linewidth.append(0.9)
+            try:
+                ma_colors.append(self.CONFIG.MA.color_list[n])
+            except:
+                ma_colors.append(self.CONFIG.MA.color_default)
+
+        self.collection_slider.set_linewidth(linewidth + [2.4])
+        self.collection_slider.set_edgecolor(ma_colors + [self.CONFIG.CANDLE.line_color])
+        return
+
+
+class NavigatorMixin(CollectionMixin):
+    def _connect_events(self):
+        super()._connect_events()
+
+        self.figure.canvas.mpl_connect('resize_event', lambda x: self.on_resize(x))
+        return
+
+    def on_resize(self, e):
+        self._on_resize(e)
+        return
+
+    def _on_resize(self, e):
+        self._set_navigator_artists()
+        return
+
+    def _refresh(self):
+        super()._refresh()
+        self._set_navigator_artists()
+        return
+
+    def _set_navigator_artists(self):
+        if not getattr(self, 'index_list', False):
+            return
+        xmax = self.index_list[-1]
+        # 슬라이더 xlim
+        xdistance = xmax / 30
+        self.slider_xmin, self.slider_xmax = (-xdistance, xmax+xdistance)
+        self.ax_slider.set_xlim(self.slider_xmin, self.slider_xmax)
+
+        # 슬라이더 ylim
+        ymin, ymax = (self.df['low'].min(), self.df['high'].max())
+        ysub = ymax - ymin
+        self.sldier_ymiddle = ymin + (ysub / 2)
+        ydistance = ysub / 5
+        self.slider_ymin, self.slider_ymax = (ymin-ydistance, ymax+ydistance)
+        self.ax_slider.set_ylim(self.slider_ymin, self.slider_ymax)
+
+        # 슬라이더 텍스트 y
+        self.artist_text_slider.set_y(ymax)
+
+        self.collection_navigator.set_linewidth([self.ax_slider.bbox.height, 5])
+
+        # 슬라이더 라인 선택 범위
+        xsub = self.slider_xmax - self.slider_xmin
+        self._navLineWidth = xsub * 8 / 1_000
+        if self._navLineWidth < 1:
+            self._navLineWidth = 1
+        self._navLineWidth_half = self._navLineWidth / 2
+        return
+
+    def _axis_navigator(self, navmin, navmax):
+        seg = [
+            # 좌측 오버레이
+            (
+                (self.slider_xmin, self.sldier_ymiddle),
+                (navmin, self.sldier_ymiddle),
+            ),
+            # 좌측 네비게이터
+            (
+                (navmin, self.slider_ymin),
+                (navmin, self.slider_ymax),
+            ),
+            # 우측 네비게이터
+            (
+                (navmax, self.sldier_ymiddle),
+                (self.slider_xmax, self.sldier_ymiddle),
+            ),
+            # 우측 오버레이
+            (
+                (navmax, self.slider_ymin),
+                (navmax, self.slider_ymax),
+            ),
+        ]
+
+        self.collection_navigator.set_segments(seg)
+        return
+
+
+class BaseMixin(NavigatorMixin):
+    min_distance = 5
+

seolpyo_mplchart/_chart/_slider/_data.py

@@ -0,0 +1,105 @@
+from ._base import BaseMixin as Base
+
+
+class DataMixin(Base):
+    navcoordinate: tuple[int, int] = (0, 0)
+
+    def set_data(self, df, change_lim=True, *args, **kwargs):
+        # print(f'{change_lim=}')
+        return super().set_data(df, change_lim=change_lim, *args, **kwargs)
+
+    def _set_data(self, df, change_lim=True, *args, **kwargs):
+        # print(f'{change_lim=}')
+        super()._set_data(df, *args, **kwargs)
+
+        vmin, vmax = self.navcoordinate
+        min_distance = 5 if not self.min_distance or self.min_distance < 5 else self.min_distance
+        if not change_lim and min_distance <= (vmax-vmin):
+            vmax += 1
+        else:
+            vmin, vmax = self.get_default_lim()
+            self.navcoordinate = (vmin, vmax-1)
+
+        self._set_slider_collection()
+
+        self.axis(vmin, xmax=vmax)
+
+        self._set_navigator_artists()
+        self._set_slider_xtick()
+
+        self._axis_navigator(*self.navcoordinate)
+
+        self._set_length_text()
+        return
+
+    def _set_slider_xtick(self):
+        if self.slider_top:
+            self.ax_slider.xaxis.set_ticks_position('top')
+        else:
+            self.ax_slider.xaxis.set_ticks_position('bottom')
+        self.ax_slider.get_yticks()
+
+        # grid가 xtick에 영향을 받기 때문에 구간별 tick을 설정해주어야 한다.
+        step = len(self.index_list) // 6
+        indices = []
+        for idx in self.index_list[::step]:
+            indices.append(idx)
+        if indices[-1] + 1 < self.index_list[-1]:
+            indices += [self.index_list[-1]]
+        else:
+            indices[-1] = self.index_list[-1]
+        # print(f'{indices=}')
+        # tick label은 0과 -1 구간에만 설정
+        date_list = ['' for _ in indices]
+        date_list[0] = self.df.iloc[0]['date']
+        date_list[-1] = self.df.iloc[-1]['date']
+        # xtick 설정
+        self.ax_slider.set_xticks(indices)
+        self.ax_slider.set_xticklabels(date_list)
+        labels = self.ax_slider.get_xticklabels()
+        for label, align in zip(labels, ['center', 'center']):
+            # 라벨 텍스트 정렬
+            label.set_horizontalalignment(align)
+        return
+
+    def get_default_lim(self):
+        xmax = self.index_list[-1] + 1
+        xmin = xmax - 120
+        if xmin < 0:
+            xmin = 0
+        return (xmin, xmax)
+
+
+class BackgroundMixin(DataMixin):
+    def _copy_bbox(self):
+        renderer = self.figure.canvas.renderer
+
+        self.ax_slider.xaxis.draw(renderer)
+        self.ax_slider.yaxis.draw(renderer)
+        self.collection_slider.draw(renderer)
+        self.background_emtpy = renderer.copy_from_bbox(self.figure.bbox)
+
+        self.draw_artists()
+        self.background = renderer.copy_from_bbox(self.figure.bbox)
+
+        self.collection_navigator.draw(renderer)
+        self.background_with_nav = renderer.copy_from_bbox(self.figure.bbox)
+        return
+
+    def _restore_region(self, is_empty=False, with_nav=True):
+        if not self.background:
+            self._create_background()
+
+        func = self.figure.canvas.renderer.restore_region
+        if is_empty:
+            func(self.background_emtpy)
+        elif with_nav:
+            func(self.background_with_nav)
+        else:
+            func(self.background)
+        return
+
+
+class BaseMixin(BackgroundMixin):
+    pass
+