seolpyo-mplchart 1.4.1__py3-none-any.whl → 2.1.0__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/base/__init__.py

@@ -0,0 +1,111 @@
+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 DEFAULTCONFIG, ConfigData
+
+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 Chart(
+    CanvasMixin,
+    ArtistMixin,
+    DrawMixin,
+    SegmentMixin,
+    AxisMixin,
+    BackgroundMixin,
+    EventMixin,
+    DataMixin,
+):
+    limit_candle = 400
+    limit_wick = 2_000
+    candle_on_ma = True
+
+    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: ConfigData
+
+    figure: Figure
+    ax_legend: Axes
+    ax_price: Axes
+    ax_volume: Axes
+
+    artist_watermark: Text
+    collection_candle: LineCollection
+    collection_volume: LineCollection
+    collection_ma: LineCollection
+
+    ###
+
+    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
+
+    ###
+
+    _visible_ma: set[int] = set()
+
+    _background = None
+    _background_background = None
+    _creating_background = False
+
+    def __init__(self, config=DEFAULTCONFIG):
+        self.CONFIG = config
+        super().__init__()
+
+        self.add_artists()
+        self.connect_events()
+        return
+
+    def refresh(self):
+        self.set_artists()
+
+        self.set_candle_segments()
+        self.set_color_segments()
+        ma_alpha = self.collection_ma.get_alpha()
+        # print(f'{ma_alpha=}')
+        if ma_alpha is not None:
+            self.collection_ma.set_alpha([1 for _ in ma_alpha])
+
+        self.axis(self.vxmin, xmax=self.vxmax-1)
+
+        self.set_canvas()
+        self.figure.canvas.draw()
+        return
+