seolpyo-mplchart 0.0.41__tar.gz → 0.1.1__tar.gz

{seolpyo_mplchart-0.0.41/seolpyo_mplchart.egg-info → seolpyo_mplchart-0.1.1}/PKG-INFO

@@ -1,7 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: seolpyo-mplchart
-Version: 0.0.41
-Summary: Fast candlestick chart using Python.
+Version: 0.1.1
+Summary: Fast candlestick chart using Python. Includes navigator, slider, navigation, and text information display functions
 Author-email: white-seolpyo <white-seolpyo@naver.com>
 License: MIT License
 Project-URL: Homepage, https://white.seolpyo.com/

{seolpyo_mplchart-0.0.41 → seolpyo_mplchart-0.1.1}/pyproject.toml

@@ -8,13 +8,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "seolpyo-mplchart"
-version = "0.0.41"
+version = "0.1.1"
 dependencies  = [
   "matplotlib >= 3.7.0",
   "pandas >= 2.0.0",
 ]
 license = {text = "MIT License"}
-description = "Fast candlestick chart using Python.\nIncludes navigator, slider, navigation, and text information display functions"
+description = "Fast candlestick chart using Python. Includes navigator, slider, navigation, and text information display functions"
 readme = "README.md"
 requires-python = ">= 3.11"
 authors = [

seolpyo_mplchart-0.1.1/seolpyo_mplchart/__init__.py

@@ -0,0 +1,120 @@
+"""
+This software includes Matplotlib, which is licensed under the BSD License.
+Matplotlib Copyright (c) 2012- Matplotlib Development Team.
+Full license can be found in the LICENSE file or at https://matplotlib.org/stable/users/license.html
+"""
+
+
+import json
+from pathlib import Path
+from typing import Literal
+
+import matplotlib.pyplot as plt
+from matplotlib.figure import Figure
+import pandas as pd
+
+
+from .slider import Chart as CM
+
+
+__all__ = [
+    'pd',
+    'plt',
+
+    'Chart',
+
+    'sample',
+    'show',
+    'close',
+]
+
+
+class Chart(CM):
+    r"""
+    You can see the guidance document:
+        Korean: https://white.seolpyo.com/entry/147/
+        English: https://white.seolpyo.com/entry/148/
+
+    Variables:
+        unit_price, unit_volume: unit for price and volume. default ('원', '주').
+
+        figsize: figure size if you use plt.show(). default (12, 6).
+        ratio_ax_slider, ratio_ax_legend, ratio_ax_price, ratio_ax_volume: Axes ratio. default (3, 2, 18, 5).
+        adjust: figure adjust. default dict(top=0.95, bottom=0.05, left=0.01, right=0.93, wspace=0, hspace=0).
+        slider_top: ax_slider is located at the top or bottom. default True.
+        color_background: color of background. default '#fafafa'.
+        color_grid: color of grid. default '#d0d0d0'.
+
+        df: stock data.
+        date: date column key. default 'date'
+        Open, high, low, close: price column key. default ('open', 'high', 'low', 'close')
+        volume: volume column key. default 'volume'
+
+        label_ma: moving average legend label format. default '{}일선'
+        list_ma: Decide how many days to draw the moving average line. default (5, 20, 60, 120, 240)
+        list_macolor: Color the moving average line. If the number of colors is greater than the moving average line, black is applied. default ('darkred', 'fuchsia', 'olive', 'orange', 'navy', 'darkmagenta', 'limegreen', 'darkcyan',)
+
+        candle_on_ma: Decide whether to draw candles on the moving average line. default True
+        color_sliderline: Color of closing price line in ax_slider. default 'k'
+        color_navigatorline: Color of left and right dividing lines in selected area. default '#1e78ff'
+        color_navigator: Color of unselected area. default 'k'
+
+        color_up: The color of the candle. When the closing price is greater than the opening price. default '#fe3032'
+        color_down: The color of the candle. When the opening price is greater than the opening price. default '#0095ff'
+        color_flat: The color of the candle. WWhen the closing price is the same as the opening price. default 'k'
+        color_up_down: The color of the candle. If the closing price is greater than the opening price, but is lower than the previous day's closing price. default 'w'
+        color_down_up: The color of the candle. If the opening price is greater than the closing price, but is higher than the closing price of the previous day. default 'w'
+        colors_volume: The color of the volume bar. default '#1f77b4'
+
+        lineKwargs: Options applied to horizontal and vertical lines drawn along the mouse position. default dict(edgecolor='k', linewidth=1, linestyle='-')
+        textboxKwargs: Options that apply to the information text box. dufault dict(boxstyle='round', facecolor='w')
+
+        fraction: Decide whether to express information as a fraction. default False
+        candleformat: Candle information text format. default '{}\n\n종가:　 {}\n등락률: {}\n대비:　 {}\n시가:　 {}({})\n고가:　 {}({})\n저가:　 {}({})\n거래량: {}({})'
+        volumeformat: Volume information text format. default '{}\n\n거래량　　　: {}\n거래량증가율: {}'
+        digit_price, digit_volume: Number of decimal places expressed in informational text. default (0, 0)
+
+        min_distance: Minimum number of candles that can be selected with the slider. default 30
+        simpler: Decide whether to display candles simply when moving the chart. default False
+        limit_volume: Maximum number of volume bars drawn when moving the chart. default 2_000
+    """
+    pass
+
+
+_name = {'samsung', 'apple'}
+def sample(name: Literal['samsung', 'apple']='samsung'):
+    if name not in _name:
+        print('name should be either samsung or apple.')
+        return
+    file = Path(__file__).parent / f'data/{name}.txt'
+    with open(file, 'r', encoding='utf-8') as txt:
+        data = json.load(txt)
+    data = data
+    df = pd.DataFrame(data)
+
+    c = Chart()
+    if name == 'apple':
+        c.unit_price = '$'
+        c.unit_volume = ' vol'
+        c.digit_price = 3
+        c.label_ma = 'ma{}'
+        c.candleformat = '{}\n\nend:     {}\nrate:    {}\ncompare: {}\nopen:    {}({})\nhigh:    {}({})\nlow:     {}({})\nvolume:  {}({})'
+        c.volumeformat = '{}\n\nvolume:      {}\nvolume rate: {}'
+    c.set_data(df)
+    show()
+    close()
+    return
+
+
+def show():
+    return plt.show()
+
+
+def close(fig: int|str|Figure|None='all'):
+    return plt.close(fig)
+
+
+if __name__ == '__main__':
+    sample('apple')
+
+

{seolpyo_mplchart-0.0.41 → seolpyo_mplchart-0.1.1}/seolpyo_mplchart/cursor.py

@@ -11,9 +11,6 @@ from .utils import float_to_str
 
 
 class Mixin:
-    def create_background(self):
-        "This function works befor canvas.copy_from_bbox()."
-        return
     def on_draw(self, e):
         "This function works if draw event active."
         return
@@ -64,19 +61,57 @@ class CollectionMixin(DrawMixin):
 _set_key = {'rate', 'compare', 'rate_open', 'rate_high', 'rate_low', 'rate_volume',}
 
 class DataMixin(CollectionMixin):
-    def _generate_data(self, df: pd.DataFrame):
-        for i in ['date', 'Open', 'high', 'low', 'close', 'volume']:
+    def _generate_data(self, df, sort_df=True, calc_ma=True, calc_info=True):
+        for i in ('date', 'Open', 'high', 'low', 'close', 'volume'):
             v = getattr(self, i)
-            if v in _set_key: raise Exception(f'you can not set "self.{i}" value in {_set_key}.\nself.{i}={v!r}')
+            if v in _set_key:
+                raise Exception(f'you can not set "self.{i}" value in {_set_key}.\nself.{i}={v!r}')
+
+        super()._generate_data(df, sort_df, calc_ma)
+        df = self.df
+
+        if not calc_info:
+            keys = set(df.keys())
+            for i in ('rate', 'compare', 'rate_open', 'rate_high', 'rate_low', 'rate_volume'):
+                if i not in keys:
+                    raise Exception(f'"{i}" column not in DataFrame.\nadd column or set calc_info=True.')
+        else:
+            df['rate'] = ((df[self.close] - df[self.close].shift(1)) / df[self.close] * 100).__round__(2).fillna(0)
+            df['compare'] = (df[self.close] - df[self.close].shift(1)).fillna(0)
+            df['rate_open'] = ((df[self.Open] - df[self.close].shift(1)) / df[self.close] * 100).__round__(2).fillna(0)
+            df['rate_high'] = ((df[self.high] - df[self.close].shift(1)) / df[self.close] * 100).__round__(2).fillna(0)
+            df['rate_low'] = ((df[self.low] - df[self.close].shift(1)) / df[self.close] * 100).__round__(2).fillna(0)
+            df['rate_volume'] = ((df[self.volume] - df[self.volume].shift(1)) /  df[self.volume].shift(1) * 100).__round__(2).fillna(0)
+
+        self.df = df
+        return
+
+    def set_text_coordante(self, vmin, vmax, pmin, pmax, volmax):
+        # 주가, 거래량 텍스트 x 위치
+        x_distance = (vmax - vmin) / 30
+        self.v0, self.v1 = (vmin + x_distance, vmax - x_distance)
+        self.text_price.set_x(self.v0)
+        self.text_volume.set_x(self.v0)
+
+        self.vmin, self.vmax = (vmin, vmax)
+        self.vmiddle = vmax - int((vmax - vmin) / 2)
 
-        super()._generate_data(df)
+        psub = pmax - pmin
+        self.min_psub = psub / 12
+
+        # 주가 날짜 텍스트 y 위치
+        y = (psub) / 20 + pmin
+        self.text_date_price.set_y(y)
+        # 주가 정보 y 위치
+        y = pmax - (psub) / 20
+        self.text_price_info.set_y(y)
+
+        # 거래량 날짜 텍스트 y 위치
+        y = volmax * 0.85
+        self.text_date_volume.set_y(y)
+        # 거래량 정보 y 위치
+        self.text_volume_info.set_y(y)
 
-        df['rate'] = ((df[self.close] - df[self.close].shift(1)) / df[self.close] * 100).__round__(2).fillna(0)
-        df['compare'] = (df[self.close] - df[self.close].shift(1)).fillna(0)
-        df['rate_open'] = ((df[self.Open] - df[self.close].shift(1)) / df[self.close] * 100).__round__(2).fillna(0)
-        df['rate_high'] = ((df[self.high] - df[self.close].shift(1)) / df[self.close] * 100).__round__(2).fillna(0)
-        df['rate_low'] = ((df[self.low] - df[self.close].shift(1)) / df[self.close] * 100).__round__(2).fillna(0)
-        df['rate_volume'] = ((df[self.volume] - df[self.volume].shift(1)) /  df[self.volume].shift(1) * 100).__round__(2).fillna(0)
         return
 
 
@@ -95,8 +130,10 @@ class LineMixin(DataMixin):
         self.canvas.blit()
         return
 
-    def set_data(self, df):
-        super().set_data(df)
+    def set_data(self, df, sort_df=True, calc_ma=True, change_lim=True, calc_info=True, *args, **kwargs):
+        return super().set_data(df, sort_df, calc_ma, change_lim, calc_info=calc_info, *args, **kwargs)
+    def _set_data(self, df: pd.DataFrame, sort_df=True, calc_ma=True, change_lim=True, calc_info=True, *args, **kwargs):
+        super()._set_data(df, sort_df, calc_ma, change_lim, calc_info=calc_info, *args, **kwargs)
 
         self.vmin, self.vmax = (self.xmin, self.xmax)
         return
@@ -172,8 +209,12 @@ class LineMixin(DataMixin):
         if self.in_index:
             intx = self.intx
             
-            high = self.df[self.high][intx] * 1.02
-            low = self.df[self.low][intx] * 0.98
+            h = self.df[self.high][intx]
+            l = self.df[self.low][intx]
+            sub = (h - l) / 2
+            if sub < self.min_psub: sub = self.min_psub
+            high = h + sub
+            low = l - sub
             if high < y or y < low: self._in_candle = False
             else:
                 self._in_candle = True
@@ -210,12 +251,12 @@ class LineMixin(DataMixin):
 
 class InfoMixin(LineMixin):
     fraction = False
-    candleformat = '{}\n\n종가:　 {}\n등락률: {}\n대비:　 {}\n시가:　 {}({})\n고가:　 {}({})\n저가:　 {}({})\n거래량: {}({})'
-    volumeformat = '{}\n\n거래량　　　: {}\n거래량증가율: {}'
+    candleformat = '{dt}\n\n종가:　 {close}\n등락률: {rate}\n대비:　 {compare}\n시가:　 {open}({rate_open})\n고가:　 {high}({rate_high})\n저가:　 {low}({rate_low})\n거래량: {volume}({rate_volume})'
+    volumeformat = '{dt}\n\n거래량　　　: {volume}\n거래량증가율: {rate_volume}'
     digit_price, digit_volume = (0, 0)
 
-    def set_data(self, df):
-        super().set_data(df)
+    def _set_data(self, df: pd.DataFrame, sort_df=True, calc_ma=True, change_lim=True, calc_info=True, *args, **kwargs):
+        super()._set_data(df, sort_df, calc_ma, change_lim, calc_info, *args, **kwargs)
 
         # 슬라이더 날짜 텍스트 y 위치
         y = self._slider_ymax - (self._slider_ymax - self._slider_ymin) / 6
@@ -227,31 +268,6 @@ class InfoMixin(LineMixin):
 
         return
 
-    def set_text_coordante(self, vmin, vmax, pmin, pmax, volmax):
-        # 주가, 거래량 텍스트 x 위치
-        x_distance = (vmax - vmin) / 30
-        self.v0, self.v1 = (vmin + x_distance, vmax - x_distance)
-        self.text_price.set_x(self.v0)
-        self.text_volume.set_x(self.v0)
-
-        self.vmin, self.vmax = (vmin, vmax)
-        self.vmiddle = vmax - int((vmax - vmin) / 2)
-
-        # 주가 날짜 텍스트 y 위치
-        y = (pmax - pmin) / 20 + pmin
-        self.text_date_price.set_y(y)
-        # 주가 정보 y 위치
-        y = pmax - (pmax - pmin) / 20
-        self.text_price_info.set_y(y)
-
-        # 거래량 날짜 텍스트 y 위치
-        y = volmax * 0.85
-        self.text_date_volume.set_y(y)
-        # 거래량 정보 y 위치
-        self.text_volume_info.set_y(y)
-
-        return
-
     def _slider_move_action(self, e):
         super()._slider_move_action(e)
 
@@ -350,35 +366,35 @@ class InfoMixin(LineMixin):
                 else: l = float_to_str(ld[0])
 
                 text = self.candleformat.format(
-                    dt,
-                    f'{c:>{self._length_text}}{self.unit_price}',
-                    f'{r:>{self._length_text}}%',
-                    f'{com:>{self._length_text}}{self.unit_price}',
-                    f'{o:>{self._length_text}}{self.unit_price}', f'{Or:+06,.2f}%',
-                    f'{h:>{self._length_text}}{self.unit_price}', f'{hr:+06,.2f}%',
-                    f'{l:>{self._length_text}}{self.unit_price}', f'{lr:+06,.2f}%',
-                    f'{v:>{self._length_text}}{self.unit_volume}', f'{vr:+06,.2f}%',
+                    dt=dt,
+                    close=f'{c:>{self._length_text}}{self.unit_price}',
+                    rate=f'{r:>{self._length_text}}%',
+                    compare=f'{com:>{self._length_text}}{self.unit_price}',
+                    open=f'{o:>{self._length_text}}{self.unit_price}', rate_open=f'{Or:+06,.2f}%',
+                    high=f'{h:>{self._length_text}}{self.unit_price}', rate_high=f'{hr:+06,.2f}%',
+                    low=f'{l:>{self._length_text}}{self.unit_price}', rate_low=f'{lr:+06,.2f}%',
+                    volume=f'{v:>{self._length_text}}{self.unit_volume}', rate_volume=f'{vr:+06,.2f}%',
                 )
             else:
                 o, h, l, c = (float_to_str(o, self.digit_price), float_to_str(h, self.digit_price), float_to_str(l, self.digit_price), float_to_str(c, self.digit_price))
                 com = float_to_str(compare, self.digit_price, plus=True)
 
                 text = self.candleformat.format(
-                    dt,
-                    f'{c:>{self._length_text}}{self.unit_price}',
-                    f'{r:>{self._length_text}}%',
-                    f'{com:>{self._length_text}}{self.unit_price}',
-                    f'{o:>{self._length_text}}{self.unit_price}', f'{Or:+06,.2f}%',
-                    f'{h:>{self._length_text}}{self.unit_price}', f'{hr:+06,.2f}%',
-                    f'{l:>{self._length_text}}{self.unit_price}', f'{lr:+06,.2f}%',
-                    f'{v:>{self._length_text}}{self.unit_volume}', f'{vr:+06,.2f}%',
+                    dt=dt,
+                    close=f'{c:>{self._length_text}}{self.unit_price}',
+                    rate=f'{r:>{self._length_text}}%',
+                    compare=f'{com:>{self._length_text}}{self.unit_price}',
+                    open=f'{o:>{self._length_text}}{self.unit_price}', rate_open=f'{Or:+06,.2f}%',
+                    high=f'{h:>{self._length_text}}{self.unit_price}', rate_high=f'{hr:+06,.2f}%',
+                    low=f'{l:>{self._length_text}}{self.unit_price}', rate_low=f'{lr:+06,.2f}%',
+                    volume=f'{v:>{self._length_text}}{self.unit_volume}', rate_volume=f'{vr:+06,.2f}%',
                 )
         else:
             vrate = f'{vr:+06,.2f}'
             text = self.volumeformat.format(
-                dt,
-                f'{v:>{self._length_text}}{self.unit_volume}',
-                f'{vrate:>{self._length_text}}%',
+                dt=dt,
+                volume=f'{v:>{self._length_text}}{self.unit_volume}',
+                rate_volume=f'{vrate:>{self._length_text}}%',
             )
         return text
 
@@ -388,10 +404,6 @@ class CursorMixin(InfoMixin):
 
 
 class Chart(CursorMixin, CM, Mixin):
-    def _generate_data(self, df):
-        super()._generate_data(df)
-        return self.generate_data(df)
-
     def _on_draw(self, e):
         super()._on_draw(e)
         return self.on_draw(e)
@@ -400,10 +412,6 @@ class Chart(CursorMixin, CM, Mixin):
         self.on_pick(e)
         return super()._on_pick(e)
 
-    def _draw_artist(self):
-        super()._draw_artist()
-        return self.create_background()
-
     def _blit(self):
         super()._blit()
         return self.on_blit()
@@ -424,14 +432,16 @@ if __name__ == '__main__':
     file = Path(__file__).parent / 'data/apple.txt'
     with open(file, 'r', encoding='utf-8') as txt:
         data = json.load(txt)
-    data = data[:100]
+    n = 2600
+    data = data[n:n+100]
     df = pd.DataFrame(data)
+    print(f'{df.keys()=}')
 
     t = time()
     c = CursorMixin()
     c.unit_price = '$'
     # c.fraction = True
-    c.set_data(df=df)
+    c.set_data(df[['date', 'open', 'high', 'low', 'close', 'volume']])
     t2 = time() - t
     print(f'{t2=}')
     plt.show()

{seolpyo_mplchart-0.0.41 → seolpyo_mplchart-0.1.1}/seolpyo_mplchart/draw.py

@@ -9,10 +9,6 @@ from .base import Base
 
 
 class Mixin:
-    def generate_data(self, df):
-        "This function works after data generate process is done."
-        return
-
     def on_blit(self):
         "This function works after cavas.blit()."
         return
@@ -27,7 +23,7 @@ class Mixin:
         return
 
 
-_set_key = {'x', 'left', 'right', 'top', 'bottom',}
+_set_key = {'zero', 'x', 'left', 'right', 'top', 'bottom',}
 
 class DataMixin(Base):
     df: pd.DataFrame
@@ -41,30 +37,40 @@ class DataMixin(Base):
     # https://matplotlib.org/stable/gallery/color/named_colors.html
     list_macolor = ('darkred', 'fuchsia', 'olive', 'orange', 'navy', 'darkmagenta', 'limegreen', 'darkcyan',)
 
-    color_up = '#fe3032'
-    color_down = '#0095ff'
+    color_up, color_down = ('#fe3032', '#0095ff')
     color_flat = 'k'
-    color_up_down = 'w'
-    color_down_up = 'w'
+    color_up_down, color_down_up = ('w', 'w')
     colors_volume = '#1f77b4'
 
-    def _generate_data(self, df: pd.DataFrame):
-        for i in ['date', 'Open', 'high', 'low', 'close', 'volume']:
+    candlewidth_half, volumewidth_half = (0.3, 0.36)
+
+    def _generate_data(self, df: pd.DataFrame, sort_df=True, calc_ma=True, **_):
+        for i in ('date', 'Open', 'high', 'low', 'close', 'volume'):
             k: str = getattr(self, i)
             if k in _set_key: raise Exception(f'you can not set "self.{i}" value in {_set_key}.\nself.{i}={k!r}')
             if i != 'date':
                 dtype = df[k].dtype
-                if not isinstance(dtype, (np.dtypes.Float64DType, np.dtypes.Int64DType, np.dtypes.Float32DType, np.dtypes.Int32DType)): raise TypeError(f'Data column type must be "float64" or "int64" or "float32" or "int32".(excluding "date" column)\ndf[{k!r}].dtype={dtype!r}')
+                if not isinstance(dtype, (np.dtypes.Float64DType, np.dtypes.Int64DType, np.dtypes.Float32DType, np.dtypes.Int32DType)):
+                    raise TypeError(f'column dtype must be one of "float64" or "int64" or "float32" or "int32".(excluding "date" column)\ndf[{k!r}].dtype={dtype!r}')
 
-        for i in self.list_ma: df[f'ma{i}'] = df[self.close].rolling(i).mean()
+        # DataFrame 정렬
+        if sort_df:
+            df = df.sort_values([self.date]).reset_index()
+
+        if not self.list_ma: self.list_ma = tuple()
+        if calc_ma:
+            for i in self.list_ma: df[f'ma{i}'] = df[self.close].rolling(i).mean()
+        else:
+            keys = set(df.keys())
+            for i in self.list_ma:
+                if f'ma{i}' not in keys:
+                    raise Exception(f'"ma{i}" column not in DataFrame.\nadd column or set calc_ma=True.')
 
-        candlewidth_half = 0.3
-        volumewidth_half = 0.36
         df['x'] = df.index + 0.5
-        df['left'] = df['x'] - candlewidth_half
-        df['right'] = df['x'] + candlewidth_half
-        df['vleft'] = df['x'] - volumewidth_half
-        df['vright'] = df['x'] + volumewidth_half
+        df['left'] = df['x'] - self.candlewidth_half
+        df['right'] = df['x'] + self.candlewidth_half
+        df['vleft'] = df['x'] - self.volumewidth_half
+        df['vright'] = df['x'] + self.volumewidth_half
 
         df['top'] = np.where(df[self.Open] <= df[self.close], df[self.close], df[self.Open])
         df['top'] = np.where(df[self.close] < df[self.Open], df[self.Open], df[self.close])
@@ -72,7 +78,7 @@ class DataMixin(Base):
         df['bottom'] = np.where(df[self.close] < df[self.Open], df[self.close], df[self.Open])
 
         # 양봉
-        df.loc[:, ['facecolor', 'edgecolor']] = (self.color_up, self.color_up)
+        df.loc[:, ['zero', 'facecolor', 'edgecolor']] = (0, self.color_up, self.color_up)
         if self.color_up != self.color_down:
             # 음봉
             df.loc[df[self.close] < df[self.Open], ['facecolor', 'edgecolor']] = (self.color_down, self.color_down)
@@ -89,7 +95,6 @@ class DataMixin(Base):
         self.df = df
         return
 
-
 class CollectionMixin(DataMixin):
     color_sliderline = 'k'
 
@@ -123,57 +128,55 @@ class CollectionMixin(DataMixin):
 
         return
 
-    def _get_candlesegment(self, s: pd.Series):
-        v = s.values
-        segment = (
-            (v[0], v[3]), # 심지 상단
-            (v[0], v[5]), # 몸통 상단
-            (v[1], v[5]), # 몸통 상단 좌측
-            (v[1], v[6]), # 몸통 하단 좌측
-            (v[0], v[6]), # 몸통 하단
-            (v[0], v[4]), # 심지 하단
-            (v[0], v[6]), # 몸통 하단
-            (v[2], v[6]), # 몸통 하단 우측
-            (v[2], v[5]), # 몸통 상단 우측
-            (v[0], v[5]), # 몸통 상단
-        )
-        return segment
-
-    def _get_volumesegment(self, s: pd.Series):
-        v = s.values
-        segment = (
-            (v[0], 0), # 몸통 하단 좌측
-            (v[0], v[2]), # 몸통 상단 좌측
-            (v[1], v[2]), # 몸통 상단 우측
-            (v[1], 0), # 몸통 하단 우측
-        )
-        return segment
-
     def _set_collection(self):
-        self.df.loc[:, ['candlesegment']] = self.df[['x', 'left', 'right', self.high, self.low, 'top', 'bottom']].agg(self._get_candlesegment, axis=1)
-        self.df.loc[:, ['volumesegment']] = self.df[['vleft', 'vright', self.volume]].agg(self._get_volumesegment, axis=1)
+        candleseg = self.df[[
+            'x', self.high,
+            'x', 'top',
+            'left', 'top',
+            'left', 'bottom',
+            'x', 'bottom',
+            'x', self.low,
+            'x', 'bottom',
+            'right', 'bottom',
+            'right', 'top',
+            'x', 'top',
+        ]].values
+        candleseg = candleseg.reshape(candleseg.shape[0], 10, 2)
+
+        self.candlecollection.set_segments(candleseg)
+        self.candlecollection.set_facecolor(self.df['facecolor'].values)
+        self.candlecollection.set_edgecolor(self.df['edgecolor'].values)
+
+        volseg = self.df[[
+            'left', 'zero',
+            'left', self.volume,
+            'right', self.volume,
+            'right', 'zero',
+        ]].values
+        volseg = volseg.reshape(volseg.shape[0], 4, 2)
+
+        self.volumecollection.set_segments(volseg)
 
         self._set_macollection()
 
         # 가격이동평균선
-        segments = list(reversed(self._masegment.values()))
+        maseg = reversed(self._masegment.values())
         colors, widths = ([], [])
         for i in reversed(self._macolors.values()): (colors.append(i), widths.append(1))
-        self.macollection.set_segments(segments)
+        self.macollection.set_segments(maseg)
         self.macollection.set_edgecolor(colors)
 
         # 슬라이더 선형차트
-        segments.append(self.df[['x', self.close]].apply(tuple, axis=1).tolist())
+        keys = []
+        for i in reversed(self.list_ma):
+            keys.append('x')
+            keys.append(f'ma{i}')
+        sliderseg = self.df[keys + ['x', self.close]].values
+        sliderseg = sliderseg.reshape(sliderseg.shape[0], self.list_ma.__len__()+1, 2).swapaxes(0, 1)
         (colors.append(self.color_sliderline), widths.append(1.8))
-        self.slidercollection.set_segments(segments)
+        self.slidercollection.set_segments(sliderseg)
         self.slidercollection.set_edgecolor(colors)
         self.slidercollection.set_linewidth(widths)
-
-        self.candlecollection.set_segments(self.df['candlesegment'])
-        self.candlecollection.set_facecolor(self.df['facecolor'].values)
-        self.candlecollection.set_edgecolor(self.df['edgecolor'].values)
-
-        self.volumecollection.set_segments(self.df['volumesegment'])
         return
 
     def _set_macollection(self):
@@ -188,7 +191,10 @@ class CollectionMixin(DataMixin):
             try: c = self.list_macolor[n]
             except: c = self.color_sliderline
             self._macolors[i] = c
-            self._masegment[i] = self.df[['x', f'ma{i}']].apply(tuple, axis=1).tolist()
+            # seg = self.df['x', f'ma{i}'].values
+            seg = self.df.loc[self.df[f'ma{i}'] != np.nan, ['x', f'ma{i}']].values
+            # print(f'{seg[:5]=}')
+            self._masegment[i] = seg
 
             handles.append(Line2D([0, 1], [0, 1], color=c, linewidth=5, label=i))
             labels.append(self.label_ma.format(i))
@@ -300,25 +306,29 @@ class BackgroundMixin(CollectionMixin):
         self.canvas.renderer.restore_region(self.background)
         return
 
-
 class DrawMixin(BackgroundMixin):
-    def set_data(self, df: pd.DataFrame):
-        self._generate_data(df)
+    def set_data(self, df: pd.DataFrame, sort_df=True, calc_ma=True, change_lim=True, *_, **kwargs):
+        self._set_data(df, sort_df, calc_ma, change_lim, **kwargs)
+        return self.df
+
+    def _set_data(self, df: pd.DataFrame, sort_df=True, calc_ma=True, change_lim=True, *_, **kwargs):
+        self._generate_data(df, sort_df, calc_ma, **kwargs)
         self._set_collection()
-        self._draw_collection()
+        self._draw_collection(change_lim)
         return
 
-    def _draw_collection(self):
+    def _draw_collection(self, change_lim=True):
         xmax = self.df['x'].values[-1] + 1
 
         xspace = xmax / 40
         self.xmin, self.xmax = (-xspace, xmax+xspace)
         # 슬라이더 xlim
         self.ax_slider.set_xlim(self.xmin, self.xmax)
-        # 주가 xlim
-        self.ax_price.set_xlim(self.xmin, self.xmax)
-        # 거래량 xlim
-        self.ax_volume.set_xlim(self.xmin, self.xmax)
+        if change_lim:
+            # 주가 xlim
+            self.ax_price.set_xlim(self.xmin, self.xmax)
+            # 거래량 xlim
+            self.ax_volume.set_xlim(self.xmin, self.xmax)
 
         ymin, ymax = (self.df[self.low].min(), self.df[self.high].max())
         ysub = (ymax - ymin) / 15
@@ -329,19 +339,15 @@ class DrawMixin(BackgroundMixin):
 
         # 주가 ylim
         self._price_ymin, self._price_ymax = (ymin-ysub, ymax+ysub)
-        self.ax_price.set_ylim(self._price_ymin, self._price_ymax)
+        if change_lim: self.ax_price.set_ylim(self._price_ymin, self._price_ymax)
 
         # 거래량 ylim
         self._vol_ymax = self.df[self.volume].max() * 1.2
-        self.ax_volume.set_ylim(0, self._vol_ymax)
+        if change_lim: self.ax_volume.set_ylim(0, self._vol_ymax)
         return
 
 
 class Chart(DrawMixin, Mixin):
-    def _generate_data(self, df):
-        super()._generate_data(df)
-        return self.generate_data(self.df)
-
     def _on_draw(self, e):
         super()._on_draw(e)
         return self.on_draw(e)

{seolpyo_mplchart-0.0.41 → seolpyo_mplchart-0.1.1}/seolpyo_mplchart/slider.py

@@ -21,6 +21,10 @@ class Mixin(CursorMixin):
     def on_release(self, e):
         "This function works if mouse button release event active."
         return
+    def draw_artist(self):
+        "This function works before canvas.blit()."
+        return
+
 
 class NavgatorMixin(Mixin):
     min_distance = 30
@@ -39,8 +43,8 @@ class NavgatorMixin(Mixin):
         self.ax_slider.add_artist(self.navigator)
         return
 
-    def set_data(self, df):
-        super().set_data(df)
+    def _set_data(self, df: pd.DataFrame, sort_df=True, calc_ma=True, change_lim=True, calc_info=True):
+        super()._set_data(df, sort_df, calc_ma, change_lim, calc_info)
 
         # 네비게이터 라인 선택 영역
         xsub = self.xmax - self.xmin
@@ -96,9 +100,6 @@ class NavgatorMixin(Mixin):
 
         if self._navcoordinate[0] == self._navcoordinate[1]:
             self._navcoordinate = (self._navcoordinate[0], self._navcoordinate[1]+self.min_distance)
-
-        self.background = None
-        self._draw()
         return
 
 
@@ -108,19 +109,27 @@ class BackgroundMixin(NavgatorMixin):
         self._restore_region()
         return
 
-    def _restore_region(self, with_nav=True):
+    def _restore_region(self, with_nav=True, empty=False, empty_with_nav=False):
         if not self.background: self._create_background()
 
-        if with_nav: self.canvas.restore_region(self.background_with_nav)
+        if empty: self.canvas.restore_region(self.background_empty)
+        elif empty_with_nav: self.canvas.restore_region(self.background_empty_with_nav)
+        elif with_nav: self.canvas.restore_region(self.background_with_nav)
         else: self.canvas.renderer.restore_region(self.background)
         return
 
     def _copy_bbox(self):
-        self.ax_slider.xaxis.draw(self.canvas.renderer)
-        self.ax_slider.yaxis.draw(self.canvas.renderer)
-        self.slidercollection.draw(self.canvas.renderer)
+        renderer = self.canvas.renderer
 
-        super()._copy_bbox()
+        self.background_empty = renderer.copy_from_bbox(self.fig.bbox)
+
+        self.ax_slider.xaxis.draw(renderer)
+        self.ax_slider.yaxis.draw(renderer)
+        self.slidercollection.draw(renderer)
+        self.background_empty_with_nav = self.canvas.renderer.copy_from_bbox(self.fig.bbox)
+
+        self._draw_artist()
+        self.background = self.canvas.renderer.copy_from_bbox(self.fig.bbox)
 
         self.navigator.draw(self.canvas.renderer)
         self.background_with_nav = self.canvas.renderer.copy_from_bbox(self.fig.bbox)
@@ -147,26 +156,24 @@ class BackgroundMixin(NavgatorMixin):
 
 
 class DrawMixin(BackgroundMixin):
-    def set_data(self, df):
-        super().set_data(df)
+    def _set_data(self, df: pd.DataFrame, sort_df=True, calc_ma=True, change_lim=True, calc_info=True):
+        super()._set_data(df, sort_df, calc_ma, change_lim, calc_info)
 
         # 네비게이터 높이 설정
-        if 0 < self._slider_ymin: ysub = self._slider_ymax
-        else: ysub = self._slider_ymax - self._slider_ymin
-        self._ymiddle = ysub / 2
+        ysub = self._slider_ymax - self._slider_ymin
+        self._ymiddle = self._slider_ymax - ysub / 2
         self.navigator.set_linewidth((ysub, 5))
         return
 
     def _on_release(self, e: MouseEvent):
-        if e.inaxes is not self.ax_slider: return
-        self.is_click, self.is_move = (False, False)
-
-        if self._navcoordinate[0] == self._navcoordinate[1]:
-            self._navcoordinate = (self._navcoordinate[0], self._navcoordinate[1]+self.min_distance)
+        super()._on_release(e)
         self._set_navigator(*self._navcoordinate)
 
-        self.background = None
-        self._draw()
+        self._restore_region(empty=True)
+        self._creating_background = False
+        self._create_background()
+        self._restore_region()
+        self._blit()
         return
 
     def _on_move(self, e: MouseEvent):
@@ -238,27 +245,6 @@ class DrawMixin(BackgroundMixin):
 
 
 class LimMixin(DrawMixin):
-    def _restore_region(self, with_nav=True, empty=False):
-        if not self.background: self._create_background()
-
-        if empty: self.canvas.restore_region(self.background_empty)
-        elif with_nav: self.canvas.restore_region(self.background_with_nav)
-        else: self.canvas.renderer.restore_region(self.background)
-        return
-
-    def _copy_bbox(self):
-        self.ax_slider.xaxis.draw(self.canvas.renderer)
-        self.ax_slider.yaxis.draw(self.canvas.renderer)
-        self.slidercollection.draw(self.canvas.renderer)
-        self.background_empty = self.canvas.renderer.copy_from_bbox(self.fig.bbox)
-
-        self._draw_artist()
-        self.background = self.canvas.renderer.copy_from_bbox(self.fig.bbox)
-
-        self.navigator.draw(self.canvas.renderer)
-        self.background_with_nav = self.canvas.renderer.copy_from_bbox(self.fig.bbox)
-        return
-
     def _on_release(self, e: MouseEvent):
         if e.inaxes is not self.ax_slider: return
         self.is_click, self.is_move = (False, False)
@@ -268,12 +254,14 @@ class LimMixin(DrawMixin):
         self._set_navigator(*self._navcoordinate)
         self._lim()
 
-        self.background = None
-        self._draw()
+        self._restore_region(empty=True)
+        self._copy_bbox()
+        self._restore_region()
+        self._blit()
         return
 
     def _on_move(self, e):
-        self._restore_region(with_nav=(not self.is_click), empty=self.is_click)
+        self._restore_region(with_nav=(not self.is_click), empty_with_nav=self.is_click)
 
         self._on_move_action(e)
 
@@ -329,7 +317,8 @@ class LimMixin(DrawMixin):
 
 class SimpleMixin(LimMixin):
     simpler = False
-    limit_volume = 2_000
+    limit_volume = 1_500
+    default_left, default_right = (180, 10)
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -345,35 +334,34 @@ class SimpleMixin(LimMixin):
         self.ax_volume.add_collection(self.blitvolume)
         return
 
-    def set_data(self, df):
-        super().set_data(df)
+    def _set_data(self, df: pd.DataFrame, sort_df=True, calc_ma=True, change_lim=True, calc_info=True):
+        super()._set_data(df, sort_df, calc_ma, False, calc_info)
 
-        seg = self.df[['x', self.high, self.low]].agg(get_wickline, axis=1)
+        seg = self.df[['x', self.high, 'x', self.low]].values
+        seg = seg.reshape(seg.shape[0], 2, 2)
         self.blitcandle.set_segments(seg)
         self.blitcandle.set_edgecolor(self.df['edgecolor'])
-        self.priceline.set_verts([self.df[['x', self.close]].apply(tuple, axis=1).tolist()])
 
-        volmax = self.df[self.volume].max()
+        pseg = self.df[['x', self.close]].values
+        self.priceline.set_verts(pseg.reshape(1, *pseg.shape))
+
         l = self.df.__len__()
         if l < self.limit_volume:
-            volseg = self.df.loc[:, ['x', self.volume]].agg(get_volumeline, axis=1)
+            volseg = self.df.loc[:, ['x', 'zero', 'x', self.volume]].values
         else:
-            n, step = (1, 1 / self.limit_volume)
-            for _ in range(self.limit_volume):
-                n -= step
-                volmin = volmax * n
-                length = self.df.loc[volmin < self.df[self.volume]].__len__()
-                if self.limit_volume < length: break
-            
-            volseg = self.df.loc[volmin < self.df[self.volume], ['x', self.volume]].agg(get_volumeline, axis=1)
-        self.blitvolume.set_segments(volseg)
-
-        index = self.df.index[-1]
-        if index < 120: self._navcoordinate = (int(self.xmin)-1, int(self.xmax)+1)
-        else: self._navcoordinate = (index-80, index+10)
+            v = self.df[['x', 'zero', 'x', self.volume]].sort_values([self.volume], axis=0, ascending=False)
+            volseg = v[:self.limit_volume].values
+
+        self.blitvolume.set_segments(volseg.reshape(volseg.shape[0], 2, 2))
+
+        if change_lim:
+            index = self.df.index[-1]
+            if index < self.default_left + self.default_right: self._navcoordinate = (int(self.xmin)-1, int(self.xmax)+1)
+            else: self._navcoordinate = (index-self.default_left, index+self.default_right)
+
         self._set_navigator(*self._navcoordinate)
         self._lim()
-        return self._draw()
+        return 
 
     def _draw_blit_artist(self):
         renderer = self.canvas.renderer
@@ -381,12 +369,20 @@ class SimpleMixin(LimMixin):
         self.ax_price.xaxis.draw(renderer)
         self.ax_price.yaxis.draw(renderer)
 
-        if self.simpler: self.blitcandle.draw(renderer)
+        left, right = self._navcoordinate
+        Range = right - left
+        if self.simpler:
+            if Range < 1_000: self.blitcandle.draw(renderer)
+            else: self.priceline.draw(renderer)
         elif self.candle_on_ma:
             self.macollection.draw(renderer)
-            self.candlecollection.draw(renderer)
+            if 2_500 < Range: self.priceline.draw(renderer)
+            elif 800 < Range or 9_999 < self.xmax: self.blitcandle.draw(renderer)
+            else: self.candlecollection.draw(renderer)
         else:
-            self.candlecollection.draw(renderer)
+            if 2_500 < Range: self.priceline.draw(renderer)
+            elif 800 < Range or 9_999 < self.xmax: self.blitcandle.draw(renderer)
+            else: self.candlecollection.draw(renderer)
             self.macollection.draw(renderer)
 
         self.ax_volume.xaxis.draw(renderer)
@@ -436,12 +432,16 @@ class ClickMixin(SimpleMixin):
         if not self.is_click: return
         elif e.inaxes is self.ax_slider: return super()._on_release(e)
         elif not self.in_price and not self.in_volume and not self.is_click_chart: return
+        # 차트 click release action
         self.canvas.set_cursor(cursors.POINTER)
         self.is_click, self.is_move = (False, False)
         self.is_click_chart = False
 
-        self._draw()
-        return self._restore_region()
+        self._restore_region(empty=True)
+        self._copy_bbox()
+        self._restore_region()
+        self._blit()
+        return
 
     def _on_chart_click(self, e: MouseEvent):
         self.is_click = True
@@ -469,7 +469,7 @@ class ClickMixin(SimpleMixin):
         return
 
     def _on_move(self, e):
-        self._restore_region(with_nav=(not self.is_click), empty=self.is_click)
+        self._restore_region(with_nav=(not self.is_click), empty_with_nav=self.is_click)
 
         self._on_move_action(e)
 
@@ -506,58 +506,6 @@ class SliderMixin(ClickMixin):
 
 
 class Chart(SliderMixin, CM, Mixin):
-    r"""
-    You can see the guidance document:
-        Korean: https://white.seolpyo.com/entry/147/
-        English: https://white.seolpyo.com/entry/148/
-
-    Variables:
-        unit_price, unit_volume: unit for price and volume. default ('원', '주').
-
-        figsize: figure size if you use plt.show(). default (12, 6).
-        ratio_ax_slider, ratio_ax_legend, ratio_ax_price, ratio_ax_volume: Axes ratio. default (3, 2, 18, 5).
-        adjust: figure adjust. default dict(top=0.95, bottom=0.05, left=0.01, right=0.93, wspace=0, hspace=0).
-        slider_top: ax_slider is located at the top or bottom. default True.
-        color_background: color of background. default '#fafafa'.
-        color_grid: color of grid. default '#d0d0d0'.
-
-        df: stock data.
-        date: date column key. default 'date'
-        Open, high, low, close: price column key. default ('open', 'high', 'low', 'close')
-        volume: volume column key. default 'volume'
-
-        label_ma: moving average legend label format. default '{}일선'
-        list_ma: Decide how many days to draw the moving average line. default (5, 20, 60, 120, 240)
-        list_macolor: Color the moving average line. If the number of colors is greater than the moving average line, black is applied. default ('darkred', 'fuchsia', 'olive', 'orange', 'navy', 'darkmagenta', 'limegreen', 'darkcyan',)
-
-        candle_on_ma: Decide whether to draw candles on the moving average line. default True
-        color_sliderline: Color of closing price line in ax_slider. default 'k'
-        color_navigatorline: Color of left and right dividing lines in selected area. default '#1e78ff'
-        color_navigator: Color of unselected area. default 'k'
-
-        color_up: The color of the candle. When the closing price is greater than the opening price. default '#fe3032'
-        color_down: The color of the candle. When the opening price is greater than the opening price. default '#0095ff'
-        color_flat: The color of the candle. WWhen the closing price is the same as the opening price. default 'k'
-        color_up_down: The color of the candle. If the closing price is greater than the opening price, but is lower than the previous day's closing price. default 'w'
-        color_down_up: The color of the candle. If the opening price is greater than the closing price, but is higher than the closing price of the previous day. default 'w'
-        colors_volume: The color of the volume bar. default '#1f77b4'
-
-        lineKwargs: Options applied to horizontal and vertical lines drawn along the mouse position. default dict(edgecolor='k', linewidth=1, linestyle='-')
-        textboxKwargs: Options that apply to the information text box. dufault dict(boxstyle='round', facecolor='w')
-
-        fraction: Decide whether to express information as a fraction. default False
-        candleformat: Candle information text format. default '{}\n\n종가:　 {}\n등락률: {}\n대비:　 {}\n시가:　 {}({})\n고가:　 {}({})\n저가:　 {}({})\n거래량: {}({})'
-        volumeformat: Volume information text format. default '{}\n\n거래량　　　: {}\n거래량증가율: {}'
-        digit_price, digit_volume: Number of decimal places expressed in informational text. default (0, 0)
-
-        min_distance: Minimum number of candles that can be selected with the slider. default 30
-        simpler: Decide whether to display candles simply when moving the chart. default False
-        limit_volume: Maximum number of volume bars drawn when moving the chart. default 2_000
-    """
-    def _generate_data(self, df):
-        super()._generate_data(df)
-        return self.generate_data(self.df)
-
     def _on_draw(self, e):
         super()._on_draw(e)
         return self.on_draw(e)
@@ -568,7 +516,10 @@ class Chart(SliderMixin, CM, Mixin):
 
     def _draw_artist(self):
         super()._draw_artist()
-        return self.create_background()
+        return self.draw_artist()
+    def _draw_blit_artist(self):
+        super()._draw_blit_artist()
+        return self.draw_artist()
 
     def _blit(self):
         super()._blit()
@@ -594,8 +545,10 @@ if __name__ == '__main__':
     df = pd.DataFrame(data)
 
     t = time()
+    # c = SimpleMixin()
     c = SliderMixin()
     c.set_data(df)
     t2 = time() - t
     print(f'{t2=}')
     plt.show()
+

{seolpyo_mplchart-0.0.41 → seolpyo_mplchart-0.1.1/seolpyo_mplchart.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: seolpyo-mplchart
-Version: 0.0.41
-Summary: Fast candlestick chart using Python.
+Version: 0.1.1
+Summary: Fast candlestick chart using Python. Includes navigator, slider, navigation, and text information display functions
 Author-email: white-seolpyo <white-seolpyo@naver.com>
 License: MIT License
 Project-URL: Homepage, https://white.seolpyo.com/

seolpyo_mplchart-0.0.41/seolpyo_mplchart/__init__.py

@@ -1,49 +0,0 @@
-"""
-This software includes Matplotlib, which is licensed under the BSD License.
-Matplotlib Copyright (c) 2012- Matplotlib Development Team.
-Full license can be found in the LICENSE file or at https://matplotlib.org/stable/users/license.html
-"""
-
-
-import json
-from pathlib import Path
-from typing import Literal
-
-import matplotlib.pyplot as plt
-import pandas as pd
-
-
-from .slider import Chart
-
-
-_name = {'samsung', 'apple'}
-def sample(name: Literal['samsung', 'apple']='samsung'):
-    if name not in _name:
-        print('name should be either samsung or apple.')
-        return
-    file = Path(__file__).parent / f'data/{name}.txt'
-    with open(file, 'r', encoding='utf-8') as txt:
-        data = json.load(txt)
-    data = data
-    df = pd.DataFrame(data)
-
-    c = Chart()
-    if name == 'apple':
-        c.unit_price = '$'
-        c.unit_volume = ' vol'
-        c.digit_price = 3
-        c.label_ma = 'ma{}'
-        c.candleformat = '{}\n\nend:     {}\nrate:    {}\ncompare: {}\nopen:    {}({})\nhigh:    {}({})\nlow:     {}({})\nvolume:  {}({})'
-        c.volumeformat = '{}\n\nvolume:      {}\nvolume rate: {}'
-    c.set_data(df)
-    show()
-
-    return
-
-
-def show():
-    return plt.show()
-
-
-if __name__ == '__main__':
-    sample('apple')