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

seolpyo_mplchart/_chart/_slider/_mouse.py

@@ -0,0 +1,176 @@
+from matplotlib.backend_bases import MouseEvent, MouseButton, cursors
+
+from ._data import BaseMixin as Base
+
+
+class MouseMoveMixin(Base):
+    in_slider = False
+    is_click_slider = False
+
+    def _erase_crossline(self):
+        boolen = super()._erase_crossline()
+        if boolen:
+            return boolen
+
+        seg = self.collection_slider_vline.get_segments()
+        if seg:
+            self.collection_slider_vline.set_segments([])
+            return True
+        return False
+
+    def _on_move_action(self, e):
+        super()._on_move_action(e)
+
+        if self.in_slider:
+            self._restore_region(self.is_click_slider)
+            self._on_move_slider(e)
+            self.figure.canvas.blit()
+        elif 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 _on_move_action(self, e: MouseEvent):
+        self._check_ax(e)
+
+        self.intx = None
+        if self.in_slider or self.in_price_chart or self.in_volume_chart:
+            self._get_x(e)
+
+        self._set_cursor(e)
+        return
+
+    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
+
+        navleft, navright = self.navcoordinate
+        if navleft == navright:
+            return
+
+        x = e.xdata.__round__()
+
+        leftmin = navleft - self._navLineWidth
+        leftmax = navleft + self._navLineWidth_half
+        rightmin = navright - self._navLineWidth_half
+        rightmax = navright + self._navLineWidth
+        if x < leftmin:
+            self.figure.canvas.set_cursor(cursors.POINTER)
+        elif x <= leftmax:
+            self.figure.canvas.set_cursor(cursors.RESIZE_HORIZONTAL)
+        elif x < rightmin:
+            self.figure.canvas.set_cursor(cursors.MOVE)
+        elif x <= rightmax:
+            self.figure.canvas.set_cursor(cursors.RESIZE_HORIZONTAL)
+        else:
+            self.figure.canvas.set_cursor(cursors.POINTER)
+        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_slider, self.in_price_chart, self.in_volume_chart = (False, False, False)
+        else:
+            if ax is self.ax_slider:
+                self.in_slider = True
+                self.in_price_chart = False
+                self.in_volume_chart = False
+            elif ax is self.ax_price:
+                self.in_slider = False
+                self.in_price_chart = True
+                self.in_volume_chart = False
+            elif ax is self.ax_volume:
+                self.in_slider = False
+                self.in_price_chart = False
+                self.in_volume_chart = True
+            else:
+                self.in_slider = False
+                self.in_price_chart = False
+                self.in_volume_chart = False
+        return
+
+    def _on_move_slider(self, e: MouseEvent):
+        x = e.xdata
+        if self.intx is not None:
+            renderer = self.figure.canvas.renderer
+            seg = [((x, self.slider_ymin), (x, self.slider_ymax))]
+            self.collection_slider_vline.set_segments(seg)
+            self.collection_slider_vline.draw(renderer)
+
+            if self.in_slider:
+                self.artist_text_slider.set_text(f'{self.df["date"][self.intx]}')
+                self.artist_text_slider.set_x(x)
+                self.artist_text_slider.draw(renderer)
+        return
+
+    def _draw_crossline(self, e: MouseEvent):
+        x = e.xdata
+        self.collection_slider_vline.set_segments([((x-0.5, self.slider_ymin), (x-0.5, self.slider_ymax))])
+        self.collection_slider_vline.draw(self.figure.canvas.renderer)
+        return super()._draw_crossline(e)
+
+
+class ClickMixin(MouseMoveMixin):
+    x_click = None
+    is_move = False
+    click_navleft, click_navright = (False, False)
+
+    def _connect_events(self):
+        super()._connect_events()
+
+        self.figure.canvas.mpl_connect('button_press_event', lambda x: self.on_click(x))
+        return
+
+    def on_click(self, e: MouseEvent):
+        self._on_click(e)
+        return
+
+    def _on_click(self, e: MouseEvent):
+        if self.in_slider and not self.is_click_slider:
+            if e.button == MouseButton.LEFT:
+                self._on_click_slider(e)
+        return
+
+    def _on_click_slider(self, e: MouseEvent):
+        self.background_with_nav_pre = self.background_with_nav
+
+        self.is_click_slider = True
+        self.figure.canvas.set_cursor(cursors.RESIZE_HORIZONTAL)
+
+        navleft, navright = self.navcoordinate
+        x = e.xdata.__round__()
+
+        leftmax = navleft + self._navLineWidth_half
+        rightmin = navright - self._navLineWidth_half
+
+        grater_than_left = leftmax < x
+        less_then_right = x < rightmin
+        if grater_than_left and less_then_right:
+            self.is_move = True
+            self.x_click = x
+        else:
+            leftmin = navleft - self._navLineWidth
+            rightmax = navright + self._navLineWidth
+            if not grater_than_left and leftmin <= x:
+                self.click_navleft = True
+                self.x_click = navright
+            elif not less_then_right and x <= rightmax:
+                self.click_navright = True
+                self.x_click = navleft
+            else:
+                self.x_click = x
+        return
+
+
+class BaseMixin(ClickMixin):
+    pass
+

seolpyo_mplchart/_chart/_slider/_nav.py

@@ -0,0 +1,204 @@
+from matplotlib.backend_bases import MouseEvent, MouseButton, cursors
+
+from ._mouse import BaseMixin as Base
+
+
+class SliderSelectMixin(Base):
+    limit_ma = 8_000
+
+    def _on_move_slider(self, e):
+        if self.is_click_slider:
+            self._set_navcoordinate(e)
+        return super()._on_move_slider(e)
+
+    def _set_navcoordinate(self, e: MouseEvent):
+        navmin, navmax = self.navcoordinate
+
+        x = e.xdata.__int__()
+        if self.is_move:
+            xsub = self.x_click - x
+            navmin, navmax = (navmin-xsub, navmax-xsub)
+
+            # 값 보정
+            if navmax < 0:
+                navmin, navmax = (navmin-navmax, 0)
+            if self.index_list[-1] < navmin:
+                navmin, navmax = (self.index_list[-1], self.index_list[-1] + (navmax-navmin))
+
+            self.navcoordinate = (navmin, navmax)
+            self.x_click = x
+
+            self.axis(navmin, xmax=navmax+1, simpler=True, draw_ma=(navmax-navmin < self.limit_ma))
+
+            self._axis_navigator(navmin, navmax)
+            self.collection_navigator.draw(self.figure.canvas.renderer)
+
+            self.draw_artists()
+            self.background_with_nav = self.figure.canvas.renderer.copy_from_bbox(self.figure.bbox)
+            self._restore_region()
+        else:
+            navmin, navmax = (x, self.x_click) if x < self.x_click else (self.x_click, x)
+
+            # 슬라이더가 차트를 벗어나지 않도록 선택 영역 제한
+            if navmax < 0 or self.index_list[-1] < navmin:
+                seg = self.collection_navigator.get_segments()
+                navmin, navmax = (int(seg[1][0][0]), int(seg[3][0][0]))
+
+            nsub = navmax - navmin
+            min_distance = 5 if not self.min_distance or self.min_distance < 5 else self.min_distance
+            if nsub < min_distance:
+                self._restore_region(False, False)
+                self._axis_navigator(navmin, navmax)
+                self.collection_navigator.draw(self.figure.canvas.renderer)
+            else:
+                self.axis(navmin, xmax=navmax+1, simpler=True, draw_ma=(nsub < self.limit_ma))
+                self._axis_navigator(navmin, navmax)
+
+                self.collection_navigator.draw(self.figure.canvas.renderer)
+
+                self.draw_artists()
+                self.background_with_nav = self.figure.canvas.renderer.copy_from_bbox(self.figure.bbox)
+                self._restore_region(False, True)
+        return
+
+
+class ReleaseMixin(SliderSelectMixin):
+    def _connect_events(self):
+        super()._connect_events()
+
+        self.figure.canvas.mpl_connect('button_release_event', lambda x: self.on_release(x))
+        return
+
+    def on_release(self, e: MouseEvent):
+        self._on_release(e)
+        return
+
+    def _on_release(self, e: MouseEvent):
+        if self.in_slider and self.is_click_slider:
+            if e.button == MouseButton.LEFT:
+                self._on_release_slider(e)
+                self.axis(self.vxmin, xmax=self.vxmax, simpler=False, draw_ma=True)
+                self.figure.canvas.draw()
+        return
+
+    def _on_release_slider(self, e: MouseEvent):
+        if not self.is_move:
+            seg = self.collection_navigator.get_segments()
+            navmin, navmax = (int(seg[1][0][0]), int(seg[3][0][0]))
+            nsub = navmax - navmin
+            min_distance = 5 if not self.min_distance or self.min_distance < 5 else self.min_distance
+            if min_distance <= nsub:
+                self.navcoordinate = (navmin, navmax)
+            else:
+                self.background_with_nav = self.background_with_nav_pre
+                navmin, navmax = self.navcoordinate
+                self.axis(navmin, xmax=navmax+1, simpler=False, draw_ma=True)
+                self._restore_region(False, True)
+                self.figure.canvas.blit()
+            self._axis_navigator(*self.navcoordinate)
+
+        self.is_click_slider = False
+        self.is_move = False
+        self.click_navleft, self.click_navright = (False, False)
+
+        # self.figure.canvas.draw()
+        return
+
+
+class ChartClickMixin(ReleaseMixin):
+    is_click_chart = False
+
+    def _on_click(self, e: MouseEvent):
+        if e.button == MouseButton.LEFT:
+            if (
+                not self.is_click_chart
+                and (self.in_price_chart or self.in_volume_chart)
+            ):
+                self._on_click_chart(e)
+            elif not self.is_click_slider and self.in_slider:
+                self._on_click_slider(e)
+        return
+
+    def _on_click_chart(self, e: MouseEvent):
+        self.is_click_chart = True
+        x = e.xdata.__int__()
+        self.x_click = x - self.navcoordinate[0]
+        self.figure.canvas.set_cursor(cursors.RESIZE_HORIZONTAL)
+        return
+
+    def _on_release(self, e):
+        if e.button ==  MouseButton.LEFT:
+            if (
+                self.is_click_chart
+                and (self.in_price_chart or self.in_volume_chart)
+            ):
+                self._on_release_chart(e)
+                self.axis(self.vxmin, xmax=self.vxmax, simpler=False, draw_ma=True)
+                self.figure.canvas.draw()
+            elif self.is_click_slider and self.in_slider:
+                self._on_release_slider(e)
+                self.axis(self.vxmin, xmax=self.vxmax, simpler=False, draw_ma=True)
+                self.figure.canvas.draw()
+        return
+
+    def _on_release_chart(self, e):
+        self.is_click_chart = False
+        self.figure.canvas.set_cursor(cursors.POINTER)
+        return
+
+    def _set_cursor(self, e):
+        if self.is_click_chart:
+            return
+        return super()._set_cursor(e)
+
+    def _on_move_action(self, e):
+        super()._on_move_action(e)
+
+        if self.in_slider:
+            self._restore_region(self.is_click_slider)
+            self._on_move_slider(e)
+            self.figure.canvas.blit()
+        elif self.in_price_chart or self.in_volume_chart:
+            self._restore_region(self.is_click_chart)
+            if not self.is_click_chart:
+                self._draw_crossline(e)
+            else:
+                self._move_chart(e)
+            self.figure.canvas.blit()
+        else:
+            if self._erase_crossline():
+                self._restore_region()
+                self.figure.canvas.blit()
+        return
+
+    def _move_chart(self, e: MouseEvent):
+        left, right = self.navcoordinate
+        x = e.xdata.__int__() - left
+        xsub = x - self.x_click
+        if not xsub:
+            self.collection_navigator.draw(self.figure.canvas.renderer)
+            self.draw_artists()
+        else:
+            left, right = (left-xsub, right-xsub)
+            if right < 0 or self.df.index[-1] < left:
+                self._restore_region()
+            else:
+                self.x_click = x
+                self.navcoordinate = (left, right)
+                self.axis(left, xmax=right+1, simpler=True, draw_ma=(right-left < self.limit_ma))
+                self._axis_navigator(left, right)
+                self.collection_navigator.draw(self.figure.canvas.renderer)
+
+                self.draw_artists()
+                self.background_with_nav = self.figure.canvas.renderer.copy_from_bbox(self.figure.bbox)
+                self._restore_region()
+        return
+
+
+class BaseMixin(ChartClickMixin):
+    pass
+
+
+class Chart(BaseMixin):
+    pass
+

seolpyo_mplchart/_chart/test.py

@@ -0,0 +1,121 @@
+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
+
+
+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[:100])
+
+def test_base():
+    from seolpyo_mplchart._chart._base import Base
+    Base()
+    plt.show()
+    return
+
+def test_draw():
+    from seolpyo_mplchart._chart._draw import Chart
+    c = Chart()
+    # c.CONFIG.CANDLE.FACECOLOR.bull_fall = 'y'
+    # c.CONFIG.CANDLE.EDGECOLOR.bull_fall = 'k'
+    # c.CONFIG.CANDLE.FACECOLOR.bear_rise = 'k'
+    # c.CONFIG.CANDLE.EDGECOLOR.bear_rise = 'pink'
+    # c.CONFIG.VOLUME.EDGECOLOR.rise = 'k'
+    # c.CONFIG.AX.facecolor = 'k'
+    # c.CONFIG.AX.TICK.edgecolor = 'yellow'
+    # c.CONFIG.AX.TICK.fontcolor = 'pink'
+    # c.set_color()
+    # c.volume = None
+    c.set_data(df)
+    plt.show()
+    return
+
+
+def test_cursor():
+    from seolpyo_mplchart._chart._cursor._info import Chart
+    from seolpyo_mplchart._config import DEFAULTCONFIG_EN
+    c = Chart()
+    # c.CONFIG = DEFAULTCONFIG_EN
+    c.refresh()
+    c.fraction = True
+    c.set_data(df)
+    plt.show()
+    return
+
+def test_slider():
+    from seolpyo_mplchart._chart._slider import Chart
+    c = Chart()
+    c.set_data(df)
+    plt.show()
+    return
+
+
+if __name__ == '__main__':
+    # test_base()
+    # test_draw()
+    # test_cursor()
+    test_slider()
+
+
+import seolpyo_mplchart as mc
+
+
+# class Chart(mc.SliderChart):
+#     format_candleinfo = mc.format_candleinfo_ko + '\nCustom info: {ci}'
+#     format_volumeinfo = mc.format_volumeinfo_ko
+#     min_distance = 2
+
+#     def __init__(self, *args, **kwargs):
+#         super().__init__(*args, **kwargs)
+#         self.collection_candle.set_linewidth(1.5)
+#         return
+
+#     def get_info_kwargs(self, is_price, **kwargs):
+#         if is_price:
+#             kwargs['ci'] = 'You can add Custom text Info or Change text info.'
+#             kwargs['close'] = 'You can Change close price info.'
+#         return kwargs
+
+#     def get_candle_segment(self, *, x, left, right, top, bottom, is_up, high, low):
+#         if is_up:
+#             return (
+#                 (x, top), (right, top), (x, top),
+#                 (x, high),
+#                 (x, low),
+#                 (x, bottom), (left, bottom), (x, bottom),
+#             )
+#         else:
+#             return (
+#                 (x, bottom), (right, bottom), (x, bottom),
+#                 (x, high),
+#                 (x, low),
+#                 (x, top), (left, top), (x, top),
+#             )
+
+
+
+# C = Chart()
+# path_file = Path(__file__).parent / 'sample/samsung.txt'
+# # C.format_candleinfo = mc.format_candleinfo_ko
+# # C.format_volumeinfo = mc.format_volumeinfo_ko
+# # C.volume = None
+
+
+# with open(path_file, 'r', encoding='utf-8') as txt:
+#     data = json.load(txt)
+# df = pd.DataFrame(data[:100])
+
+# C.set_data(df)
+
+# mc.show()
+# mc.close()

seolpyo_mplchart/_config/__init__.py

@@ -0,0 +1,3 @@
+from .config import DEFAULTCONFIG, DEFAULTCONFIG_EN, ConfigData
+from .slider import SLIDERCONFIG, SLIDERCONFIG_EN, SliderConfigData
+

seolpyo_mplchart/_config/ax.py

@@ -0,0 +1,28 @@
+
+
+class Grid:
+    def __init__(self):
+        self.visible = True
+        self.linewidth = 0.7
+        self.color: str|tuple[float, float, float, float] = '#d0d0d0'
+        self.linestyle = '-'
+        self.dashes = (1, 0)
+        self.axis = 'both'
+
+GRID = Grid()
+
+class TickData:
+    def __init__(self):
+        self.edgecolor: str|tuple[float, float, float, float] = 'k'
+        self.fontcolor: str|tuple[float, float, float, float] = 'k'
+
+TICK = TickData()
+
+class AxData:
+    def __init__(self):
+        self.facecolor: str|tuple[float, float, float, float] = '#fafafa'
+        self.GRID = GRID
+        self.TICK = TICK
+
+AX = AxData()
+

seolpyo_mplchart/_config/candle.py

@@ -0,0 +1,30 @@
+
+
+class CandleFaceColorData:
+    def __init__(self):
+        self.bull_rise: str|tuple[float, float, float, float] = '#FF2400'
+        self.bull_fall: str|tuple[float, float, float, float] = 'w'
+        self.bear_fall: str|tuple[float, float, float, float] = '#1E90FF'
+        self.bear_rise: str|tuple[float, float, float, float] = 'w'
+
+CANDLEFACECOLOR = CandleFaceColorData()
+
+class CandleEdgeColorData:
+    def __init__(self):
+        self.bull_rise: str|tuple[float, float, float, float] = '#FF2400'
+        self.bull_fall: str|tuple[float, float, float, float] = '#FF2400'
+        self.bear_fall: str|tuple[float, float, float, float] = '#1E90FF'
+        self.bear_rise: str|tuple[float, float, float, float] = '#1E90FF'
+        self.doji: str|tuple[float, float, float, float] = 'k'
+
+CANDLEEDGECOLOR = CandleEdgeColorData()
+
+class CandleData:
+    def __init__(self):
+        self.half_width = 0.24
+        self.line_color: str|tuple[float, float, float, float] = 'k'
+        self.FACECOLOR = CANDLEFACECOLOR
+        self.EDGECOLOR = CANDLEEDGECOLOR
+
+CANDLE = CandleData()
+

seolpyo_mplchart/_config/config.py

@@ -0,0 +1,21 @@
+from . import figure, ax, candle, volume, ma, unit, cursor, format
+
+
+class ConfigData:
+    def __init__(self):
+        self.FIGURE = figure.FIGURE
+        self.UNIT = unit.UNIT
+        self.AX = ax.AX
+        self.CANDLE = candle.CANDLE
+        self.VOLUME = volume.VOLUME
+        self.MA = ma.MA
+        self.CURSOR = cursor.CURSOR
+        self.FORMAT = format.FORMAT
+
+DEFAULTCONFIG = ConfigData()
+
+DEFAULTCONFIG_EN = ConfigData()
+DEFAULTCONFIG_EN.UNIT = unit.UNIT_EN
+DEFAULTCONFIG_EN.MA = ma.MA_EN
+DEFAULTCONFIG_EN.FORMAT = format.FORMAT_EN
+

seolpyo_mplchart/_config/cursor.py

@@ -0,0 +1,49 @@
+
+
+class CrossLineData:
+    def __init__(self):
+        self.edgecolor = 'k'
+        self.linewidth = 1
+        self.linestyle = '-'
+
+CROSSLINE = CrossLineData()
+
+class BBoxData:
+    def __init__(self):
+        self.boxstyle = 'round'
+        self.facecolor = 'w'
+        self.edgecolor = 'k'
+
+BBOX = BBoxData()
+
+class Text:
+    def __init__(self):
+        self.color = 'k'
+        self.BBOX = BBOX
+
+    def to_dict(self):
+        data = {}
+        for k, v in self.__dict__.items():
+            if k == 'BBOX':
+                k = k.lower()
+                v = self.BBOX.__dict__
+            data[k] = v
+        return data
+
+TEXT = Text()
+
+class Box:
+    def __init__(self):
+        self.edgecolor = 'k'
+        self.linewidth = 1.2
+
+BOX = Box()
+
+class Cursor:
+    def __init__(self):
+        self.CROSSLINE = CROSSLINE
+        self.TEXT = TEXT
+        self.BOX = BOX
+
+CURSOR = Cursor()
+

seolpyo_mplchart/_config/figure.py

@@ -0,0 +1,41 @@
+
+
+class RatioData:
+    def __init__(self):
+        self.legend = 2
+        self.price = 18
+        self.volume = 5
+
+RATIO = RatioData()
+
+class WatermarkData:
+    def __init__(self):
+        self.alpha = 0.2
+        self.color = 'k'
+        self.fontsize = 20
+
+WATERMARK = WatermarkData()
+
+class AdjustData:
+    def __init__(self):
+        # 여백
+        self.top = 0.95
+        self.bottom = 0.05
+        self.left = 0.01
+        self.right = 0.93
+        # 플롯간 간격
+        self.wspace = 0
+        self.hspace = 0
+
+ADJUST = AdjustData()
+
+class FigureData:
+    def __init__(self):
+        self.facecolor: str|tuple[float, float, float, float] = 'w'
+        self.figsize = (14, 7)
+        self.RATIO = RATIO
+        self.ADJUST = ADJUST
+        self.WATERMARK = WATERMARK
+
+FIGURE = FigureData()
+