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

seolpyo_mplchart/_chart/cursor/e_axis.py

@@ -0,0 +1,64 @@
+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
+

seolpyo_mplchart/_chart/cursor/h_data.py

@@ -0,0 +1,62 @@
+import pandas as pd
+
+from ..._config import ConfigData
+
+
+class Base:
+    CONFIG: ConfigData
+
+    key_volume: str
+    df: pd.DataFrame
+
+    _add_columns: callable
+    set_variables: callable
+
+
+class Mixin(Base):
+    def _add_columns(self):
+        super()._add_columns()
+
+        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['box_candle_top'] = self.df['high'] + self.df['space_box_candle']
+        self.df['box_candle_bottom'] = self.df['low'] - self.df['space_box_candle']
+        self.df['box_candle_height'] = self.df['box_candle_top'] - self.df['box_candle_bottom']
+
+        if self.key_volume:
+            self.df['box_volume_top'] = self.df['volume'] * 1.15
+
+        return
+
+    def set_variables(self):
+        super().set_variables()
+
+        self._set_length_text()
+        return
+
+    def _set_length_text(self):
+        func = lambda x: len(self.CONFIG.UNIT.func(x, digit=self.CONFIG.UNIT.digit, word=self.CONFIG.UNIT.price))
+        self._length_text = self.df['high'].apply(func).max()
+
+        if self.key_volume:
+            func = lambda x: len(self.CONFIG.UNIT.func(x, digit=self.CONFIG.UNIT.digit_volume, word=self.CONFIG.UNIT.volume))
+            lenth_volume = self.df['volume'].apply(func).max()
+            # print(f'{self._length_text=}')
+            # print(f'{lenth_volume=}')
+            if self._length_text < lenth_volume:
+                self._length_text = lenth_volume
+        return
+
+
+class DataMixin(Mixin):
+    _length_text: int
+

seolpyo_mplchart/_chart/cursor/test.py

@@ -0,0 +1,69 @@
+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.cursor import Chart
+from seolpyo_mplchart._config import DEFAULTCONFIG, DEFAULTCONFIG_EN
+
+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[:300])
+
+
+class C(Chart):
+    # limit_candle = 200
+    # limit_wick = 200
+    t = 'light'
+    # watermark = ''
+    def __init__(self):
+        super().__init__()
+        self.figure.canvas.mpl_connect('button_press_event', lambda x: self.theme(x))
+        self.CONFIG.FORMAT.candle += '\nCustom: {custom}'
+
+    def get_info_kwargs(self, is_price, **kwargs):
+        kwargs = super().get_info_kwargs(is_price, **kwargs)
+        kwargs['close'] = 'Cusotom close value'
+        kwargs['custom'] = 'this is custom add info kwargs'
+        return kwargs
+
+    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'
+                self.CONFIG = set_theme(DEFAULTCONFIG_EN, theme=self.t)
+            else:
+                self.t = 'light'
+                self.CONFIG = set_theme(DEFAULTCONFIG, theme=self.t)
+            # print(f'{self.t=}')
+            # self.CONFIG.MA.ma_list = []
+            self.refresh()
+        return
+
+
+def run():
+    chart = C()
+    chart.set_data(df)
+    plt.show()
+    plt.close()
+    return
+
+
+if __name__ == '__main__':
+    run()
+
+

seolpyo_mplchart/_chart/slider/__init__.py

@@ -0,0 +1,169 @@
+from matplotlib.axes import Axes
+from matplotlib.collections import LineCollection
+from matplotlib.text import Text
+from matplotlib.axes import Axes
+import numpy as np
+import pandas as pd
+
+from ..._config import SLIDERCONFIG, SliderConfigData
+from ..base import Chart as BaseChart
+from ..cursor import CursorMixin
+
+from .a_canvas import CanvasMixin, Figure
+from .b_artist import ArtistMixin
+from .c_draw import DrawMixin
+from .d_segment import SegmentMixin
+from .e_axis import AxisMixin
+from .f_background import BackgroundMixin
+from .g_event import EventMixin
+from .h_data import DataMixin
+
+
+class SliderMixin(
+    CanvasMixin,
+    ArtistMixin,
+    DrawMixin,
+    SegmentMixin,
+    AxisMixin,
+    BackgroundMixin,
+    EventMixin,
+    DataMixin,
+):
+    pass
+
+
+class Chart(SliderMixin, CursorMixin, BaseChart):
+    candle_on_ma = True
+    slider_top = True
+    fraction = False
+
+    limit_candle = 400
+    limit_wick = 2_000
+    limit_volume = 200
+    limit_ma = 8_000
+
+    min_distance = 5
+
+    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
+
+    CONFIG: SliderConfigData
+
+    figure: Figure
+    ax_legend: Axes
+    ax_price: Axes
+    ax_volume: Axes
+
+    ax_slider: Axes
+    ax_none: Axes
+    _ax_slider_top: Axes
+    _ax_slider_bottom: Axes
+
+    artist_watermark: Text
+    collection_candle: LineCollection
+    collection_volume: LineCollection
+    collection_ma: LineCollection
+
+    collection_slider: LineCollection
+    collection_nav: LineCollection
+    collection_slider_vline: LineCollection
+    artist_text_slider: Text
+
+    in_candle = False
+    in_volume = False
+
+    collection_price_crossline: LineCollection
+    collection_volume_crossline: LineCollection
+
+    artist_label_x: Text = None
+    artist_label_y: Text = None
+
+    collection_box_price: LineCollection
+    collection_box_volume: LineCollection
+
+    artist_info_candle: Text
+    artist_info_volume: Text
+
+    v0: int
+    v1: int
+    vmiddle: int
+
+    min_height_box_candle: float
+    min_height_box_volume: float
+
+    _length_text: int
+
+    _in_mouse_move = False
+
+    ###
+
+    segment_nav: np.ndarray
+    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
+
+    price_ymin: int
+    price_ymax: int
+    volume_ymax: int
+
+    chart_price_ymax: float
+    chart_volume_ymax: float
+
+    vxmin: int
+    vxmax: int
+
+    _nav_width: float
+
+    slider_xmin: int
+    slider_xmax: int
+    slider_ymin: float
+    slider_ymax: float
+
+    in_chart = False
+    in_slider = False
+    in_chart_price = False
+    in_chart_volume = False
+
+    is_move_chart = False
+    is_click_slider = False
+    is_click_chart = False
+    x_click: float
+
+    click_nav_left = False
+    click_nav_right = False
+
+    navcoordinate: tuple[int, int]
+
+    ###
+
+    _visible_ma: set[int] = set()
+    _edgecolor_ma = []
+
+    _background = None
+    _creating_background = False
+
+    def __init__(self, config=SLIDERCONFIG):
+        self.CONFIG = config
+        super().__init__()
+        return
+
+    def refresh(self):
+        self._set_slider_artists()
+        super().refresh()
+        return
+