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

seolpyo_mplchart/_chart/slider/g_event.py

@@ -0,0 +1,353 @@
+from matplotlib.axes import Axes
+from matplotlib.backend_bases import MouseEvent, MouseButton, cursors
+from matplotlib.collections import LineCollection
+from matplotlib.text import Text
+import numpy as np
+
+from ..cursor.g_event import EventMixin as Base
+
+
+class BaseMixin(Base):
+    ax_slider: Axes
+
+    slider_xmin: int
+    slider_xmax: int
+    slider_ymin: float
+    slider_ymax: float
+
+    in_slider = False
+    is_click_slider = False
+    is_click_chart = False
+    is_move_chart = False
+
+    click_nav_left = False
+    click_nav_right = False
+
+    min_distance = 5
+
+    segment_nav: np.ndarray
+
+    _set_slider_vline: callable
+    _draw_slider_vline: callable
+    _set_slider_text: callable
+    _draw_slider_text: callable
+    draw_chart: callable
+    axis: callable
+    _set_cursor: callable
+    _move_chart: callable
+    _draw_nav: callable
+    _restore_region_background: callable
+
+    collection_slider_vline: LineCollection
+    artist_text_slider: Text
+    collection_nav: LineCollection
+
+    x_click: int
+    _nav_width: float
+    navcoordinate: tuple[int, int]
+    vxmin: int
+    vxmax: int
+
+    def get_nav_xlim(self):
+        seg = self.segment_nav
+        # print(f'{seg=}')
+        xmin = seg[-2][0][0]
+        xmax = seg[-1][0][0]
+        
+        return (int(xmin), int(xmax))
+
+
+class CursorMixin(BaseMixin):
+    def _set_cursor(self, e: MouseEvent):
+        # 마우스 커서 변경
+        if self.is_click_slider:
+            return
+        elif not self.in_slider:
+            self.figure.canvas.set_cursor(cursors.POINTER)
+            return
+
+        xmin, xmax = self.get_nav_xlim()
+        if xmin == xmax:
+            return
+
+        x = e.xdata
+
+        left0 = xmin - self._nav_width
+        left1 = xmin
+
+        if left0 <= x and x <= left1:
+            # 커서가 좌경계선 위에 위치
+            self.figure.canvas.set_cursor(cursors.RESIZE_HORIZONTAL)
+            return
+
+        right0 = xmax
+        right1 = xmax + self._nav_width
+        if right0 <= x and x <= right1:
+            # 커서가 우경계선 위에 위치
+            self.figure.canvas.set_cursor(cursors.RESIZE_HORIZONTAL)
+            return
+
+        if left1 < x and x < right0:
+            # 커서가 조회영역 위에 위치
+            self.figure.canvas.set_cursor(cursors.MOVE)
+            return
+
+        self.figure.canvas.set_cursor(cursors.POINTER)
+        return
+
+
+class AxMixin(BaseMixin):
+    def _check_ax(self, e: MouseEvent):
+        ax = e.inaxes
+        # print(f'{ax=}')
+        self.in_chart = False
+        self.in_slider, self.in_chart_price, self.in_chart_volume = (False, False, False)
+
+        if e.xdata is None or e.ydata is None:
+            return
+
+        if ax is self.ax_slider:
+            if (
+                (self.slider_xmin <= e.xdata and e.xdata <= self.slider_xmax)
+                and (self.slider_ymin <= e.ydata and e.ydata <= self.slider_ymax)
+            ):
+                self.in_slider = True
+        else:
+            super()._check_ax(e)
+        return
+
+
+class ClickMixin(BaseMixin):
+    is_click_slider = False
+    is_click_chart = False
+
+    click_nav_left = False
+    click_nav_right = False
+
+    def on_click(self, e: MouseEvent):
+        if e.xdata is not None and e.ydata is not None:
+            if self.in_chart and not self.is_click_chart:
+                if e.button == MouseButton.LEFT:
+                    self._on_click_chart(e)
+            elif self.in_slider and not self.is_click_slider:
+                if e.button == MouseButton.LEFT:
+                    self._on_click_slider(e)
+        return
+
+    def _on_click_chart(self, e: MouseEvent):
+        # 조회영역 이동 시작
+        self.is_click_chart = True
+        self.is_move_chart = True
+
+        x = int(e.xdata)
+        self.x_click = x
+
+        xmin, xmax = self.get_nav_xlim()
+        self.navcoordinate = (xmin, xmax)
+
+        self.figure.canvas.set_cursor(cursors.RESIZE_HORIZONTAL)
+        return
+
+    def _on_click_slider(self, e: MouseEvent):
+        self.is_click_slider = True
+        self.figure.canvas.set_cursor(cursors.RESIZE_HORIZONTAL)
+
+        xmin, xmax = self.get_nav_xlim()
+        x = round(e.xdata)
+
+        xmin0 = xmin - self._nav_width
+        xmin1 = xmin
+        if xmin0 <= x and x <= xmin1:
+            # 좌경계선 이동 시작
+            self.navcoordinate = (xmin, xmax)
+            self.click_nav_left = True
+            self.x_click = xmin
+            return
+
+        xmax0 = xmax
+        if xmin1 < x and x < xmax0:
+            # 조회영역 이동 시작
+            self.navcoordinate = (xmin, xmax)
+            self.is_move_chart = True
+            self.x_click = x
+            return
+
+        if xmax0 <= x and x <= (xmax + self._nav_width):
+            # 우경계선 이동 시작
+            self.navcoordinate = (xmin, xmax)
+            self.click_nav_right = True
+            self.x_click = xmax
+            return
+
+        self.navcoordinate = (xmin, xmax)
+        self.x_click = x
+        return
+
+
+class ReleaseMixin(BaseMixin):
+    def on_release(self, e: MouseEvent):
+        if e.button ==  MouseButton.LEFT:
+            if (
+                self.is_click_chart
+                and self.in_chart
+            ):
+                self._on_release_chart(e)
+            elif self.is_click_slider and self.in_slider:
+                self._on_release_slider(e)
+        return
+
+    def _on_release_chart(self, e):
+        self.x_click = None
+        self.is_click_chart = False
+        self.is_move_chart = False
+        self.figure.canvas.set_cursor(cursors.POINTER)
+
+        xmin, xmax = self.navcoordinate
+        self.axis(xmin, xmax=xmax)
+        self.figure.canvas.draw()
+        return
+
+    def _on_release_slider(self, e: MouseEvent):
+        if self.x_click:
+            xmin, xmax = self.get_nav_xlim()
+            xsub = xmax - xmin
+            min_distance = 5 if not self.min_distance or self.min_distance < 5 else self.min_distance
+            # print(f'{xsub=}')
+            # print(f'{min_distance=}')
+            if min_distance <= xsub:
+                self.navcoordinate = (xmin, xmax)
+            else:
+                xmin, xmax = self.navcoordinate
+
+            self.x_click = None
+            self.is_click_slider = False
+            self.is_move_chart = False
+            self.click_nav_left, self.click_nav_right = (False, False)
+            self.axis(xmin, xmax=xmax)
+
+            self.figure.canvas.draw()
+        return
+
+
+class ChartMixin(BaseMixin):
+    def _move_chart(self, e: MouseEvent):
+        if self.is_click_chart and self.in_chart:
+            xdata = int(e.xdata)
+            # print(f'{(self.x_click, xdata)=}')
+            xsub = self.x_click - xdata
+            if xsub:
+                pre_xmin, pre_xmax = self.navcoordinate
+                xmin, xmax = (pre_xmin+xsub, pre_xmax+xsub)
+                # print(f'{(xmin, xmax)=}')
+                if 0 <= xmax and xmin <= self.index_list[-1] and xmin != xmax:
+                    self.axis(xmin, xmax=xmax)
+                    self.navcoordinate = (xmin, xmax)
+        elif self.is_click_slider and self.in_slider:
+            xdata = round(e.xdata)
+            pre_xmin, pre_xmax = self.navcoordinate
+            if self.click_nav_left:
+                if xdata < pre_xmax:
+                    xmin, xmax = (xdata, pre_xmax)
+                else:
+                    xmin, xmax = (pre_xmax, xdata)
+            elif self.click_nav_right:
+                if xdata < pre_xmin:
+                    xmin, xmax = (xdata, pre_xmin)
+                else:
+                    xmin, xmax = (pre_xmin, xdata)
+            else:
+                if self.is_move_chart:
+                    xsub = self.x_click - xdata
+                    xmax = -1
+                    if xsub:
+                        pre_xmin, pre_xmax = self.navcoordinate
+                        xmin, xmax = (pre_xmin-xsub, pre_xmax-xsub)
+                else:
+                    if xdata == self.x_click:
+                        xmax = -1
+                    elif xdata < self.x_click:
+                        xmin, xmax = (xdata, self.x_click)
+                    else:
+                        xmin, xmax = (self.x_click, xdata)
+    
+            if 0 <= xmax and xmin <= self.index_list[-1] and xmin != xmax:
+                self.axis(xmin, xmax=xmax)
+        return
+
+
+class MoveMixin(BaseMixin):
+    def _set_and_draw_vline(self, e: MouseEvent):
+        self._set_slider_vline(e)
+        self._draw_slider_vline()
+        if self.in_slider and self._set_slider_text(e):
+            self._draw_slider_text()
+        return
+ 
+    def _set_and_draw_crossline(self, e: MouseEvent):
+        self._set_and_draw_vline(e)
+
+        super()._set_and_draw_crossline(e)
+        return
+ 
+    def _on_move_action(self, e: MouseEvent):
+        if e.xdata is not None:
+            if self.x_click is not None:
+                self._restore_region_background()
+
+                self._move_chart(e)
+                self.draw_chart()
+                self._draw_nav()
+                if self.in_slider:
+                    self._set_and_draw_vline(e)
+
+                self.figure.canvas.blit()
+                self.figure.canvas.flush_events()
+            else:
+                self._set_cursor(e)
+
+                if self.in_slider:
+                    self._restore_region()
+
+                    self._set_and_draw_vline(e)
+
+                    self.figure.canvas.blit()
+                    self.figure.canvas.flush_events()
+                else:
+                    super()._on_move_action(e)
+        else:
+            super()._on_move_action(e)
+        return
+
+    def need_restore(self):
+        if not super().need_restore():
+            if self.collection_slider_vline.get_segments():
+                self.collection_slider_vline.set_segments([])
+                return True
+        return
+
+
+class EventMixin(AxMixin, CursorMixin, ClickMixin, ReleaseMixin, ChartMixin, MoveMixin,):
+    x_click = None
+    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
+
+    min_distance = 5
+
+    navcoordinate: tuple[int, int]
+
+    def connect_events(self):
+        super().connect_events()
+
+        self.figure.canvas.mpl_connect('button_press_event', lambda x: self.on_click(x))
+        self.figure.canvas.mpl_connect('button_release_event', lambda x: self.on_release(x))
+        return

seolpyo_mplchart/_chart/slider/h_data.py

@@ -0,0 +1,102 @@
+from matplotlib.axes import Axes
+from matplotlib.text import Text
+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_slider: Axes
+
+    index_list: list[int] = []
+
+    artist_text_slider: Text
+
+    axis: callable
+    get_default_xlim: callable
+    set_variables: callable
+
+    _set_slider_collection: callable
+    vxmin: int
+    vxmax: int
+
+
+class SliderMixin(Base):
+    min_distance = 5
+
+    def get_default_xlim(self):
+        xmax = self.index_list[-1] + 1
+        xmin = xmax - 120
+        if xmin < 0:
+            xmin = 0
+        return (xmin, xmax)
+
+    def set_variables(self):
+        super().set_variables()
+
+        self._set_slider()
+        return
+
+    def _set_slider(self):
+        # print('_set_slider')
+        self._set_slider_xtick()
+
+        xmax = self.index_list[-1]
+        # 슬라이더 xlim
+        xdistance = round(xmax / 30)
+        self.slider_xmin, self.slider_xmax = (-xdistance, xmax+xdistance)
+        self.ax_slider.set_xlim(self.slider_xmin, self.slider_xmax)
+
+        # 네비게이터 경계선 두께
+        self._nav_width = round((self.slider_xmax - self.slider_xmin) / 250, 2)
+
+        # 슬라이더 ylim
+        ymin, ymax = (self.df['low'].min(), self.df['high'].max())
+        ysub = ymax - ymin
+        ydistance = round(ysub / 5, self.CONFIG.UNIT.digit+2)
+        self.slider_ymin, self.slider_ymax = (ymin-ydistance, ymax+ydistance)
+        self.ax_slider.set_ylim(self.slider_ymin, self.slider_ymax)
+
+        self._set_slider_collection()
+        self._set_slider_text_position()
+
+        return
+
+    def _set_slider_text_position(self):
+        # 슬라이더 텍스트 y
+        self.artist_text_slider.set_y(self.df['high'].max())
+        return
+
+    def _set_slider_xtick(self):
+        indices = [0, self.index_list[-1]]
+        # print(f'{indices=}')
+
+        date_list = [self.df.iloc[idx]['date'] for idx in indices]
+        # print(f'{date_list=}')
+        # xtick 설정, major tick과 겹쳐서 무시되는 것 방지
+        self.ax_slider.set_xticks([idx+0.01 for idx in indices], labels=date_list, minor=True)
+
+        labels = self.ax_slider.get_xticklabels(minor=True)
+        # print(f'{labels=}')
+        for label, align in zip(labels, ['center', 'center']):
+            # 라벨 텍스트 정렬
+            label.set_horizontalalignment(align)
+        return
+
+
+class DataMixin(SliderMixin):
+    min_distance = 5
+    _nav_width: float
+
+    slider_xmin: int
+    slider_xmax: int
+    slider_ymin: float
+    slider_ymax: float
+

seolpyo_mplchart/_chart/slider/test.py

@@ -0,0 +1,71 @@
+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._config import SLIDERCONFIG
+from seolpyo_mplchart._chart.slider 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[:800])
+
+
+class C(Chart):
+    limit_candle = 100
+    limit_wick = 300
+    limit_volume = 10
+    limit_ma = 200
+    t = 'light'
+    # watermark = ''
+    def __init__(self):
+        super().__init__()
+        # super().__init__(config=set_theme(SLIDERCONFIG, theme='dark'))
+        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.slider_top = True
+                self.t = 'dark'
+                # self.CONFIG.MA.linewidth = 1
+                self.get_candle_segment = lambda **x: Chart.get_candle_segment(self, **x)
+                self.CONFIG.CANDLE.linewidth = 0.8
+            else:
+                self.slider_top = False
+                self.t = 'light'
+                # self.CONFIG.MA.linewidth = 3
+                self.get_candle_segment = self.get_bar_segment
+                self.CONFIG.CANDLE.linewidth = 1.3
+            # 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()
+
+

seolpyo_mplchart/_config/candle.py

@@ -22,6 +22,7 @@ CANDLEEDGECOLOR = CandleEdgeColorData()
 class CandleData:
     def __init__(self):
         self.half_width = 0.24
+        self.linewidth = 0.8
         self.line_color: str|tuple[float, float, float, float] = 'k'
         self.FACECOLOR = CANDLEFACECOLOR
         self.EDGECOLOR = CANDLEEDGECOLOR

seolpyo_mplchart/_config/figure.py

@@ -2,8 +2,7 @@
 
 class RatioData:
     def __init__(self):
-        self.legend = 2
-        self.price = 18
+        self.price = 5
         self.volume = 5
 
 RATIO = RatioData()
@@ -19,7 +18,7 @@ WATERMARK = WatermarkData()
 class AdjustData:
     def __init__(self):
         # 여백
-        self.top = 0.95
+        self.top = 0.98
         self.bottom = 0.05
         self.left = 0.01
         self.right = 0.93
@@ -31,7 +30,7 @@ ADJUST = AdjustData()
 
 class FigureData:
     def __init__(self):
-        self.facecolor: str|tuple[float, float, float, float] = 'w'
+        self.facecolor: str|tuple[float, float, float, float] = '#fafafa'
         self.figsize = (14, 7)
         self.RATIO = RATIO
         self.ADJUST = ADJUST

seolpyo_mplchart/_config/ma.py

@@ -5,6 +5,8 @@ class MaData:
     def __init__(self):
         self.color_default: str|tuple[float, float, float, float] = 'k'
         self.format = '{}일선'
+        self.linewidth = 1
+        self.ncol = 10
         self.color_list: list[str|tuple[float, float, float, float]] = ['#8B00FF', '#008000', '#A0522D', '#008B8B', '#FF0080']
         self.ma_list = (5, 20, 60, 120, 240)
 

seolpyo_mplchart/_config/slider/config.py

@@ -1,11 +1,11 @@
 from .. import config
 from .figure import FIGURE, SliderFigureData
-from .nav import NAVIGATOR
+from .nav import NAV
 
 
 class SliderData:
     def __init__(self):
-        self.NAVIGATOR = NAVIGATOR
+        self.NAV = NAV
 
 SLIDER = SliderData()
 

seolpyo_mplchart/_config/slider/figure.py

@@ -3,11 +3,10 @@ from .. import figure
 
 class RatioData:
     def __init__(self):
-        self.legend = 2
-        self.price = 18
-        self.volume = 5
-        self.slider = 3
+        self.price = 9
+        self.volume = 3
         self.none = 2
+        self.slider = 1.5
 
 RATIO = RatioData()
 

seolpyo_mplchart/_config/slider/nav.py

@@ -1,9 +1,10 @@
 
 
-class NavigatorData:
+class Nav:
     def __init__(self):
         self.edgecolor = '#2962FF'
         self.facecolor = '#0000002E'
+        self.alpha = 0.18
 
-NAVIGATOR = NavigatorData()
+NAV = Nav()
 

seolpyo_mplchart/_config/volume.py

@@ -19,6 +19,7 @@ VOLUMEEDGECOLOR = VolumeEdgeColorData()
 class VolumeData:
     def __init__(self):
         self.half_width = 0.36
+        self.linewidth = 0.7
         self.FACECOLOR = VOLUMEFACECOLOR
         self.EDGECOLOR = VOLUMEEDGECOLOR
 

seolpyo_mplchart/_utils/__init__.py

@@ -0,0 +1,10 @@
+from .theme import set_theme
+from .nums import (
+    convert_num,
+    float_to_str,
+    convert_unit, convert_unit_en,
+    data_unit_ko, data_unit_en
+)
+from .xl import xl_to_dataList
+from .utils import switch_backend, show, close, list_to_DataFrame
+

seolpyo_mplchart/_utils/nums.py

@@ -0,0 +1,67 @@
+
+
+def convert_num(num):
+    if isinstance(num, float) and num % 1:
+        return num
+    return int(num)
+
+
+def float_to_str(num: float, *, digit=0, plus=False):
+    if 0 < digit:
+        num.__round__(digit)
+        text = f'{num:+,.{digit}f}' if plus else f'{num:,.{digit}f}'
+    else:
+        num = round(num, digit).__int__()
+        text = f'{num:+,}' if plus else f'{num:,}'
+    return text
+
+
+data_unit_ko = {
+    '경': 10_000_000_000_000_000,
+    '조':      1_000_000_000_000,
+    '억':            100_000_000,
+    '만':                 10_000,
+}
+def convert_unit(value, *, digit=0, word='원', unit_data: dict[str, int]=None):
+    if not unit_data:
+        unit_data = data_unit_ko
+    # print('ko')
+    # print(f'{value=:,}')
+    v = abs(value)
+    for unit, n in unit_data.items():
+        if n <= v:
+            # print(f'{n=:,}')
+            # print(f'{unit=}')
+            num = value / n
+            if word.startswith(' '):
+                return f'{float_to_str(num, digit=digit)}{unit}{word}'
+            return f'{float_to_str(num, digit=digit)}{unit} {word}'
+
+    if not value % 1:
+        value = int(value)
+    text = f'{float_to_str(value, digit=digit)}{word}'
+    # print(f'{text=}')
+    return text
+
+data_unit_en = {
+    'Qd': 1_000_000_000_000_000,
+    'T':      1_000_000_000_000,
+    'B':          1_000_000_000,
+    'M':              1_000_000,
+    'K':                  1_000,
+}
+def convert_unit_en(value, *, digit=0, word='$', unit_data: dict[str, int]=None):
+    if not unit_data:
+        unit_data = data_unit_en
+    # print('en')
+    # print(f'{value=:,}')
+    return convert_unit(value, digit=digit, word=word, unit_data=unit_data)
+
+
+if __name__ == '__main__':
+    a = 456.123
+    print(float_to_str(a))
+    print(float_to_str(a, 2))
+    print(float_to_str(a, 6))
+
+