maque 0.2.1__py3-none-any.whl

maque/utils/constant.py

@@ -0,0 +1,183 @@
+BLUE_E = "#1C758A"
+BLUE_D = "#29ABCA"
+BLUE_C = "#58C4DD"
+BLUE_B = "#9CDCEB"
+BLUE_A = "#C7E9F1"
+TEAL_E = "#49A88F"
+TEAL_D = "#55C1A7"
+TEAL_C = "#5CD0B3"
+TEAL_B = "#76DDC0"
+TEAL_A = "#ACEAD7"
+GREEN_E = "#699C52"
+GREEN_D = "#77B05D"
+GREEN_C = "#83C167"
+GREEN_B = "#A6CF8C"
+GREEN_A = "#C9E2AE"
+YELLOW_E = "#E8C11C"
+YELLOW_D = "#F4D345"
+YELLOW_C = "#FFFF00"
+YELLOW_B = "#FFEA94"
+YELLOW_A = "#FFF1B6"
+GOLD_E = "#C78D46"
+GOLD_D = "#E1A158"
+GOLD_C = "#F0AC5F"
+GOLD_B = "#F9B775"
+GOLD_A = "#F7C797"
+RED_E = "#CF5044"
+RED_D = "#E65A4C"
+RED_C = "#FC6255"
+RED_B = "#FF8080"
+RED_A = "#F7A1A3"
+MAROON_E = "#94424F"
+MAROON_D = "#A24D61"
+MAROON_C = "#C55F73"
+MAROON_B = "#EC92AB"
+MAROON_A = "#ECABC1"
+PURPLE_E = "#644172"
+PURPLE_D = "#715582"
+PURPLE_C = "#9A72AC"
+PURPLE_B = "#B189C6"
+PURPLE_A = "#CAA3E8"
+GREY_E = "#222222"
+GREY_D = "#444444"
+GREY_C = "#888888"
+GREY_B = "#BBBBBB"
+GREY_A = "#DDDDDD"
+WHITE = "#FFFFFF"
+BLACK = "#000000"
+GREY_BROWN = "#736357"
+DARK_BROWN = "#8B4513"
+LIGHT_BROWN = "#CD853F"
+PINK = "#D147BD"
+LIGHT_PINK = "#DC75CD"
+GREEN_SCREEN = "#00FF00"
+ORANGE = "#FF862F"
+
+# Abbreviated names for the "median" colors
+BLUE = BLUE_C
+TEAL = TEAL_C
+GREEN = GREEN_C
+YELLOW = YELLOW_C
+GOLD = GOLD_C
+RED = RED_C
+MAROON = MAROON_C
+PURPLE = PURPLE_C
+GREY = GREY_C
+
+# ---------------------------
+red_lighter = "#FFEBEE"
+red_light = "#EF9A9A"
+red = "#EF5350"
+red_dark = "#E53935"
+red_darker = "#C62828"
+
+pink_lighter = "#FCE4EC"
+pink_light = "#F48FB1"
+pink = "#EC407A"
+pink_dark = "#D81B60"
+pink_darker = "#AD1457"
+
+purple_lighter = "#F3E5F5"
+purple_light = "#CE93D8"
+purple = "#AB47BC"
+purple_dark = "#8E24AA"
+purple_darker = "#6A1B9A"
+
+deep_purple_lighter = "#EDE7F6"
+deep_purple_light = "#B39DDB"
+deep_purple = "#7E57C2"
+deep_purple_dark = "#5E35B1"
+deep_purple_darker = "#4527A0"
+
+indigo_lighter = "#E8EAF6"
+indigo_light = "#9FA8DA"
+indigo = "#5C6BC0"
+indigo_dark = "#3949AB"
+indigo_darker = "#283593"
+
+blue_lighter = "#E3F2FD"
+blue_light = "#90CAF9"
+blue = "#42A5F5"
+blue_dark = "#1E88E5"
+blue_darker = "#1565C0"
+
+light_blue_lighter = "#E1F5FE"
+light_blue_light = "#81D4FA"
+light_blue = "#29B6F6"
+light_blue_dark = "#039BE5"
+light_blue_darker = "#0277BD"
+
+cyan_lighter = "#E0F7FA"
+cyan_light = "#80DEEA"
+cyan = "#26C6DA"
+cyan_dark = "#00ACC1"
+cyan_darker = "#00838F"
+
+teal_lighter = "#E0F2F1"
+teal_light = "#80CBC4"
+teal = "#26A69A"
+teal_dark = "#00897B"
+teal_darker = "#00695C"
+
+green_lighter = "#E8F5E9"
+green_light = "#A5D6A7"
+green = "#66BB6A"
+green_dark = "#43A047"
+green_darker = "#2E7D32"
+
+light_green_lighter = "#F1F8E9"
+light_green_light = "#C5E1A5"
+light_green = "#9CCC65"
+light_green_dark = "#7CB342"
+light_green_darker = "#558B2F"
+
+lime_lighter = "#F9FBE7"
+lime_light = "#E6EE9C"
+lime = "#D4E157"
+lime_dark = "#C0CA33"
+lime_darker = "#9E9D24"
+
+yellow_lighter = "#FFFDE7"
+yellow_light = "#FFF59D"
+yellow = "#FFEE58"
+yellow_dark = "#FDD835"
+yellow_darker = "#F9A825"
+
+amber_lighter = "#FFF8E1"
+amber_light = "#FFE082"
+amber = "#FFCA28"
+amber_dark = "#FFB300"
+amber_darker = "#FF8F00"
+
+orange_lighter = "#FFF3E0"
+orange_light = "#FFCC80"
+orange = "#FFA726"
+orange_dark = "#FB8C00"
+orange_darker = "#EF6C00"
+
+salmon_lighter = "#FBE9E7"
+salmon_light = "#FFAB91"
+salmon = "#FF7043"
+salmon_dark = "#F4511E"
+salmon_darker = "#D84315"
+
+brown_lighter = "#EFEBE9"
+brown_light = "#BCAAA4"
+brown = "#8D6E63"
+brown_dark = "#6D4C41"
+brown_darker = "#4E342E"
+
+grey_lighter = "#FAFAFA"
+grey_light = "#EEEEEE"
+grey = "#BDBDBD"
+grey_dark = "#757575"
+grey_darker = "#424242"
+
+blue_grey_lighter = "#ECEFF1"
+blue_grey_light = "#B0BEC5"
+blue_grey = "#78909C"
+blue_grey_dark = "#546E7A"
+blue_grey_darker = "#37474F"
+
+black = "#000000"
+white = "#FFFFFF"

maque/utils/core.py

@@ -0,0 +1,261 @@
+from .color_string import rgb_string, color_const
+from functools import wraps, update_wrapper
+import asyncio
+import logging
+import inspect
+import time
+from typing import Union
+
+
+def async_retry(
+        retry_times: int = 3,
+        retry_delay: float = 1.0,
+        exceptions: tuple = (Exception,),
+        logger = None,
+):
+    """
+    异步重试装饰器
+
+    Args:
+        retry_times: 最大重试次数
+        retry_delay: 重试间隔时间(秒)
+        exceptions: 需要重试的异常类型
+        logger: 日志记录器
+    """
+    if logger is None:
+        from loguru import logger
+
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            for attempt in range(retry_times):
+                try:
+                    return await func(*args, **kwargs)
+                except exceptions as e:
+                    if attempt == retry_times - 1:
+                        raise
+                    logger.warning(f"Attempt {attempt + 1} failed: {str(e)}")
+                    await asyncio.sleep(retry_delay)
+            return await func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def benchmark(times=10, logger=None, level=logging.INFO):
+    # if func is None:
+    #     return partial(time_it, times=times)
+    def decorate(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            start = time.time()
+            value = None
+            for i in range(times):
+                value = func(*args, **kwargs)
+            end = time.time()
+            average_cost_time = (end - start) / times
+            time_str = f"{average_cost_time:.3f}"
+
+            if logger:
+                logger.log(
+                    level,
+                    f"Run {rgb_string(str(times), color_const.GREEN)} times, "
+                    f"the average time is {rgb_string(time_str, color_const.GREEN)} seconds."
+                )
+            else:
+                print(
+                    f"Run {rgb_string(str(times), color_const.GREEN)} times, "
+                    f"the average time is {rgb_string(time_str, color_const.GREEN)} seconds."
+                )
+            return value
+
+        return wrapper
+
+    return decorate
+
+
+def measure_time(logger=None, level=logging.INFO):
+    def decorate(func):
+        """Log the runtime of the decorated function."""
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            start = time.time()
+            value = func(*args, **kwargs)
+            end = time.time()
+            cost_time = end - start
+            time_str = f"{cost_time:.3f}"
+            if logger:
+                logger.log(level,
+                           f"Finished {rgb_string(func.__name__, color_const.RED)} in {rgb_string(time_str, color_const.GREEN)} secs."
+                           )
+            else:
+                print(f"Finished {rgb_string(func.__name__, color_const.RED)} in {rgb_string(time_str, color_const.GREEN)} secs.")
+            return value
+
+        return wrapper
+
+    return decorate
+
+
+def repeat(n=2):
+    """repeat decorated function `n` times."""
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            result = None
+            for i in range(n):
+                result = func(*args, **kwargs)
+            return result
+
+        return wrapper
+
+    return decorator
+
+
+def optional_debug(func):
+    if "debug" in inspect.signature(func).parameters:
+        raise TypeError("debug argument already defined")
+
+    debug_default = True
+
+    @wraps(func)
+    def wrapper(*args, debug=debug_default, **kwargs):
+        if debug:
+            args_repr = [repr(a) for a in args]
+            kwargs_repr = [f"{k}={v!r}" for k, v in kwargs.items()]
+            signature = ", ".join(args_repr + kwargs_repr)
+            print(f"Calling '{func.__name__}({signature})'")
+        value = func(*args, **kwargs)
+        if debug:
+            print(f"{func.__name__!r} returned {value!r}")
+        return value
+
+    sig = inspect.signature(func)
+    parms = list(sig.parameters.values())
+    parms.append(
+        inspect.Parameter(
+            "debug", inspect.Parameter.KEYWORD_ONLY, default=debug_default
+        )
+    )
+    wrapper.__signature__ = sig.replace(parameters=parms)
+    return wrapper
+
+
+def count_calls(func):
+    """Count the number of calls made to the decorated function."""
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        wrapper.num_calls += 1
+        print(f"Call {wrapper.num_calls} of {func.__name__!r}")
+        return func(*args, **kwargs)
+
+    wrapper.num_calls = 0
+    return wrapper
+
+
+class CountCalls:
+    """Count the number of calls made to the decorated function."""
+
+    def __init__(self, func):
+        update_wrapper(self, func)
+        self.func = func
+        self.num_calls = 0
+
+    def __call__(self, *args, **kwargs):
+        self.num_calls += 1
+        print(f"Call {self.num_calls} of {self.func.__name__!r}")
+        return self.func(*args, **kwargs)
+
+
+class CallReminder:
+    def __init__(self, func):
+        self._func = func
+        self._num_calls = 0
+
+    def __call__(self, *args, **kwargs):
+        self._num_calls += 1
+        return self._func(*args, **kwargs)
+
+    @property
+    def count_calls(self):
+        return self._num_calls
+
+
+def logged(level, name=None, message=None):
+    """
+    Add logging to a function. level is the logging
+    level, name is the logger name, and message is the
+    log message. If name and message aren't specified,
+    they default to the function's module and name.
+    """
+
+    def decorate(func):
+        logname = name if name else func.__module__
+        log = logging.getLogger(logname)
+        logmsg = message if message else func.__name__
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            log.log(level, logmsg)
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorate
+
+
+def singleton(cls):
+    """
+    Usage
+    -----
+        @singleton
+        class Cls:
+            pass
+    """
+    _instance = {}
+
+    def inner():
+        if cls not in _instance:
+            _instance[cls] = cls()
+        return _instance[cls]
+
+    return inner
+
+
+class Singleton:
+    """
+    Usage
+    -----
+        @Singleton
+        class Cls:
+            pass
+    """
+
+    def __init__(self, cls):
+        self._cls = cls
+        self._instance = {}
+
+    def __call__(self):
+        if self._cls not in self._instance:
+            self._instance[self._cls] = self._cls()
+        return self._instance[self._cls]
+
+
+class MetaSingleton(type):
+    """
+    Usage
+    -----
+        class Cls(metaclass=MetaSingleton):
+            pass
+    """
+
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(MetaSingleton, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]

maque/utils/cursor.py

@@ -0,0 +1,143 @@
+import abc
+import sys
+
+CSI = '\033['
+OSC = '\033]'
+OFF = CSI + '0m'
+
+
+class BaseCursor(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def FORWARD(self, *args, **kwargs):
+        '''Forward move'''
+        pass
+
+    @abc.abstractmethod
+    def BACK(self, *args, **kwargs):
+        '''Backward move'''
+        pass
+
+    @abc.abstractmethod
+    def PreLINE(self, *args, **kwargs):
+        """Moves cursor to beginning of the line n (default 1) lines up.
+        No any character will be cleared.
+        """
+        pass
+
+    @abc.abstractmethod
+    def EraseLine(self, *args, **kwargs):
+        """Erases part of the line.
+        If n is 0, clear from cursor to the end of the line.
+        If n is 1, clear from cursor to beginning of the line.
+        If n is 2, clear entire line. Cursor position does not change.
+        """
+        pass
+
+    # @abc.abstractmethod
+    # def EraseUpLine(self, *args, **kwargs):
+    #     """Erase n lines and cursor move up n lines"""
+    #     pass
+
+    @abc.abstractmethod
+    def savePOS_x(self, *args, **kwargs):
+        """Save current position"""
+        pass
+
+    @abc.abstractmethod
+    def restorePOS_x(self, *args, **kwargs):
+        """Restore saved position"""
+        pass
+
+    @abc.abstractmethod
+    def getPOS(self):
+        pass
+
+
+def send(code):
+    sys.stdout.write(code)
+    sys.stdout.flush()
+
+
+def csi(n, code):
+    return CSI + str(n) + code
+
+
+class Cursor(BaseCursor):
+    '''See: http://en.wikipedia.org/wiki/ANSI_escape_code'''
+
+    def UP(self, n=1):
+        """Moves the cursor n (default 1) cells in the given direction."""
+        return csi(n, 'A')
+
+    def DOWN(self, n=1):
+        """Moves the cursor n (default 1) cells in the given direction."""
+        return csi(n, 'B')
+
+    def FORWARD(self, n=1):
+        """Moves the cursor n (default 1) cells in the given direction."""
+        return csi(n, 'C')
+
+    def BACK(self, n=1):
+        """Moves the cursor n (default 1) cells in the given direction."""
+        return csi(n, 'D')
+
+    def NextLINE(self, n=1):
+        return csi(n, 'E')
+
+    def PreLINE(self, n=1):
+        """Moves cursor to beginning of the line n (default 1) lines up.
+        No any character are cleared.
+        """
+        return csi(n, 'F')
+
+    def HorizCol(self, n=1):
+        """Moves the cursor to column n"""
+        return csi(n, 'G')
+
+    def POS(self, x=1, y=1):
+        """Moves the cursor to row n, column m.
+        The values are 1-based, and default to 1 (top left corner) if omitted."""
+        return CSI + str(y) + ';' + str(x) + 'H'
+
+    def EraseLine(self, n=0):
+        """Erases part of the line.
+        If n is 0, clear from cursor to the end of the line.
+        If n is 1, clear from cursor to beginning of the line.
+        If n is 2, clear entire line. Cursor position does not change.
+        """
+        if n == 0:
+            return CSI + 'K'
+        else:
+            return csi(n, 'K')
+
+    def EraseDisplay(self, n=0):
+        """Clears part of the screen.
+        If n is 0, clear from cursor to end of screen.
+        If n is 1, clear from cursor to beginning of the screen.
+        If n is 2, clear entire screen (and moves cursor to upper left on DOS ANSI.SYS).
+        If n is 3, clear entire screen and delete all lines saved in the scrollback buffer.
+        """
+        return csi(n, 'J')
+
+    def ScrollUp(self, n=1):
+        """Scroll whole page up by n (default 1) lines.
+        New lines are added at the bottom.
+        """
+        return csi(n, "S")
+
+    def ScrollDown(self, n=0):
+        """Scroll whole page down by n (default 1) lines.
+        New lines are added at the top. """
+        return csi(n, "T")
+
+    def savePOS_x(self):
+        return "\033[s"  # "\0337"
+
+    def restorePOS_x(self):
+        return "\033[u"  # "\0338"
+
+    def getPOS(self):
+        return CSI + "6n"
+
+    def hiddenCursor(self):
+        return "\033[?25l"

maque/utils/distance.py

@@ -0,0 +1,58 @@
+import numpy as np
+from difflib import SequenceMatcher
+
+"""
+Some common distance function
+"""
+
+# 尝试导入 Levenshtein 库（更快），否则使用标准库 difflib
+try:
+    import Levenshtein as _Levenshtein
+    _USE_LEVENSHTEIN = True
+except ImportError:
+    _USE_LEVENSHTEIN = False
+
+
+def euclidean_dist(vec1, vec2):
+    assert vec1.shape == vec2.shape
+    return np.sqrt(np.sum((vec1 - vec2) ** 2))
+
+
+def manhattan_dist(vec1, vec2):
+    return np.sum(np.abs(vec1 - vec2))
+
+
+def chebyshev_dist(vec1, vec2):
+    return np.max(np.abs(vec1 - vec2))
+
+
+def minkowski_dist(vec1, vec2, p=2):
+    """
+    :param: `p` The meaning of norm.
+        p=1: dist = manhattan_dist
+        p=2: dist = euclidean_dist
+        p=inf: dist = chebyshev_dist
+    """
+    s = np.sum(np.power(vec2 - vec1, p))
+    return np.power(s, 1 / p)
+
+
+def cosine_dist(vec1, vec2, p=2):
+    # np.linalg.norm(vec, ord=1) 计算p=1范数,默认p=2
+    return (vec1.T @ vec2) / (np.linalg.norm(vec1, ord=p) * np.linalg.norm(vec2, ord=p))
+
+
+def distance(a, b):
+    """计算两个字符串的相似度 (0-1)，1表示完全相同"""
+    if _USE_LEVENSHTEIN:
+        return _Levenshtein.ratio(a, b)
+    else:
+        return SequenceMatcher(None, a, b).ratio()
+
+
+def hamming(x, y):
+    return np.sum(x != y) / len(x)
+
+
+def jaccard():
+    pass