bn-lightweight-charts 0.2.0__py3-none-any.whl

bn_lightweight_charts/topbar.py

@@ -0,0 +1,128 @@
+import asyncio
+from typing import Dict, Literal
+
+from .util import jbool, Pane
+
+
+ALIGN = Literal['left', 'right']
+
+
+class Widget(Pane):
+    def __init__(self, topbar, value, func: callable = None, convert_boolean=False):
+        super().__init__(topbar.win)
+        self.value = value
+
+        def wrapper(v):
+            if convert_boolean:
+                self.value = False if v == 'false' else True
+            else:
+                self.value = v
+            func(topbar._chart)
+
+        async def async_wrapper(v):
+            self.value = v
+            await func(topbar._chart)
+
+        self.win.handlers[self.id] = async_wrapper if asyncio.iscoroutinefunction(func) else wrapper
+
+
+class TextWidget(Widget):
+    def __init__(self, topbar, initial_text, align, func):
+        super().__init__(topbar, value=initial_text, func=func)
+
+        callback_name = f'"{self.id}"' if func else ''
+
+        self.run_script(f'{self.id} = {topbar.id}.makeTextBoxWidget("{initial_text}", "{align}", {callback_name})')
+
+    def set(self, string):
+        self.value = string
+        self.run_script(f'{self.id}.innerText = "{string}"')
+
+
+class SwitcherWidget(Widget):
+    def __init__(self, topbar, options, default, align, func):
+        super().__init__(topbar, value=default, func=func)
+        self.options = list(options)
+        self.run_script(f'{self.id} = {topbar.id}.makeSwitcher({self.options}, "{default}", "{self.id}", "{align}")')
+
+    def set(self, option):
+        if option not in self.options:
+            raise ValueError(f"option '{option}' does not exist within {self.options}.")
+        self.run_script(f'{self.id}.onItemClicked("{option}")')
+        self.value = option
+
+
+class MenuWidget(Widget):
+    def __init__(self, topbar, options, default, separator, align, func):
+        super().__init__(topbar, value=default, func=func)
+        self.options = list(options)
+        self.run_script(f'''
+        {self.id} = {topbar.id}.makeMenu({list(options)}, "{default}", {jbool(separator)}, "{self.id}", "{align}")
+        ''')
+
+    # TODO this will probably need to be fixed
+    def set(self, option):
+        if option not in self.options:
+            raise ValueError(f"Option {option} not in menu options ({self.options})")
+        self.value = option
+        self.run_script(f'''
+            {self.id}._clickHandler("{option}")
+        ''')
+        # self.win.handlers[self.id](option)
+
+    def update_items(self, *items: str):
+        self.options = list(items)
+        self.run_script(f'{self.id}.updateMenuItems({self.options})')
+
+
+class ButtonWidget(Widget):
+    def __init__(self, topbar, button, separator, align, toggle, func):
+        super().__init__(topbar, value=False, func=func, convert_boolean=toggle)
+        self.run_script(
+            f'{self.id} = {topbar.id}.makeButton("{button}", "{self.id}", {jbool(separator)}, true, "{align}", {jbool(toggle)})')
+
+    def set(self, string):
+        # self.value = string
+        self.run_script(f'{self.id}.elem.innerText = "{string}"')
+
+
+class TopBar(Pane):
+    def __init__(self, chart):
+        super().__init__(chart.win)
+        self._chart = chart
+        self._widgets: Dict[str, Widget] = {}
+        self._created = False
+
+    def _create(self):
+        if self._created:
+            return
+        self._created = True
+        self.run_script(f'{self.id} = {self._chart.id}.createTopBar()')
+
+    def __getitem__(self, item):
+        if widget := self._widgets.get(item):
+            return widget
+        raise KeyError(f'Topbar widget "{item}" not found.')
+
+    def get(self, widget_name):
+        return self._widgets.get(widget_name)
+
+    def switcher(self, name, options: tuple, default: str = None,
+                 align: ALIGN = 'left', func: callable = None):
+        self._create()
+        self._widgets[name] = SwitcherWidget(self, options, default if default else options[0], align, func)
+
+    def menu(self, name, options: tuple, default: str = None, separator: bool = True,
+             align: ALIGN = 'left', func: callable = None):
+        self._create()
+        self._widgets[name] = MenuWidget(self, options, default if default else options[0], separator, align, func)
+
+    def textbox(self, name: str, initial_text: str = '',
+                align: ALIGN = 'left', func: callable = None):
+        self._create()
+        self._widgets[name] = TextWidget(self, initial_text, align, func)
+
+    def button(self, name, button_text: str, separator: bool = True,
+               align: ALIGN = 'left', toggle: bool = False, func: callable = None):
+        self._create()
+        self._widgets[name] = ButtonWidget(self, button_text, separator, align, toggle, func)

bn_lightweight_charts/util.py

@@ -0,0 +1,227 @@
+import asyncio
+import json
+from datetime import datetime
+from zoneinfo import ZoneInfo
+from tzlocal import get_localzone_name
+from random import choices
+from typing import Literal, Union
+from numpy import isin
+import pandas as pd
+
+
+class Pane:
+    def __init__(self, window):
+        from .abstract import Window
+        self.win: Window = window
+        self.run_script = window.run_script
+        self.bulk_run = window.bulk_run
+        if hasattr(self, 'id'):
+            return
+        self.id = Window._id_gen.generate()
+
+
+class IDGen(list):
+    ascii = 'abcdefghijklmnopqrstuvwxyz'
+
+    def generate(self) -> str:
+        var = ''.join(choices(self.ascii, k=8))
+        if var not in self:
+            self.append(var)
+            return f'window.{var}'
+        self.generate()
+
+def format_datetime(dt: datetime, tz: Union[str, ZoneInfo] = None) -> str:
+    if tz is None:
+        # tz = ZoneInfo(get_localzone_name())
+        return dt.strftime('%Y-%m-%d %H:%M')
+    elif isinstance(tz, str):
+        tz = ZoneInfo(tz)
+    # If dt does not contain tzinfo, assume it is in the specified zone
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=tz)
+    else:
+        # Convert datetime to the required timezone
+        dt = dt.astimezone(tz)
+    return dt.strftime('%Y-%m-%d %H:%M GMT%z')
+
+def parse_event_message(window, string):
+    name, args = string.split('_~_')
+    args = args.split(';;;')
+    func = window.handlers[name]
+    return func, args
+
+def df_data(data: Union[pd.DataFrame, pd.Series]):
+    if isinstance(data, pd.DataFrame):
+        d = data.to_dict(orient='records')
+        filtered_records = [{k: v for k, v in record.items() if v is not None and not pd.isna(v)} for record in d]
+    else:
+        d = data.to_dict()
+        filtered_records = {k: v for k, v in d.items()}
+    return filtered_records
+
+def series_data(data: Union[pd.DataFrame, pd.Series]):
+    filtered_records = []
+    for idx, val in data.items():
+        if isinstance(val, float):
+            val_str = f'{val:.4f}'
+        else:
+            val_str = str(val)
+        filtered_records.append({'index': idx, 'value': val_str})
+    return filtered_records
+
+def js_data(data: Union[pd.DataFrame, pd.Series]):
+    if isinstance(data, pd.DataFrame):
+        d = data.to_dict(orient='records')
+        filtered_records = [{k: v for k, v in record.items() if v is not None and not pd.isna(v)} for record in d]
+    else:
+        d = data.to_dict()
+        filtered_records = {k: v for k, v in d.items()}
+    return json.dumps(filtered_records)
+
+
+def snake_to_camel(s: str):
+    components = s.split('_')
+    return components[0] + ''.join(x.title() for x in components[1:])
+
+def js_json(d: dict):
+    filtered_dict = {}
+    for key, val in d.items():
+        if key in ('self') or val in (None,):
+            continue
+        if '_' in key:
+            key = snake_to_camel(key)
+        filtered_dict[key] = val
+    return f"JSON.parse('{json.dumps(filtered_dict)}')"
+
+
+def jbool(b: bool): return 'true' if b is True else 'false' if b is False else None
+
+
+LINE_STYLE = Literal['solid', 'dotted', 'dashed', 'large_dashed', 'sparse_dotted']
+
+MARKER_POSITION = Literal['above', 'below', 'inside', 'atPriceMiddle', 'atPriceTop', 'atPriceBottom']
+
+MARKER_SHAPE = Literal['arrow_up', 'arrow_down', 'circle', 'square']
+
+CROSSHAIR_MODE = Literal['normal', 'magnet', 'hidden']
+
+PRICE_SCALE_MODE = Literal['normal', 'logarithmic', 'percentage', 'index100']
+
+TIME = Union[datetime, pd.Timestamp, str, float]
+
+NUM = Union[float, int]
+
+FLOAT = Literal['left', 'right', 'top', 'bottom']
+
+
+def as_enum(value, string_types):
+    types = string_types.__args__
+    return -1 if value not in types else types.index(value)
+
+
+def marker_shape(shape: MARKER_SHAPE):
+    return {
+        'arrow_up': 'arrowUp',
+        'arrow_down': 'arrowDown',
+    }.get(shape) or shape
+
+
+def marker_position(p: MARKER_POSITION):
+    return {
+        'above' : 'aboveBar',
+        'below' : 'belowBar',
+        'inside': 'inBar',
+        'atPriceMiddle': 'atPriceMiddle',
+        'atPriceTop'   : 'atPriceTop',
+        'atPriceBottom': 'atPriceBottom',
+    }.get(p)
+
+
+class Emitter:
+    def __init__(self):
+        self._callable = None
+
+    def __iadd__(self, other):
+        self._callable = other
+        return self
+
+    def _emit(self, *args):
+        if self._callable:
+            if asyncio.iscoroutinefunction(self._callable):
+                asyncio.create_task(self._callable(*args))
+            else:
+                self._callable(*args)
+
+
+class JSEmitter:
+    def __init__(self, chart, name, on_iadd, wrapper=None):
+        self._on_iadd = on_iadd
+        self._chart = chart
+        self._name = name
+        self._wrapper = wrapper
+
+    def __iadd__(self, other):
+        def final_wrapper(*arg):
+            other(self._chart, *arg) if not self._wrapper else self._wrapper(other, self._chart, *arg)
+        async def final_async_wrapper(*arg):
+            await other(self._chart, *arg) if not self._wrapper else await self._wrapper(other, self._chart, *arg)
+
+        self._chart.win.handlers[self._name] = final_async_wrapper if asyncio.iscoroutinefunction(other) else final_wrapper
+        self._on_iadd(other)
+        return self
+
+
+class Events:
+    def __init__(self, chart):
+        self.new_bar = Emitter()
+        self.search = JSEmitter(chart, f'search{chart.id}',
+            lambda o: chart.run_script(f'''
+            Lib.Handler.makeSpinner({chart.id})
+            {chart.id}.search = Lib.Handler.makeSearchBox({chart.id})
+            ''')
+        )
+        salt = chart.id[chart.id.index('.')+1:]
+        self.range_change = JSEmitter(chart, f'range_change{salt}',
+            lambda o: chart.run_script(f'''
+            let checkLogicalRange{salt} = (logical) => {{
+                {chart.id}.chart.timeScale().unsubscribeVisibleLogicalRangeChange(checkLogicalRange{salt})
+                
+                let barsInfo = {chart.id}.series.barsInLogicalRange(logical)
+                if (barsInfo) window.callbackFunction(`range_change{salt}_~_${{barsInfo.barsBefore}};;;${{barsInfo.barsAfter}}`)
+                    
+                setTimeout(() => {chart.id}.chart.timeScale().subscribeVisibleLogicalRangeChange(checkLogicalRange{salt}), 50)
+            }}
+            {chart.id}.chart.timeScale().subscribeVisibleLogicalRangeChange(checkLogicalRange{salt})
+            '''),
+            wrapper=lambda o, c, *arg: o(c, *[float(a) for a in arg])
+        )
+
+        self.click = JSEmitter(chart, f'subscribe_click{salt}',
+            lambda o: chart.run_script(f'''
+            let clickHandler{salt} = (param) => {{
+                if (!param.point) return;
+                const time = {chart.id}.chart.timeScale().coordinateToTime(param.point.x)
+                const price = {chart.id}.series.coordinateToPrice(param.point.y);
+                window.callbackFunction(`subscribe_click{salt}_~_${{time}};;;${{price}}`)
+            }}
+            {chart.id}.chart.subscribeClick(clickHandler{salt})
+            '''),
+            wrapper=lambda func, c, *args: func(c, *[float(a) if a != 'null' else None for a in args])
+        )
+
+class BulkRunScript:
+    def __init__(self, script_func):
+        self.enabled = False
+        self.scripts = []
+        self.script_func = script_func
+
+    def __enter__(self):
+        self.enabled = True
+
+    def __exit__(self, *args):
+        self.enabled = False
+        self.script_func('\n'.join(self.scripts))
+        self.scripts = []
+
+    def add_script(self, script):
+        self.scripts.append(script)