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

seolpyo_mplchart/_chart/_base.py

@@ -0,0 +1,217 @@
+import matplotlib.pyplot as plt
+import matplotlib.style as mplstyle
+from matplotlib.axes import Axes
+from matplotlib.backends.backend_agg import FigureCanvasAgg, RendererAgg
+from matplotlib.backend_bases import FigureManagerBase
+from matplotlib.figure import Figure as Fig
+from matplotlib.text import Text
+
+from .._config import DEFAULTCONFIG
+
+try: plt.switch_backend('TkAgg')
+except: pass
+
+# 한글 깨짐 문제 방지
+try: plt.rcParams['font.family'] ='Malgun Gothic'
+except: pass
+
+mplstyle.use('fast')
+
+
+class Canvas(FigureCanvasAgg):
+    manager: FigureManagerBase
+    renderer = RendererAgg
+
+class Figure(Fig):
+    canvas: Canvas
+
+
+class Base:
+    watermark = 'seolpyo mplchart'
+
+    figure: Figure
+
+    def __init__(self, config=DEFAULTCONFIG):
+        # 기본 툴바 비활성화
+        plt.rcParams['toolbar'] = 'None'
+        # plt.rcParams['figure.dpi'] = 600
+
+        self.CONFIG = config
+        self.add_axes()
+        self.set_window()
+        return
+
+    def add_axes(self):
+        self.figure, axes = plt.subplots(
+            3, # row 수
+            figsize=self.CONFIG.FIGURE.figsize, # 기본 크기
+            height_ratios=(
+                self.CONFIG.FIGURE.RATIO.legend,
+                self.CONFIG.FIGURE.RATIO.price,
+                self.CONFIG.FIGURE.RATIO.volume,
+            ) # row 크기 비율
+        )
+
+        axes: list[Axes]
+        self.ax_legend, self.ax_price, self.ax_volume = axes
+        self.ax_legend.set_label('legend ax')
+        self.ax_price.set_label('price ax')
+        self.ax_volume.set_label('volume ax')
+
+        # 이평선 라벨 axis 그리지 않기
+        self.ax_legend.set_axis_off()
+
+        # y ticklabel foramt 설정
+        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_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)
+        return
+
+
+    def set_window(self):
+        self._set_figure()
+        self._set_axes()
+        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()
+        gs.set_height_ratios([
+            self.CONFIG.FIGURE.RATIO.legend,
+            self.CONFIG.FIGURE.RATIO.price,
+            self.CONFIG.FIGURE.RATIO.volume,
+        ])
+        # print(f'{gs.get_height_ratios()=}')
+        self.figure.tight_layout()
+
+        # 플롯간 간격 설정(Configure subplots)
+        self.figure.subplots_adjust(**self.CONFIG.FIGURE.ADJUST.__dict__)
+
+        self.figure.set_facecolor(self.CONFIG.FIGURE.facecolor)
+        return
+
+    def _set_axes(self):
+        self._set_axes_legend()
+
+        # 공통 설정
+        for ax in (self.ax_price, self.ax_volume):
+            # 차트 영역 배경 색상
+            ax.set_facecolor(self.CONFIG.AX.facecolor)
+
+            # Axes 외곽선 색 변경(틱 색과 일치)
+            for i in ['top', 'bottom', 'left', 'right']:
+                ax.spines[i].set_color(self.CONFIG.AX.TICK.edgecolor)
+            # 틱 색상
+            ax.tick_params('both', colors=self.CONFIG.AX.TICK.edgecolor)
+            # 틱 라벨 색상
+            ticklabels: list[Text] = ax.get_xticklabels() + ax.get_yticklabels()
+            for ticklabel in ticklabels:
+                ticklabel.set_color(self.CONFIG.AX.TICK.fontcolor)
+
+            # Axes grid(구분선, 격자) 그리기
+            # 어째서인지 grid의 zorder 값을 선언해도 1.6을 값으로 한다.
+            ax.grid(**self.CONFIG.AX.GRID.__dict__)
+        return
+
+    def _set_axes_legend(self):
+        color = self.CONFIG.AX.facecolor
+
+        # 이평선 라벨 Axes 배경색
+        legends = self.ax_legend.get_legend()
+        if legends:
+            legends.get_frame().set_facecolor(color)
+
+        # 이평선 라벨 Axes 테두리색
+        color = self.CONFIG.AX.TICK.edgecolor
+        legends = self.ax_legend.get_legend()
+        if legends:
+            legends.get_frame().set_edgecolor(color)
+
+        # 이평선 라벨 폰트 색상
+        color = self.CONFIG.AX.TICK.fontcolor
+        legends = self.ax_legend.get_legend()
+        if legends:
+            legend_labels: list[Text] = legends.texts
+            for i in legend_labels:
+                i.set_color(color)
+        return
+
+
+class ArtistMixin(Base):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.add_artists()
+        return
+
+    def add_artists(self):
+        self._add_artists()
+        return
+
+    def _add_artists(self):
+        self._add_watermark()
+        self._set_wartermark()
+        return
+
+    def set_artists(self):
+        self._set_artists()
+        return
+
+    def _set_artists(self):
+        self._set_wartermark()
+        return
+
+    def _add_watermark(self):
+        self.artist_watermark = Text(
+            x=0.5, y=0.5, text='',
+            animated=True,
+            horizontalalignment='center', verticalalignment='center',
+            transform=self.ax_price.transAxes
+        )
+        self.ax_price.add_artist(self.artist_watermark)
+        return
+
+    def _set_wartermark(self):
+        self.artist_watermark.set_text(self.watermark)
+        self.artist_watermark.set_fontsize(self.CONFIG.FIGURE.WATERMARK.fontsize)
+        self.artist_watermark.set_color(self.CONFIG.FIGURE.WATERMARK.color)
+        self.artist_watermark.set_alpha(self.CONFIG.FIGURE.WATERMARK.alpha)
+        return
+
+
+class BaseMixin(ArtistMixin):
+    def refresh(self):
+        self._refresh()
+        self.figure.canvas.draw()
+        return
+
+    def _refresh(self):
+        self.set_window()
+        self.set_artists()
+        return

seolpyo_mplchart/_chart/_cursor/__init__.py

@@ -0,0 +1,2 @@
+from ._info import BaseMixin, Chart
+

seolpyo_mplchart/_chart/_cursor/_artist.py

@@ -0,0 +1,217 @@
+from matplotlib.collections import LineCollection
+from matplotlib.text import Text
+import pandas as pd
+
+from .._draw import BaseMixin as Base
+
+
+class ArtistMixin(Base):
+    def _add_artists(self):
+        super()._add_artists()
+
+        self._add_crosslines()
+        self._set_crosslines()
+
+        self._add_label_texts()
+        self._set_label_texts()
+
+        self._add_info_texts()
+        self._set_info_texts()
+
+        self._add_box_collections()
+        self._set_box_collections()
+        return
+
+    def _set_artists(self):
+        super()._set_artists()
+
+        self._set_crosslines()
+        self._set_label_texts()
+        self._set_info_texts()
+        self._set_box_collections()
+        return
+
+    def _add_crosslines(self):
+        kwargs = {'segments': [], 'animated': True}
+
+        self.collection_price_crossline = LineCollection(**kwargs)
+        self.ax_price.add_artist(self.collection_price_crossline)
+
+        self.collection_volume_crossline = LineCollection(**kwargs)
+        self.ax_volume.add_artist(self.collection_volume_crossline)
+        return
+
+    def _set_crosslines(self):
+        kwargs = self.CONFIG.CURSOR.CROSSLINE.__dict__
+        kwargs.update({'segments': [], 'animated': True})
+
+        self.collection_price_crossline.set(**kwargs)
+        self.collection_volume_crossline.set(**kwargs)
+        return
+
+    def _add_label_texts(self):
+        kwargs = {'text': '', 'animated': True, 'horizontalalignment': 'center', 'verticalalignment': 'top'}
+
+        self.artist_text_x = Text(**kwargs)
+        self.figure.add_artist(self.artist_text_x)
+
+        kwargs.update({'horizontalalignment': 'left', 'verticalalignment': 'center'})
+        self.artist_text_y = Text(**kwargs)
+        self.figure.add_artist(self.artist_text_y)
+        return
+
+    def _set_label_texts(self):
+        kwargs = self.CONFIG.CURSOR.TEXT.to_dict()
+        kwargs.update({'text': ' ', 'animated': True, 'horizontalalignment': 'center', 'verticalalignment': 'top'})
+
+        self.artist_text_x.set(**kwargs)
+
+        kwargs.update({'horizontalalignment': 'left', 'verticalalignment': 'center'})
+        self.artist_text_y.set(**kwargs)
+        return
+
+    def _add_box_collections(self):
+        kwargs = {'segments': [], 'animated': True,}
+
+        self.collection_box_price = LineCollection(**kwargs)
+        self.ax_price.add_artist(self.collection_box_price)
+        self.collection_box_volume = LineCollection(**kwargs)
+        self.ax_volume.add_artist(self.collection_box_volume)
+        return
+
+    def _set_box_collections(self):
+        kwargs = self.CONFIG.CURSOR.BOX.__dict__
+        kwargs.update({'segments': [], 'animated': True,})
+
+        self.collection_box_price.set(**kwargs)
+        self.collection_box_volume.set(**kwargs)
+        return
+
+    def _add_info_texts(self):
+        kwargs = {'text': '', 'animated': True, 'horizontalalignment': 'left', 'verticalalignment': 'top',}
+
+        self.artist_info_candle = Text(**kwargs)
+        self.ax_price.add_artist(self.artist_info_candle)
+        self.artist_info_volume = Text(**kwargs)
+        self.ax_volume.add_artist(self.artist_info_volume)
+        return
+
+    def _set_info_texts(self):
+        kwargs = self.CONFIG.CURSOR.TEXT.to_dict()
+        kwargs.update({'text': '', 'animated': True, 'horizontalalignment': 'left', 'verticalalignment': 'top',})
+
+        self.artist_info_candle.set(**kwargs)
+        self.artist_info_volume.set(**kwargs)
+        return
+
+
+class DataMixin(ArtistMixin):
+    def _set_data(self, df: pd.DataFrame, *args, **kwargs):
+        super()._set_data(df, *args, **kwargs)
+
+        self.df['compare'] = (self.df['close'] - self.df['pre_close']).fillna(0)
+        self.df['rate'] = (self.df['compare'] * 100 / self.df['pre_close']).__round__(2).fillna(0)
+        self.df['rate_open'] = ((self.df['open'] - self.df['pre_close']) * 100 / self.df['pre_close']).__round__(2).fillna(0)
+        self.df['rate_high'] = ((self.df['high'] - self.df['pre_close']) * 100 / self.df['pre_close']).__round__(2).fillna(0)
+        self.df['rate_low'] = ((self.df['low'] - self.df['pre_close']) * 100 / self.df['pre_close']).__round__(2).fillna(0)
+        if self.key_volume:
+            self.df['pre_volume'] = self.df['volume'].shift(1)
+            self.df['compare_volume'] = (self.df['volume'] - self.df['pre_volume']).fillna(0)
+            self.df['rate_volume'] = (self.df['compare_volume'] * 100 / self.df['pre_volume']).__round__(2).fillna(0)
+
+        self.df['space_box_candle'] = (self.df['high'] - self.df['low']) / 5
+        self.df['bottom_box_candle'] = self.df['low'] - self.df['space_box_candle']
+        self.df['top_box_candle'] = self.df['high'] + self.df['space_box_candle']
+        self.df['height_box_candle'] = self.df['top_box_candle'] - self.df['bottom_box_candle']
+        if self.key_volume: self.df['max_box_volume'] = self.df['volume'] * 1.15
+
+        self._set_label_texts_position()
+        return
+
+    def _refresh(self):
+        super()._refresh()
+        
+        self._set_label_texts_position()
+        return
+
+    def _axis(self, xmin, xmax, simpler=False, draw_ma=True):
+        super()._axis(xmin, xmax=xmax, simpler=simpler, draw_ma=draw_ma)
+
+        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.key_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.key_volume_ymax * 0.85
+
+        # 정보 텍스트박스 y축 설정
+        self.artist_info_candle.set_y(self.price_ymax - pydistance)
+        self.artist_info_volume.set_y(yvolume)
+
+        return
+
+    def _set_label_texts_position(self):
+        self._set_label_x_position()
+        self._set_label_y_position()
+        return
+
+    def _set_label_x_position(self):
+        renderer = getattr(self.figure.canvas, 'renderer', None)
+        if not renderer:
+            renderer
+
+        # Axes 우측 경계 좌표
+        x1 = self.ax_price.get_position().x1
+        # Text bbox 너비
+        bbox = self.artist_text_y.get_bbox_patch()\
+            .get_window_extent(renderer)
+        bbox_width = bbox.width
+        # 밀어야 하는 x값
+        fig_width = self.figure.bbox.width
+        # fig_width = self.figure.get_size_inches()[0] * self.figure.dpi
+        box_width_fig = (bbox_width+14) / fig_width
+        # print(f'{box_width_fig=}')
+
+        # x축 값(가격 또는 거래량)
+        # self.artist_text_y.set_x(x1)
+        x = x1 + (box_width_fig / 2)
+        # print(f'{(x1, x)=}')
+        self.artist_text_y.set_x(x)
+        return
+
+    def _set_label_y_position(self):
+        renderer = getattr(self.figure.canvas, 'renderer', None)
+        if not renderer:
+            return
+
+        # Axes 하단 경계 좌표
+        y0 = self.ax_volume.get_position().y0
+        # Text bbox 높이
+        bbox = self.artist_text_x.get_bbox_patch()\
+            .get_window_extent(renderer)
+        height_px = bbox.height
+        # print(f'{height_px=}')
+        # 밀어야 하는 y값
+        fig_height_px = self.figure.bbox.height
+        box_height_fig = (height_px+14) / fig_height_px
+
+        # y축 값(날짜)
+        y = y0 - (box_height_fig/2)
+        # print(f'{(y0, y)=}')
+        self.artist_text_x.set_y(y)
+        return
+
+
+class BaseMixin(DataMixin):
+    pass
+

seolpyo_mplchart/_chart/_cursor/_cursor.py

@@ -0,0 +1,165 @@
+from matplotlib.backend_bases import MouseEvent
+
+from ._artist import BaseMixin as Base
+from ..._config.utils import float_to_str
+
+
+class EventMixin(Base):
+    in_price_chart, in_volume_chart = (False, False)
+    intx = None
+
+    def _connect_events(self):
+        super()._connect_events()
+
+        self.figure.canvas.mpl_connect('motion_notify_event', lambda x: self.on_move(x))
+        return
+
+    def on_move(self, e):
+        self._on_move_action(e)
+        return
+
+    def _on_move_action(self, e: MouseEvent):
+        self._check_ax(e)
+
+        self.intx = None
+        if self.in_price_chart or self.in_volume_chart: self._get_x(e)
+        return
+
+    def _get_x(self, e: MouseEvent):
+        self.intx = e.xdata.__int__()
+        if self.intx < 0: self.intx = None
+        else:
+            try: self.index_list[self.intx]
+            except: self.intx = None
+        return
+
+    def _check_ax(self, e: MouseEvent):
+        ax = e.inaxes
+        if not ax or e.xdata is None or e.ydata is None:
+            self.in_price_chart, self.in_volume_chart = (False, False)
+        else:
+            if ax is self.ax_price:
+                self.in_price_chart = True
+                self.in_volume_chart = False
+            elif ax is self.ax_volume:
+                self.in_price_chart = False
+                self.in_volume_chart = True
+            else:
+                self.in_price_chart = False
+                self.in_volume_chart = False
+        return
+
+
+class CrossLineMixin(EventMixin):
+    in_candle, in_volumebar = (False, False)
+
+    def _on_move_action(self, e):
+        super()._on_move_action(e)
+
+        if self.in_price_chart or self.in_volume_chart:
+            self._restore_region()
+            self._draw_crossline(e)
+            self.figure.canvas.blit()
+        else:
+            if self._erase_crossline():
+                self._restore_region()
+                self.figure.canvas.blit()
+        return
+
+    def _erase_crossline(self):
+        seg = self.collection_price_crossline.get_segments()
+        if seg:
+            self.collection_price_crossline.set_segments([])
+            return True
+        return False
+
+    def _draw_crossline(self, e: MouseEvent):
+        x, y = (e.xdata, e.ydata)
+
+        if self.in_price_chart:
+            self.collection_price_crossline.set_segments([((x, self.price_ymin), (x, self.price_ymax)), ((self.vxmin, y), (self.vxmax, y))])
+            self.collection_volume_crossline.set_segments([((x, 0), (x, self.key_volume_ymax))])
+        else:
+            self.collection_price_crossline.set_segments([((x, self.price_ymin), (x, self.price_ymax))])
+            self.collection_volume_crossline.set_segments([((x, 0), (x, self.key_volume_ymax)), ((self.vxmin, y), (self.vxmax, y))])
+
+        renderer = self.figure.canvas.renderer
+        self.collection_price_crossline.draw(renderer)
+        self.collection_volume_crossline.draw(renderer)
+
+        self._draw_text_artist(e)
+        return
+
+    def _draw_text_artist(self, e: MouseEvent):
+        x, y = (e.xdata, e.ydata)
+
+        display_coords = e.inaxes.transData.transform((e.xdata, e.ydata))
+        figure_coords = self.figure.transFigure.inverted().transform(display_coords)
+        # print(f'{figure_coords=}')
+
+        renderer = self.figure.canvas.renderer
+        if self.in_price_chart:
+            text = f'{float_to_str(y, digit=self.CONFIG.UNIT.digit)}{self.CONFIG.UNIT.price}'
+        else:
+            text = f'{float_to_str(y, digit=self.CONFIG.UNIT.digit_volume)}{self.CONFIG.UNIT.volume}'
+
+        # y축 값(가격 또는 거래량)
+        self.artist_text_y.set_text(text)
+        self.artist_text_y.set_y(figure_coords[1])
+        self.artist_text_y.draw(renderer)
+
+        if self.intx is not None:
+            # x축 값(날짜)
+            self.artist_text_x.set_text(f'{self.df['date'][self.intx]}')
+            self.artist_text_x.set_x(figure_coords[0])
+            self.artist_text_x.draw(renderer)
+        return
+
+
+class BoxMixin(CrossLineMixin):
+    def _draw_crossline(self, e):
+        super()._draw_crossline(e)
+        self._draw_box_artist(e)
+        return
+
+    def _draw_box_artist(self, e: MouseEvent):
+        y = e.ydata
+
+        renderer = self.figure.canvas.renderer
+
+        self.in_candle = False
+        self.in_volumebar = False
+        if self.intx is not None:
+            if self.in_price_chart:
+                # 박스 크기
+                high = self.df['top_box_candle'][self.intx]
+                low = self.df['bottom_box_candle'][self.intx]
+                height = self.df['height_box_candle'][self.intx]
+                if height < self.min_height_box_candle:
+                    sub = (self.min_height_box_candle - height) / 2
+                    high, low = (high+sub, low-sub)
+
+                # 커서가 캔들 사이에 있는지 확인
+                if low <= y and y <= high:
+                    # 캔들 강조
+                    self.in_candle = True
+                    x1, x2 = (self.intx-0.3, self.intx+1.3)
+                    self.collection_box_price.set_segments([((x1, high), (x2, high), (x2, low), (x1, low), (x1, high))])
+                    self.collection_box_price.draw(renderer)
+            elif self.in_volume_chart and self.key_volume:
+                # 거래량 강조
+                high = self.df['max_box_volume'][self.intx]
+                low = 0
+                if high < self.min_height_box_volume: high = self.min_height_box_volume
+
+                if low <= y and y <= high:
+                    self.in_volumebar = True
+                    x1, x2 = (self.intx-0.3, self.intx+1.3)
+                    self.collection_box_volume.set_segments([((x1, high), (x2, high), (x2, low), (x1, low), (x1, high))])
+                    self.collection_box_volume.draw(renderer)
+        return
+
+
+class BaseMixin(BoxMixin):
+    pass
+