hikyuu 2.6.8__py3-none-manylinux2014_aarch64.whl

hikyuu/util/mylog.py

@@ -0,0 +1,291 @@
+#!/usr/bin/python
+# -*- coding: utf8 -*-
+# cp936
+
+import os
+import logging
+import logging.handlers
+import traceback
+import time
+import functools
+import multiprocessing
+
+
+# 统计函数运行时间
+def spend_time(func):
+    @functools.wraps(func)
+    def wrappedFunc(*args, **kargs):
+        starttime = time.perf_counter()
+        try:
+            print("\nCalling: %s" % func.__name__)
+            return func(*args, **kargs)
+        finally:
+            endtime = time.perf_counter()
+            print("spend time: %.6fs, %.4fm" % (endtime - starttime, (endtime - starttime) / 60))
+
+    return wrappedFunc
+
+# 统计函数运行时间
+
+
+def hku_benchmark(count=10):
+    def hku_benchmark_wrap(func):
+        @functools.wraps(func)
+        def wrappedFunc(*args, **kargs):
+            starttime = time.perf_counter()
+            try:
+                print(f"\nstart benchmark: {func.__name__}")
+                for i in range(count):
+                    ret = func(*args, **kargs)
+                return ret
+            finally:
+                endtime = time.perf_counter()
+                total_sec = endtime - starttime
+                total_min = total_sec / 60.0
+                seconds = total_sec / count
+                minutes = seconds / 60.0
+                print("+--------------------------------------------------------------------------")
+                print(f"|  run count: {count}")
+                print(f"|  total time: {total_sec: <.6f}s, {total_min: <.4f}m")
+                print(f"|  mean time: {seconds: <.6f}s, {minutes: <.4f}m")
+                print("+--------------------------------------------------------------------------")
+        return wrappedFunc
+    return hku_benchmark_wrap
+
+
+FORMAT = '%(asctime)-15s [%(levelname)s] %(message)s [%(name)s::%(funcName)s]'
+logging.basicConfig(format=FORMAT, level=logging.INFO)
+hku_logger_name = 'hikyuu'
+hku_logger = logging.getLogger(hku_logger_name)
+
+_usrdir = os.path.expanduser("~")
+if not os.path.lexists(f"{_usrdir}/.hikyuu"):
+    os.makedirs(f"{_usrdir}/.hikyuu")
+_logfile = logging.handlers.RotatingFileHandler(
+    f"{_usrdir}/.hikyuu/hikyuu_py.log", maxBytes=10240, backupCount=3, encoding="utf-8")
+_logfile.setFormatter(logging.Formatter(FORMAT))
+_logfile.setLevel(logging.WARN)
+hku_logger.addHandler(_logfile)
+
+g_hku_logger_lock = multiprocessing.Lock()
+
+
+def set_my_logger_file(file_name):
+    global _logfile
+    with g_hku_logger_lock:
+        hku_logger.removeHandler(_logfile)
+        _logfile = logging.handlers.RotatingFileHandler(
+            file_name, maxBytes=10240, backupCount=3, encoding="utf-8")
+        _logfile.setFormatter(logging.Formatter(FORMAT))
+        _logfile.setLevel(logging.WARN)
+        hku_logger.addHandler(_logfile)
+
+
+def get_default_logger():
+    return logging.getLogger(hku_logger_name)
+
+
+def class_logger(cls, enable=False):
+    # logger = logging.getLogger("{}.{}".format(cls.__module__, cls.__name__))
+    logger = logging.getLogger("{}".format(cls.__name__))
+    if enable == 'debug':
+        logger.setLevel(logging.DEBUG)
+    elif enable == 'info':
+        logger.setLevel(logging.INFO)
+    cls.logger = logger
+
+
+def add_class_logger_handler(class_list, level=logging.INFO, handler=None):
+    """为指定的类增加日志 handler，并设定级别
+
+    :param class_list: 类列表
+    :param level: 日志级别
+    :param handler: logging handler
+    """
+    for cls in class_list:
+        # logger = logging.getLogger("{}.{}".format(cls.__module__, cls.__name__))
+        logger = logging.getLogger("{}".format(cls.__name__))
+        if handler:
+            logger.addHandler(handler)
+        logger.setLevel(level)
+
+
+def hku_debug(msg, *args, **kwargs):
+    st = traceback.extract_stack()[-2]
+    logger = kwargs.pop("logger") if "logger" in kwargs else None
+    if logger:
+        logger.debug("{} [{}] ({}:{})".format(msg.format(*args, **kwargs), st.name, st.filename, st.lineno))
+    else:
+        hku_logger.debug("{} [{}] ({}:{})".format(msg.format(*args, **kwargs), st.name, st.filename, st.lineno))
+
+
+hku_trace = hku_debug
+
+
+def hku_info(msg, *args, **kwargs):
+    st = traceback.extract_stack()[-2]
+    logger = kwargs.pop("logger") if "logger" in kwargs else None
+    if logger is not None:
+        logger.info("{} [{}] ({}:{})".format(msg.format(*args, **kwargs), st.name, st.filename, st.lineno))
+    else:
+        hku_logger.info("{} [{}] ({}:{})".format(msg.format(*args, **kwargs), st.name, st.filename, st.lineno))
+
+
+def hku_warn(msg, *args, **kwargs):
+    st = traceback.extract_stack()[-2]
+    logger = kwargs.pop("logger") if "logger" in kwargs else None
+    if logger:
+        logger.warning("{} [{}] ({}:{})".format(msg.format(*args, **kwargs), st.name, st.filename, st.lineno))
+    else:
+        with g_hku_logger_lock:
+            hku_logger.warning("{} [{}] ({}:{})".format(msg.format(*args, **kwargs), st.name, st.filename, st.lineno))
+
+
+def hku_error(msg, *args, **kwargs):
+    st = traceback.extract_stack()[-2]
+    logger = kwargs.pop("logger") if "logger" in kwargs else None
+    if logger:
+        logger.error("{} [{}] ({}:{})".format(msg.format(*args, **kwargs), st.name, st.filename, st.lineno))
+    else:
+        with g_hku_logger_lock:
+            hku_logger.error("{} [{}] ({}:{})".format(msg.format(*args, **kwargs), st.name, st.filename, st.lineno))
+
+
+def hku_fatal(msg, *args, **kwargs):
+    st = traceback.extract_stack()[-2]
+    logger = kwargs.pop("logger") if "logger" in kwargs else None
+    if logger:
+        logger.critical("{} [{}] ({}:{})".format(msg.format(*args, **kwargs), st.name, st.filename, st.lineno))
+    else:
+        with g_hku_logger_lock:
+            hku_logger.critical("{} [{}] ({}:{})".format(msg.format(*args, **kwargs), st.name, st.filename, st.lineno))
+
+
+def hku_debug_if(exp, msg, *args, **kwargs):
+    if exp:
+        st = traceback.extract_stack()[-2]
+        logger = kwargs.pop("logger") if "logger" in kwargs else None
+        callback = kwargs.pop("callback") if "callback" in kwargs else None
+        if logger:
+            logger.info("{} [{}] ({}:{})".format(msg.format(*args, **kwargs), st.name, st.filename, st.lineno))
+        else:
+            hku_logger.info("{} [{}] ({}:{})".format(msg.format(*args, **kwargs), st.name, st.filename, st.lineno))
+        if callback:
+            callback()
+
+
+hku_trace_if = hku_debug_if
+
+
+def hku_info_if(exp, msg, *args, **kwargs):
+    if exp:
+        st = traceback.extract_stack()[-2]
+        logger = kwargs.pop("logger") if "logger" in kwargs else None
+        callback = kwargs.pop("callback") if "callback" in kwargs else None
+        if logger:
+            logger.info("{} [{}] ({}:{})".format(msg.format(*args, **kwargs), st.name, st.filename, st.lineno))
+        else:
+            hku_logger.info("{} [{}] ({}:{})".format(msg.format(*args, **kwargs), st.name, st.filename, st.lineno))
+        if callback:
+            callback()
+
+
+def hku_warn_if(exp, msg, *args, **kwargs):
+    if exp:
+        st = traceback.extract_stack()[-2]
+        logger = kwargs.pop("logger") if "logger" in kwargs else None
+        callback = kwargs.pop("callback") if "callback" in kwargs else None
+        if logger:
+            logger.warning("{} [{}] ({}:{})".format(msg.format(*args, **kwargs), st.name, st.filename, st.lineno))
+        else:
+            with g_hku_logger_lock:
+                hku_logger.warning("{} [{}] ({}:{})".format(msg.format(
+                    *args, **kwargs), st.name, st.filename, st.lineno))
+        if callback:
+            callback()
+
+
+def hku_error_if(exp, msg, *args, **kwargs):
+    if exp:
+        st = traceback.extract_stack()[-2]
+        logger = kwargs.pop("logger") if "logger" in kwargs else None
+        callback = kwargs.pop("callback") if "callback" in kwargs else None
+        if logger:
+            logger.error("{} [{}] ({}:{})".format(msg.format(*args, **kwargs), st.name, st.filename, st.lineno))
+        else:
+            with g_hku_logger_lock:
+                hku_logger.error("{} [{}] ({}:{})".format(msg.format(*args, **kwargs), st.name, st.filename, st.lineno))
+        if callback:
+            callback()
+
+
+def hku_fatal_if(exp, msg, *args, **kwargs):
+    if exp:
+        st = traceback.extract_stack()[-2]
+        logger = kwargs.pop("logger") if "logger" in kwargs else None
+        callback = kwargs.pop("callback") if "callback" in kwargs else None
+        if logger:
+            logger.critical("{} [{}] ({}:{})".format(msg.format(*args, **kwargs), st.name, st.filename, st.lineno))
+        else:
+            with g_hku_logger_lock:
+                hku_logger.critical("{} [{}] ({}:{})".format(
+                    msg.format(*args, **kwargs), st.name, st.filename, st.lineno))
+        if callback:
+            callback()
+
+
+# 跟踪函数运行
+def with_trace(level=logging.INFO):
+    def with_trace_wrap(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            hku_info('start run: %s' % func.__name__)
+            result = func(*args, **kwargs)
+            hku_info('completed: %s' % func.__name__)
+            return result
+
+        return wrapper
+
+    return with_trace_wrap
+
+
+def capture_multiprocess_all_logger(queue, level=None):
+    """重设所有子进程中的 logger 输出指定的 queue，并重设level
+
+    @param multiprocessing.Queue queue 指定的 mp Queue
+    @param level 日志输出等级, None为保持原有等级
+    """
+    if queue is None:
+        return
+    qh = logging.handlers.QueueHandler(queue)
+    for name in logging.Logger.manager.loggerDict.keys():
+        logger = logging.getLogger(name)
+        logger.addHandler(qh)
+        if level is not None:
+            logger.setLevel(level)
+
+# Temporary change logger level
+# https://docs.python.org/3/howto/logging-cookbook.html
+
+
+class LoggingContext:
+    def __init__(self, logger, level=None, handler=None, close=True):
+        self.logger = logger
+        self.level = level
+        self.handler = handler
+        self.close = close
+
+    def __enter__(self):
+        if self.level is not None:
+            self.old_level = self.logger.level
+            self.logger.setLevel(self.level)
+        if self.handler:
+            self.logger.addHandler(self.handler)
+
+    def __exit__(self, et, ev, tb):
+        if self.level is not None:
+            self.logger.setLevel(self.old_level)
+        if self.handler:
+            self.logger.removeHandler(self.handler)
+        if self.handler and self.close:
+            self.handler.close()

hikyuu/util/mylog.pyi

@@ -0,0 +1,72 @@
+from __future__ import annotations
+import functools as functools
+import logging as logging
+import multiprocessing as multiprocessing
+import os as os
+import time as time
+import traceback as traceback
+__all__: list[str] = ['FORMAT', 'LoggingContext', 'add_class_logger_handler', 'capture_multiprocess_all_logger', 'class_logger', 'functools', 'g_hku_logger_lock', 'get_default_logger', 'hku_benchmark', 'hku_debug', 'hku_debug_if', 'hku_error', 'hku_error_if', 'hku_fatal', 'hku_fatal_if', 'hku_info', 'hku_info_if', 'hku_logger', 'hku_logger_name', 'hku_trace', 'hku_trace_if', 'hku_warn', 'hku_warn_if', 'logging', 'multiprocessing', 'os', 'set_my_logger_file', 'spend_time', 'time', 'traceback', 'with_trace']
+class LoggingContext:
+    def __enter__(self):
+        ...
+    def __exit__(self, et, ev, tb):
+        ...
+    def __init__(self, logger, level = None, handler = None, close = True):
+        ...
+def add_class_logger_handler(class_list, level = 20, handler = None):
+    """
+    为指定的类增加日志 handler，并设定级别
+    
+        :param class_list: 类列表
+        :param level: 日志级别
+        :param handler: logging handler
+        
+    """
+def capture_multiprocess_all_logger(queue, level = None):
+    """
+    重设所有子进程中的 logger 输出指定的 queue，并重设level
+    
+        @param multiprocessing.Queue queue 指定的 mp Queue
+        @param level 日志输出等级, None为保持原有等级
+        
+    """
+def class_logger(cls, enable = False):
+    ...
+def get_default_logger():
+    ...
+def hku_benchmark(count = 10):
+    ...
+def hku_debug(msg, *args, **kwargs):
+    ...
+def hku_debug_if(exp, msg, *args, **kwargs):
+    ...
+def hku_error(msg, *args, **kwargs):
+    ...
+def hku_error_if(exp, msg, *args, **kwargs):
+    ...
+def hku_fatal(msg, *args, **kwargs):
+    ...
+def hku_fatal_if(exp, msg, *args, **kwargs):
+    ...
+def hku_info(msg, *args, **kwargs):
+    ...
+def hku_info_if(exp, msg, *args, **kwargs):
+    ...
+def hku_warn(msg, *args, **kwargs):
+    ...
+def hku_warn_if(exp, msg, *args, **kwargs):
+    ...
+def set_my_logger_file(file_name):
+    ...
+def spend_time(func):
+    ...
+def with_trace(level = 20):
+    ...
+FORMAT: str = '%(asctime)-15s [%(levelname)s] %(message)s [%(name)s::%(funcName)s]'
+_logfile: logging.handlers.RotatingFileHandler  # value = <RotatingFileHandler /root/.hikyuu/hikyuu_py.log (WARNING)>
+_usrdir: str = '/root'
+g_hku_logger_lock: multiprocessing.synchronize.Lock  # value = <Lock(owner=None)>
+hku_logger: logging.Logger  # value = <Logger hikyuu (INFO)>
+hku_logger_name: str = 'hikyuu'
+hku_trace = hku_debug
+hku_trace_if = hku_debug_if

hikyuu/util/notebook.py

@@ -0,0 +1,47 @@
+#!/usr/bin/python
+# -*- coding: utf8 -*-
+#
+# Create on: 2024-03-11
+#    Author: fasiondog
+
+# 来源于 pandas 中对 ipython，notebook 环境的检测代码
+
+def in_interactive_session() -> bool:
+    """
+    Check if we're running in an interactive shell.
+
+    Returns
+    -------
+    bool
+        True if running under python/ipython interactive shell.
+    """
+    def check_main():
+        try:
+            import __main__ as main
+        except ModuleNotFoundError:
+            return False
+        return not hasattr(main, "__file__")
+
+    try:
+        # error: Name '__IPYTHON__' is not defined
+        return __IPYTHON__ or check_main()  # type: ignore[name-defined]
+    except NameError:
+        return check_main()
+
+
+def in_ipython_frontend() -> bool:
+    """
+    Check if we're inside an IPython zmq frontend. 检测是否在 jupyter 环境中
+
+    Returns
+    -------
+    bool
+    """
+    try:
+        # error: Name 'get_ipython' is not defined
+        ip = get_ipython()  # type: ignore[name-defined]
+        return "zmq" in str(type(ip)).lower()
+    except NameError:
+        pass
+
+    return False

hikyuu/util/notebook.pyi

@@ -0,0 +1,23 @@
+from __future__ import annotations
+__all__: list[str] = ['in_interactive_session', 'in_ipython_frontend']
+def in_interactive_session() -> bool:
+    """
+    
+        Check if we're running in an interactive shell.
+    
+        Returns
+        -------
+        bool
+            True if running under python/ipython interactive shell.
+        
+    """
+def in_ipython_frontend() -> bool:
+    """
+    
+        Check if we're inside an IPython zmq frontend. 检测是否在 jupyter 环境中
+    
+        Returns
+        -------
+        bool
+        
+    """

hikyuu/util/singleton.py

@@ -0,0 +1,29 @@
+#!/usr/bin/python
+# -*- coding: utf8 -*-
+# cp936
+
+#==========================================================
+# History
+# 1. 20200822, Added by fasiondog
+#==========================================================
+
+import threading
+
+
+class SingletonType(type):
+    """基于 metalclass 实现单例
+
+    示例：
+    class MyClass(metaclass=SingletonType):
+        def __init__(self,name):
+            self.name = name
+    """
+
+    _instance_lock = threading.Lock()
+
+    def __call__(cls, *args, **kwargs):
+        if not hasattr(cls, "_instance"):
+            with SingletonType._instance_lock:
+                if not hasattr(cls, "_instance"):
+                    cls._instance = super(SingletonType, cls).__call__(*args, **kwargs)
+        return cls._instance

hikyuu/util/singleton.pyi

@@ -0,0 +1,18 @@
+from __future__ import annotations
+import threading as threading
+import typing
+__all__: list[str] = ['SingletonType', 'threading']
+class SingletonType(type):
+    """
+    基于 metalclass 实现单例
+    
+        示例：
+        class MyClass(metaclass=SingletonType):
+            def __init__(self,name):
+                self.name = name
+        
+    """
+    _instance_lock: typing.ClassVar[_thread.lock]  # value = <unlocked _thread.lock object at 0xffff778cc0c0>
+    @classmethod
+    def __call__(cls, *args, **kwargs):
+        ...

hikyuu/util/slice.py

@@ -0,0 +1,43 @@
+#!/usr/bin/python
+# -*- coding: utf8 -*-
+# cp936
+#
+# The MIT License (MIT)
+#
+# Copyright (c) 2010-2017 fasiondog
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+
+def list_getitem(data, i):
+    """对C++引出的vector，实现python的切片，
+       将引入的vector类的__getitem__函数覆盖即可。
+    """
+    if isinstance(i, int):
+        length = len(data)
+        index = length + i if i < 0 else i
+        if index < 0 or index >= length:
+            raise IndexError("index out of range: %d" % i)
+        return data.get(index)
+    
+    elif isinstance(i, slice):
+        return [data.get(x) for x in range(*i.indices(len(data)))]
+    
+    else:
+        raise IndexError("Error index type")

hikyuu/util/timeout.py

@@ -0,0 +1,83 @@
+#!/usr/bin/python
+# -*- coding: utf8 -*-
+# cp936
+
+import ctypes
+import threading
+import functools
+
+
+class ThreadKiller(threading.Thread):
+    """separate thread to kill TerminableThread"""
+    def __init__(self, target_thread, exception_cls, repeat_sec=2.0):
+        threading.Thread.__init__(self)
+        self.target_thread = target_thread
+        self.exception_cls = exception_cls
+        self.repeat_sec = repeat_sec
+        self.daemon = True
+
+    def run(self):
+        """loop raising exception incase it's caught hopefully this breaks us far out"""
+        while self.target_thread.is_alive():
+            ctypes.pythonapi.PyThreadState_SetAsyncExc(
+                ctypes.c_long(self.target_thread.ident), ctypes.py_object(self.exception_cls)
+            )
+            self.target_thread.join(self.repeat_sec)
+
+
+class TerminableThread(threading.Thread):
+    """a thread that can be stopped by forcing an exception in the execution context"""
+    def terminate(self, exception_cls, repeat_sec=2.0):
+        if self.is_alive() is False:
+            return True
+        killer = ThreadKiller(self, exception_cls, repeat_sec=repeat_sec)
+        killer.start()
+
+
+def timeout(sec, raise_sec=1):
+    """
+    timeout decorator
+    :param sec: function raise TimeoutError after ? seconds
+    :param raise_sec: retry kill thread per ? seconds
+        default: 1 second
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapped_func(*args, **kwargs):
+            err_msg = f'Function {func.__name__} timed out after {sec} seconds'
+
+            class FuncTimeoutError(TimeoutError):
+                def __init__(self):
+                    TimeoutError.__init__(self, err_msg)
+
+            result, exception = [], []
+
+            def run_func():
+                try:
+                    res = func(*args, **kwargs)
+                except FuncTimeoutError:
+                    pass
+                except Exception as e:
+                    exception.append(e)
+                else:
+                    result.append(res)
+
+            # typically, a python thread cannot be terminated, use TerminableThread instead
+            thread = TerminableThread(target=run_func, daemon=True)
+            thread.start()
+            thread.join(timeout=sec)
+            if thread.is_alive():
+                # a timeout thread keeps alive after join method, terminate and raise TimeoutError
+                exc = type('TimeoutError', FuncTimeoutError.__bases__, dict(FuncTimeoutError.__dict__))
+                thread.terminate(exception_cls=FuncTimeoutError, repeat_sec=raise_sec)
+                raise TimeoutError(err_msg)
+            elif exception:
+                # if exception occurs during the thread running, raise it
+                raise exception[0]
+            else:
+                # if the thread successfully finished, return its results
+                return result[0]
+
+        return wrapped_func
+
+    return decorator