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

seolpyo_mplchart/_chart/base/d_segment.py

@@ -0,0 +1,262 @@
+import pandas as pd
+import numpy as np
+
+from ..._config import ConfigData
+
+
+class DataMixin:
+    df: pd.DataFrame
+    CONFIG: ConfigData
+
+    def add_volume_color_column(self):
+        columns = ['facecolor_volume', 'edgecolor_volume']
+        face_rise = self.CONFIG.VOLUME.FACECOLOR.rise
+        face_fall = self.CONFIG.VOLUME.FACECOLOR.fall
+        edge_rise = self.CONFIG.VOLUME.EDGECOLOR.rise
+        edge_fall = self.CONFIG.VOLUME.EDGECOLOR.fall
+        face_doji = self.CONFIG.VOLUME.FACECOLOR.doji
+        edge_doji = self.CONFIG.VOLUME.EDGECOLOR.doji
+
+        # 주가 상승
+        self.df.loc[:, columns] = (face_rise, edge_rise)
+        if face_rise != face_fall or edge_rise != edge_fall:
+            # 주가 하락
+            condition = self.df['close'] < self.df['pre_close']
+            self.df.loc[condition, columns] = (face_fall, edge_fall)
+        if face_rise != face_doji or edge_rise != edge_doji:
+            # 보합
+            condition = self.df['close'] == self.df['pre_close']
+            self.df.loc[condition, columns] = (edge_doji, edge_doji)
+        return
+
+    def add_candle_color_column(self):
+        columns = ['facecolor', 'edgecolor']
+        face_bull_rise = self.CONFIG.CANDLE.FACECOLOR.bull_rise
+        face_bull_fall = self.CONFIG.CANDLE.FACECOLOR.bull_fall
+        face_bear_rise = self.CONFIG.CANDLE.FACECOLOR.bear_rise
+        face_bear_fall = self.CONFIG.CANDLE.FACECOLOR.bear_fall
+        edge_bull_rise = self.CONFIG.CANDLE.EDGECOLOR.bull_rise
+        edge_bull_fall = self.CONFIG.CANDLE.EDGECOLOR.bull_fall
+        edge_bear_rise = self.CONFIG.CANDLE.EDGECOLOR.bear_rise
+        edge_bear_fall = self.CONFIG.CANDLE.EDGECOLOR.bear_fall
+        doji = self.CONFIG.CANDLE.EDGECOLOR.doji
+
+        # 상승양봉
+        self.df.loc[:, columns] = (face_bull_rise, edge_bull_rise)
+        if face_bull_rise != face_bear_fall or edge_bull_rise != edge_bear_fall:
+            # 하락음봉
+            self.df.loc[self.df['close'] < self.df['open'], columns] = (face_bear_fall, edge_bear_fall)
+        if face_bull_rise != doji or face_bear_fall != doji or edge_bull_rise != doji or edge_bear_fall != doji:
+            # 보합
+            self.df.loc[self.df['close'] == self.df['open'], columns] = (doji, doji)
+
+        if face_bull_rise != face_bull_fall or edge_bull_rise != edge_bull_fall:
+            # 하락양봉(비우기)
+            self.df.loc[(self.df['facecolor'] == face_bull_rise) & (self.df['close'] <= self.df['pre_close']), columns] = (face_bull_fall, edge_bull_fall)
+        if face_bear_fall != face_bear_rise or edge_bear_fall != edge_bear_rise:
+            # 상승음봉(비우기)
+            self.df.loc[(self.df['facecolor'] == face_bear_fall) & (self.df['pre_close'] <= self.df['close']), columns] = (face_bear_rise, edge_bear_rise)
+        return
+
+
+class VolumeSegmentMixin(DataMixin):
+    key_volume: str
+
+    segment_volume: np.ndarray
+    segment_volume_wick: np.ndarray
+    facecolor_volume: np.ndarray
+    edgecolor_volume: np.ndarray
+
+    def set_volume_color_segments(self):
+        self.add_volume_color_column()
+
+        self.facecolor_volume = self.df['facecolor_volume'].values
+        self.edgecolor_volume = self.df['edgecolor_volume'].values
+        return
+
+    def set_volume_segments(self):
+        # 거래량 바 세그먼트
+        segment_volume_wick = self.df[[
+            'left_volume', 'zero',
+            'left_volume', 'volume',
+            'right_volume', 'volume',
+            'right_volume', 'zero',
+        ]].values
+
+        self.segment_volume = segment_volume_wick.reshape(segment_volume_wick.shape[0], 4, 2)
+
+        # 거래량 심지 세그먼트
+        segment_volume_wick = self.df[[
+            'x', 'zero',
+            'x', 'volume',
+        ]].values
+        self.segment_volume_wick = segment_volume_wick.reshape(segment_volume_wick.shape[0], 2, 2)
+
+        return
+
+
+class MethodMixin:
+    def get_candle_segment(self, *, is_up, x, left, right, top, bottom, high, low):
+        """
+        get candle segment
+
+        Args:
+            is_up (bool): (True if open < close else False)
+            x (float): center of candle
+            left (float): left of candle
+            right (float): right of candle
+            top (float): top of candle(close if `is_up` else open)
+            bottom (float): bottom of candle(open if `is_up` else close)
+            high (float): top of candle wick
+            low (float): bottom of candle wick
+
+        Returns:
+            tuple[tuple[float, float]]: candle segment
+        """
+        return (
+            (x, top),
+            (left, top), (left, bottom),
+            (x, bottom), (x, low), (x, bottom),
+            (right, bottom), (right, top),
+            (x, top), (x, high)
+        )
+
+    def get_bar_segment(self, *, is_up, x, left, right, top, bottom, high, low):
+        if is_up:
+            return (
+                (x, top),
+                (x, high),
+                (x, top),
+                (right, top),
+                (x, top),
+                (x, low),
+                (x, bottom),
+                (left, bottom),
+                (x, bottom),
+            )
+        return (
+            (x, top),
+            (x, high),
+            (x, top),
+            (left, top),
+            (x, top),
+            (x, low),
+            (x, bottom),
+            (right, bottom),
+            (x, bottom),
+        )
+
+
+class CandleSegmentMixin(MethodMixin, DataMixin):
+    segment_candle: np.ndarray
+    segment_candle_wick: np.ndarray
+    segment_priceline: np.ndarray
+    facecolor_candle: np.ndarray
+    edgecolor_candle: np.ndarray
+
+    def set_candle_color_segments(self):
+        self.add_candle_color_column()
+
+        self.facecolor_candle = self.df['facecolor'].values
+        self.edgecolor_candle = self.df['edgecolor'].values
+        return
+
+    def set_candle_segments(self):
+        # 캔들 세그먼트
+        segment_candle = []
+        for x, left, right, top, bottom, is_up, high, low in zip(
+            self.df['x'].to_numpy().tolist(),
+            self.df['left_candle'].to_numpy().tolist(), self.df['right_candle'].to_numpy().tolist(),
+            self.df['top_candle'].to_numpy().tolist(), self.df['bottom_candle'].to_numpy().tolist(),
+            self.df['is_up'].to_numpy().tolist(),
+            self.df['high'].to_numpy().tolist(), self.df['low'].to_numpy().tolist(),
+        ):
+            segment_candle.append(
+                self.get_candle_segment(
+                    is_up=is_up,
+                    x=x, left=left, right=right,
+                    top=top, bottom=bottom,
+                    high=high, low=low,
+                )
+            )
+
+        self.segment_candle = np.array(segment_candle)
+        return
+
+    def _set_candle_segments(self):
+        # 심지 세그먼트
+        segment_wick = self.df[[
+            'x', 'high',
+            'x', 'low',
+        ]].values
+        self.segment_candle_wick = segment_wick.reshape(segment_wick.shape[0], 2, 2)
+        # 종가 세그먼트
+        segment_priceline = segment_wick = self.df[['x', 'close']].values
+        self.segment_priceline = segment_priceline.reshape(1, *segment_wick.shape)
+        return
+
+
+class MaSegmentMixin(DataMixin):
+    _visible_ma: set
+
+    segment_ma: np.ndarray
+    edgecolor_ma: np.ndarray
+
+    def set_ma_segments(self):
+        # 주가 차트 가격이동평균선
+        key_ma = []
+        for i in reversed(self.CONFIG.MA.ma_list):
+            key_ma.append('x')
+            key_ma.append(f'ma{i}')
+        if key_ma:
+            segment_ma = self.df[key_ma].values
+            self.segment_ma = segment_ma.reshape(
+                segment_ma.shape[0], len(self.CONFIG.MA.ma_list), 2
+            ).swapaxes(0, 1)
+        return
+
+    def _set_ma_color_segments(self):
+        # 이평선 색상 가져오기
+        edgecolors = []
+        for n, _ in enumerate(self.CONFIG.MA.ma_list):
+            try:
+                c = self.CONFIG.MA.color_list[n]
+            except:
+                c = self.CONFIG.MA.color_default
+            edgecolors.append(c)
+
+        self.edgecolor_ma = list(reversed(edgecolors))
+
+        return
+
+
+class SegmentMixin(CandleSegmentMixin, VolumeSegmentMixin, MaSegmentMixin):
+    segment_volume: np.ndarray
+    segment_volume_wick: np.ndarray
+    facecolor_volume: np.ndarray
+    edgecolor_volume: np.ndarray
+
+    segment_candle: np.ndarray
+    segment_candle_wick: np.ndarray
+    segment_priceline: np.ndarray
+    facecolor_candle: np.ndarray
+    edgecolor_candle: np.ndarray
+
+    segment_ma: np.ndarray
+    edgecolor_ma: np.ndarray
+
+    def set_segments(self):
+        self.set_candle_segments()
+        self._set_candle_segments()
+        self.set_volume_segments()
+        self.set_ma_segments()
+
+        self.set_color_segments()
+        return
+
+    def set_color_segments(self):
+        self.set_candle_color_segments()
+        self.set_volume_color_segments()
+        self._set_ma_color_segments()
+        return
+

seolpyo_mplchart/_chart/base/e_axis.py

@@ -0,0 +1,267 @@
+from matplotlib.axes import Axes
+from matplotlib.collections import LineCollection
+from matplotlib.text import Text
+import numpy as np
+import pandas as pd
+
+from ..._config import ConfigData
+
+
+class Base:
+    CONFIG: ConfigData
+
+    key_volume: str
+    df: pd.DataFrame
+
+    index_list: list[int]
+
+    collection_candle: LineCollection
+    collection_volume: LineCollection
+    collection_ma: LineCollection
+
+    segment_candle: np.ndarray
+    segment_candle_wick: np.ndarray
+    segment_priceline: np.ndarray
+    facecolor_candle: np.ndarray
+    edgecolor_candle: np.ndarray
+
+    segment_volume: np.ndarray
+    segment_volume_wick: np.ndarray
+    facecolor_volume: np.ndarray
+    edgecolor_volume: np.ndarray
+
+    segment_ma: np.ndarray
+    edgecolor_ma: np.ndarray
+
+
+class LimMixin(Base):
+    def _get_indices(self, ind_start, *, ind_end):
+        "조회 영역에 해당하는 index 가져오기"
+        if ind_start < 0:
+            ind_start = 0
+        if ind_end < 1:
+            ind_end = 1
+
+        if ind_end < ind_start:
+            msg = 'ind_end < ind_start'
+            msg += f'  {ind_start=:,}'
+            msg += f'  {ind_end=:,}'
+            raise Exception(msg)
+        return (ind_start, ind_end)
+
+    def _get_price_ylim(self, ind_start, *, ind_end):
+        ymin, ymax = (self.df['low'][ind_start:ind_end].min(), self.df['high'][ind_start:ind_end].max())
+
+        if ymin == ymax:
+            if ymax:
+                ymin, ymax = (round(ymax * 0.9, self.CONFIG.UNIT.digit+2), round(ymax * 1.1, self.CONFIG.UNIT.digit+2))
+            else:
+                ymin, ymax = (-5, 10)
+        else:
+            height = ymax - ymin
+            if height < 15:
+                height = 15
+
+            ymin = ymin - round(height / 20, self.CONFIG.UNIT.digit+2)
+            ymax = ymax + round(height / 10, self.CONFIG.UNIT.digit+2)
+
+        return (ymin, ymax)
+
+    def _get_volume_ylim(self, ind_start, *, ind_end):
+        if not self.key_volume:
+            ymax = 1
+        else:
+            series = self.df['volume'][ind_start:ind_end]
+            # print(f'{series=}')
+            ymax = series.max()
+            height = ymax
+            ymax = ymax + round(height / 5, self.CONFIG.UNIT.digit_volume+2)
+            if ymax < 1:
+                ymax = 1
+        # print(f'{ymax=}')
+        return (0, ymax)
+
+
+class MaMixin(Base):
+    def _set_ma_collection_segments(self, ind_start, ind_end):
+        self.collection_ma.set_segments(self.segment_ma[:, ind_start:ind_end])
+        self.collection_ma.set_edgecolor(self.edgecolor_ma)
+        return
+
+
+class VolumeMixin(Base):
+    def _set_volume_collection_segments(self, ind_start, ind_end):
+        if not self.key_volume:
+            self.collection_volume.set_segments([])
+            return
+
+        self.collection_volume.set_segments(self.segment_volume[ind_start:ind_end])
+        self.collection_volume.set_linewidth(self.CONFIG.VOLUME.linewidth)
+        self.collection_volume.set_facecolor(self.facecolor_volume[ind_start:ind_end])
+        self.collection_volume.set_edgecolor(self.edgecolor_volume[ind_start:ind_end])
+        return
+
+    def _set_volume_collection_wick_segments(self, ind_start, ind_end):
+        # print(f'{(ind_start, ind_end)=}')
+        if not self.key_volume:
+            self.collection_volume.set_segments([])
+            return
+
+        seg_volume = self.segment_volume_wick[ind_start:ind_end]
+        seg_edgecolor_volume = self.edgecolor_volume[ind_start:ind_end]
+
+        self.collection_volume.set_segments(seg_volume)
+        self.collection_volume.set_linewidth(1.3)
+        self.collection_volume.set_facecolor([])
+        self.collection_volume.set_edgecolor(seg_edgecolor_volume)
+        return
+
+class CandleMixin(Base):
+    def _set_candle_collection_segments(self, ind_start, ind_end):
+        # print(f'{self.edgecolor_candle[ind_start:ind_end]=}')
+        self.collection_candle.set_segments(self.segment_candle[ind_start:ind_end])
+        self.collection_candle.set_facecolor(self.facecolor_candle[ind_start:ind_end])
+        self.collection_candle.set_edgecolor(self.edgecolor_candle[ind_start:ind_end])
+        self.collection_candle.set_linewidth(self.CONFIG.CANDLE.linewidth)
+        self.collection_candle.set_antialiased(False)
+        return
+
+    def _set_candle_collection_wick_segments(self, ind_start, ind_end):
+        # print(f'{self.edgecolor_candle[ind_start:ind_end]=}')
+        self.collection_candle.set_segments(self.segment_candle_wick[ind_start:ind_end])
+        self.collection_candle.set_facecolor([])
+        self.collection_candle.set_edgecolor(self.edgecolor_candle[ind_start:ind_end])
+        self.collection_candle.set_linewidth(1.5)
+        self.collection_candle.set_antialiased(False)
+        return
+
+    def set_candle_collection_priceline_segments(self, ind_start, ind_end):
+        self.collection_candle.set_segments(self.segment_priceline[:, ind_start:ind_end])
+        self.collection_candle.set_facecolor([])
+        self.collection_candle.set_edgecolor(self.CONFIG.CANDLE.line_color)
+        self.collection_candle.set_linewidth(2)
+        self.collection_candle.set_antialiased(True)
+        return
+
+
+class CollectionMixin(CandleMixin, VolumeMixin, MaMixin):
+    limit_candle = 400
+    limit_wick = 2_000
+
+    def set_collections(self, ind_start, *, ind_end):
+        if ind_start < 0:
+            ind_start = 0
+        indsub = ind_end - ind_start
+        # print(f'{indsub=:,}')
+
+        if not self.limit_candle or indsub < self.limit_candle:
+            # print('candle')
+            self._set_candle_collection_segments(ind_start, ind_end=ind_end)
+            self._set_volume_collection_segments(ind_start, ind_end=ind_end)
+        else:
+            self._set_volume_collection_wick_segments(ind_start, ind_end=ind_end)
+
+            if not self.limit_wick or indsub < self.limit_wick:
+                # print('wick')
+                self._set_candle_collection_wick_segments(ind_start, ind_end=ind_end)
+            else:
+                # print('line')
+                self.set_candle_collection_priceline_segments(ind_start, ind_end=ind_end)
+
+        self._set_ma_collection_segments(ind_start, ind_end=ind_end)
+        return
+
+
+class AxisMixin(LimMixin, CollectionMixin):
+    limit_candle = 400
+    limit_wick = 2_000
+
+    ax_price: Axes
+    ax_volume: Axes
+
+    vxmin: int
+    vxmax: int
+    price_ymin: int
+    price_ymax: int
+    volume_ymax: int
+
+    def axis(self, xmin, *, xmax):
+        "조회 영역 변경"
+        # print('base axis')
+        self.set_collections(xmin, ind_end=xmax+1)
+
+        self.vxmin, self.vxmax = (xmin, xmax+1)
+        ind_start, ind_end = self._get_indices(xmin, ind_end=xmax)
+
+        self.price_ymin, self.price_ymax = self._get_price_ylim(ind_start, ind_end=ind_end)
+
+        # 주가 차트 xlim
+        self.ax_price.set_xlim(self.vxmin, self.vxmax)
+        # 주가 차트 ylim
+        self.ax_price.set_ylim(self.price_ymin, self.price_ymax)
+
+        # 거래량 차트 xlim
+        self.ax_volume.set_xlim(self.vxmin, self.vxmax)
+        self.volume_ymax = 1
+        if self.key_volume:
+            _, self.volume_ymax = self._get_volume_ylim(ind_start, ind_end=ind_end)
+            # 거래량 차트 ylim
+            self.ax_volume.set_ylim(0, self.volume_ymax)
+
+        self.set_xtick_labels(xmin, xmax=xmax)
+        return
+
+    def set_xtick_labels(self, xmin, *, xmax):
+        # x축에 일부 date 표시하기
+        xsub = xmax - xmin
+        xmiddle = xmin + (xsub // 2)
+        indices = [idx for idx in (xmin, xmiddle, xmax) if 0 <= idx and idx <= self.index_list[-1]]
+        # print(f'{xmiddle=}')
+        # print(f'{indices=}')
+
+        m = (xmiddle - xmin) // 2
+        ind_end = self.index_list[-1]
+        aligns = ['left', 'center', 'center']
+        if len(indices) < 2:
+            if xmin < 0 and self.index_list[-1] < xmax:
+                indices = [0, xmiddle, ind_end]
+            else:
+                if xmin <= 0:
+                    if m <= xmax:
+                        aligns = aligns[-2:]
+                        indices = [0, xmax]
+                    else:
+                        aligns = aligns[-1:]
+                        indices = [0]
+                else:
+                    if xmin+m <= ind_end:
+                        aligns = aligns[:2]
+                        indices = [xmin, ind_end]
+                    else:
+                        aligns = aligns[:1]
+                        indices = [ind_end]
+        elif len(indices) < 3:
+            if xmin < 0:
+                if 0 <= (xmiddle - m):
+                    indices = [0] + indices
+                else:
+                    aligns = aligns[-2:]
+                    indices[0] = 0
+            else:
+                if (xmiddle + m) <= ind_end:
+                    indices.append(ind_end)
+                else:
+                    aligns = aligns[:2]
+                    indices[-1] = ind_end
+
+        date_list = [self.df.iloc[idx]['date'] for idx in indices]
+        # 라벨을 노출할 틱 위치, major tick과 겹쳐서 무시되는 것 방지
+        self.ax_volume.set_xticks([idx+0.501 for idx in indices], minor=True)
+        # 라벨
+        self.ax_volume.set_xticklabels(date_list, minor=True)
+        labels: list[Text] = self.ax_volume.get_xticklabels(minor=True)
+        for label, align in zip(labels, aligns):
+            # 라벨 텍스트 정렬
+            label.set_horizontalalignment(align)
+        return
+

seolpyo_mplchart/_chart/base/f_background.py

@@ -0,0 +1,62 @@
+from .a_canvas import Figure
+
+
+class Base:
+    _background = None
+    _background_background = None
+
+    _creating_background = False
+
+    figure: Figure
+
+    draw_chart: callable
+    draw_artists: callable
+    draw_background: callable
+
+    def _draw_canvas(self):
+        self._background = None
+        self._restore_region()
+        return
+
+    def _restore_region(self):
+        # print(f'{self._background=}')
+        if not self._background:
+            self._create_background()
+
+        self.figure.canvas.renderer.restore_region(self._background)
+        return
+
+    def _restore_region_background(self):
+        if not self._background:
+            self._create_background()
+
+        self.figure.canvas.renderer.restore_region(self._background_background)
+        return
+
+    def _create_background(self):
+        if self._creating_background:
+            return
+
+        self._creating_background = True
+        self._copy_bbox()
+        self._creating_background = False
+        return
+
+    def _copy_bbox(self):
+        renderer = self.figure.canvas.renderer
+
+        self.draw_background()
+        self._background_background = renderer.copy_from_bbox(self.figure.bbox)
+
+        self.draw_chart()
+        self.draw_artists()
+        self._background = renderer.copy_from_bbox(self.figure.bbox)
+
+        return
+
+
+class BackgroundMixin(Base):
+    _background = None
+    _background_background = None
+    _creating_background = False
+

seolpyo_mplchart/_chart/base/g_event.py

@@ -0,0 +1,66 @@
+from matplotlib.axes import Axes
+from matplotlib.backend_bases import PickEvent
+from matplotlib.collections import LineCollection
+
+from ..._config import ConfigData
+
+from .a_canvas import Figure
+
+
+class Base:
+    figure: Figure
+
+    _draw_canvas: callable
+    _set_figure_ratios: callable
+
+    def on_draw(self, e):
+        self._background = None
+        self._draw_canvas()
+        return
+
+    def on_resize(self, e):
+        self._set_figure_ratios()
+        return
+
+
+class LegendMixin:
+    CONFIG: ConfigData
+
+    figure: Figure
+    ax_legend: Axes
+    collection_ma: LineCollection
+
+    def on_pick(self, e):
+        self._pick_legend_action(e)
+        return
+
+    def _pick_legend_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 EventMixin(Base, LegendMixin):
+    def connect_events(self):
+        self.figure.canvas.mpl_connect('draw_event', lambda x: self.on_draw(x))
+        self.figure.canvas.mpl_connect('pick_event', lambda x: self.on_pick(x))
+        self.figure.canvas.mpl_connect('resize_event', lambda x: self.on_resize(x))
+        return
+