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

seolpyo_mplchart/_chart/base/e_axis.py

@@ -0,0 +1,268 @@
+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(self.CONFIG.CANDLE.linewidth * 2)
+        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
+

seolpyo_mplchart/_chart/base/h_data.py

@@ -0,0 +1,138 @@
+from matplotlib.axes import Axes
+import numpy as np
+import pandas as pd
+
+from ..._config import ConfigData
+
+
+class Base:
+    CONFIG: ConfigData
+    df: pd.DataFrame
+
+    key_date = 'date'
+    key_open, key_high, key_low, key_close = ('open', 'high', 'low', 'close')
+    key_volume = 'volume'
+
+    ax_price: Axes
+    index_list: list[int] = []
+
+    set_segments: callable
+    axis: callable
+
+    def get_default_xlim(self):
+        """
+        get_default_xlim.
+
+        space = int(self.index_list[-1] / 20)
+
+        Returns:
+            (int, int): (-space, self.index_list[-1]+space)
+        """
+        # print(f'{self.index_list[-1]=}')
+        space = int(self.index_list[-1] / 20)
+        return (-space, self.index_list[-1]+space)
+
+    def set_variables(self):
+        self.index_list.clear()
+        self.index_list = self.df.index.tolist()
+        self.xmin, self.xmax = (0, self.index_list[-1])
+
+        self.chart_price_ymax = round(self.df['high'].max() * 1.3, self.CONFIG.UNIT.digit+2)
+        if self.key_volume:
+            self.chart_volume_ymax = round(self.df['volume'].max() * 1.3, self.CONFIG.UNIT.digit_volume+2)
+        else:
+            self.chart_volume_ymax = 10
+
+        if not self.CONFIG.MA.ma_list:
+            self.CONFIG.MA.ma_list = []
+        else:
+            self.CONFIG.MA.ma_list = sorted(self.CONFIG.MA.ma_list)
+
+        return
+
+    def set_data(self, df: pd.DataFrame, *, change_xlim=True):
+        """
+        `if change_xlim`: change xlim with `self.get_default_xlim()` value
+
+        `if not change_xlim`: Keep the current xlim
+        """
+        self.df = self._convert_df(df)
+
+        self._add_columns()
+        # print(f'{self.df.columns=}')
+
+        self.set_variables()
+
+        self.set_segments()
+
+        if change_xlim:
+            xmin, xmax = self.get_default_xlim()
+            self.axis(xmin, xmax=xmax)
+        return
+    
+    def _convert_df(self, df: pd.DataFrame):
+        keys = {
+            self.key_date: 'date',
+            self.key_open: 'open',
+            self.key_high: 'high',
+            self.key_low: 'low',
+            self.key_close: 'close',
+            self.key_volume: 'volume',
+        }
+        df.rename(columns=keys, inplace=True)
+
+        # df column 추출
+        if self.key_volume:
+            df = df[['date', 'open', 'high', 'low', 'close', 'volume']].copy()
+        else:
+            df = df[['date', 'open', 'high', 'low', 'close',]].copy()
+            df['volume'] = 0
+        df.loc[:, 'ymax_volume'] = df['volume'] * 1.2
+
+        # 오름차순 정렬
+        df = df.sort_values(['date'])
+        df = df.reset_index(drop=True)
+
+        return df
+
+    def _add_columns(self):
+        # 전일 종가 추가
+        self.df['pre_close'] = self.df['close'].shift(1).fillna(0)
+        # 거래정지인 경우 전일종가 적용
+        self.df.loc[self.df['close'] == 0, 'close'] = self.df['pre_close']
+        # 종가만 유효한 경우 종가로 통일
+        self.df.loc[(self.df['close'] != 0) & (self.df['open'] == 0), ['open', 'high', 'low']] = self.df['close']
+
+        # 가격이동평균선 계산
+        for ma in self.CONFIG.MA.ma_list:
+            self.df[f'ma{ma}'] = self.df['close'].rolling(ma).mean()
+
+        # 세그먼트 생성을 위한 column 추가
+        self.df['x'] = self.df.index + 0.5
+        self.df['left_candle'] = self.df['x'] - self.CONFIG.CANDLE.half_width
+        self.df['right_candle'] = self.df['x'] + self.CONFIG.CANDLE.half_width
+        self.df['left_volume'] = self.df['x'] - self.CONFIG.VOLUME.half_width
+        self.df['right_volume'] = self.df['x'] + self.CONFIG.VOLUME.half_width
+        self.df['zero'] = 0
+
+        self.df['is_up'] = np.where(self.df['open'] < self.df['close'], True, False)
+        self.df['top_candle'] = np.where(self.df['is_up'], self.df['close'], self.df['open'])
+        self.df['bottom_candle'] = np.where(self.df['is_up'], self.df['open'], self.df['close'])
+
+        return
+
+
+class DataMixin(Base):
+    key_date = 'date'
+    key_open, key_high, key_low, key_close = ('open', 'high', 'low', 'close')
+    key_volume = 'volume'
+
+    index_list: list[int] = []
+
+    df: pd.DataFrame
+
+    chart_price_ymax: float
+    chart_volume_ymax: float
+    xmin: int
+    xmax: int
+

seolpyo_mplchart/_chart/base/test.py

@@ -0,0 +1,58 @@
+import sys
+from pathlib import Path
+name_pkg = 'seolpyo_mplchart'
+path_pkg = Path(__file__)
+while path_pkg.name != name_pkg:
+    path_pkg = path_pkg.parent
+sys.path = [path_pkg.parent.__str__()] + sys.path
+
+import json
+
+import pandas as pd
+import matplotlib.pyplot as plt
+
+from seolpyo_mplchart._utils.theme import set_theme
+from seolpyo_mplchart._chart.base import Chart
+
+
+path_file = path_pkg / 'sample' / 'samsung.txt'
+with open(path_file, 'r', encoding='utf-8') as txt:
+    data = json.load(txt)
+df = pd.DataFrame(data[:])
+
+
+class C(Chart):
+    # limit_wick = 200
+    t = 'light'
+    # watermark = ''
+    def __init__(self):
+        super().__init__()
+        self.figure.canvas.mpl_connect('button_press_event', lambda x: self.theme(x))
+    
+    def theme(self, e):
+        btn = getattr(e, 'button')
+        # print(f'{str(btn)=}')
+        if str(btn) == '3':
+            # print('refresh')
+            if self.t == 'light':
+                self.t = 'dark'
+            else:
+                self.t = 'light'
+            # print(f'{self.t=}')
+            self.CONFIG = set_theme(self.CONFIG, theme=self.t)
+            self.refresh()
+        return
+
+
+def run():
+    chart = C()
+    chart.set_data(df)
+    plt.show()
+    plt.close()
+    return
+
+
+if __name__ == '__main__':
+    run()
+
+