rushlib 0.1.0__tar.gz

rushlib-0.1.0/LICENSE.txt

@@ -0,0 +1,21 @@
+GPL-3.0 License
+
+Copyright (c) 2025 [Ndrzy]
+
+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.

rushlib-0.1.0/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: rushlib
+Version: 0.1.0
+Summary: python lib
+Home-page: https://github.com/meatdumplings0019/rushlib
+Author: ndrzy
+Author-email: dandan0019@outlook.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires: colorama
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires
+Dynamic: requires-python
+Dynamic: summary
+
+# RushLib

rushlib-0.1.0/README.md

@@ -0,0 +1 @@
+# RushLib

rushlib-0.1.0/rushlib/__init__.py

@@ -0,0 +1,6 @@
+import rushlib.color
+import rushlib.text
+import rushlib.args
+import rushlib.math
+import rushlib.message
+import rushlib.func

rushlib-0.1.0/rushlib/args.py

@@ -0,0 +1,12 @@
+import argparse
+
+from typing import Optional
+
+def parse_args(tokens: list[str], parser: argparse.ArgumentParser) -> Optional[argparse.Namespace]:
+    try:
+        return parser.parse_args(tokens)
+    except SystemExit:
+        return None
+    except Exception as e:
+        print(f"参数解析错误: {str(e)}")
+        return None

rushlib-0.1.0/rushlib/color/__init__.py

@@ -0,0 +1,203 @@
+from rushlib.color._console import *
+from rushlib.color.util import *
+
+
+class MColor:
+    CONSOLE_COLOR = ForeWhite()
+
+    def __init__(self, r: int = 255, g: int = 255, b: int = 255, a: int = 255):
+        """
+        增强版的Color, 支持rgb转hex, 可以直接作为pygame的Color
+        :param r: R
+        :param g: G
+        :param b: B
+        :param a: A
+        """
+        self._r, self._g, self._b, self._a = self.vali_rgba(r, g, b, a)
+
+    @staticmethod
+    def from_hex(hex_str: str = "#FFFFFF"):
+        """
+        将16进制颜色代码转为MColor
+        :param hex_str: 16进制string
+        :return: new MColor
+        """
+        r, g, b, a = hex_to_rgb(hex_str)
+        return MColor(r, g, b, a)
+
+    @staticmethod
+    def vali_rgba(r, g, b, a=255):
+        return vali_rgba(r, g, b, a)
+
+    @property
+    def r(self) -> int:
+        return self._r
+
+    @r.setter
+    def r(self, value: int) -> None:
+        if 0 < value <= 255:
+            self._r = value
+
+        self.r = 255
+
+    @property
+    def float_r(self) -> float:
+        return self.r / 255.0
+
+    @property
+    def g(self) -> int:
+        return self._g
+
+    @g.setter
+    def g(self, value: int) -> None:
+        if 0 < value <= 255:
+            self._g = value
+            return
+
+        self.g = 255
+
+    @property
+    def float_g(self) -> float:
+        return self.g / 255.0
+
+    @property
+    def b(self) -> int:
+        return self._b
+
+    @b.setter
+    def b(self, value: int) -> None:
+        if 0 < value <= 255:
+            self._b = value
+            return
+
+        self.b = 255
+
+    @property
+    def float_b(self) -> float:
+        return self.b / 255.0
+
+    @property
+    def a(self) -> int:
+        return self._a
+
+    @a.setter
+    def a(self, value: int) -> None:
+        if 0 < value <= 255:
+            self._a = value
+            return
+
+        self.a = 255
+
+    @property
+    def float_a(self) -> float:
+        return self.a / 255.0
+
+    @property
+    def rgb(self) -> tuple[int, int, int]:
+        return self.r, self.g, self.b
+
+    @property
+    def float_rgb(self) -> tuple[float, float, float]:
+        return self.float_r, self.float_g, self.float_b
+
+    @property
+    def rgba(self) -> tuple[int, int, int, int]:
+        return self.rgb[0], self.rgb[1], self.rgb[2], self.a
+
+    @property
+    def float_rgba(self) -> tuple[float, float, float, float]:
+        return self.float_rgb[0], self.float_rgb[1], self.float_rgb[2], self.float_a
+
+    @property
+    def hex(self) -> str:
+        return rgb_to_hex(self.r, self.g, self.b)
+
+    def __iter__(self):
+        yield self.r
+        yield self.g
+        yield self.b
+        yield self.a
+
+    def __len__(self):
+        return 4
+
+    def __getitem__(self, item):
+        prop = self.r, self.g, self.b, self.a
+
+        return prop[item]
+
+    def __add__(self, other):
+        if isinstance(other, MColor):
+            r, g, b, a = other
+            return MColor(self.r + r, self.g + g, self.b + b, self.a + a)
+
+        raise TypeError(other)
+
+    def __sub__(self, other):
+        if isinstance(other, MColor):
+            r, g, b, a = other
+            return MColor(self.r - r, self.g - g, self.b - b, self.a - a)
+
+        raise TypeError(other)
+
+    def __repr__(self):
+        return f"[MColor r={self.r} g={self.g} b={self.b} a={self.a}]"
+
+    def __str__(self):
+        return f'{self.CONSOLE_COLOR}'
+
+
+class Black(MColor):
+    CONSOLE_COLOR = ForeBlack()
+
+    def __init__(self, a: int = 255):
+        super().__init__(0, 0, 0, a)
+
+
+class Red(MColor):
+    CONSOLE_COLOR = ForeRed()
+
+    def __init__(self, a: int = 255):
+        super().__init__(255, 0, 0, a)
+
+
+class Green(MColor):
+    CONSOLE_COLOR = ForeGreen()
+
+    def __init__(self, a: int = 255):
+        super().__init__(0, 255, 0, a)
+
+
+class Yellow(MColor):
+    CONSOLE_COLOR = ForeYellow()
+
+    def __init__(self, a: int = 255):
+        super().__init__(255, 255, 0, a)
+
+
+class Blue(MColor):
+    CONSOLE_COLOR = ForeBlue()
+
+    def __init__(self, a: int = 255):
+        super().__init__(0, 0, 255, a)
+
+
+class Magenta(MColor):
+    CONSOLE_COLOR = ForeMagenta()
+
+    def __init__(self, a: int = 255):
+        super().__init__(255, 0, 255, a)
+
+
+class Cyan(MColor):
+    CONSOLE_COLOR = ForeCyan()
+
+    def __init__(self, a: int = 255):
+        super().__init__(0, 255, 255, a)
+
+
+class White(MColor):
+    CONSOLE_COLOR = ForeWhite()
+
+    def __init__(self, a: int = 255):
+        super().__init__(255, 255, 255, a)

rushlib-0.1.0/rushlib/color/_console/__init__.py

@@ -0,0 +1,53 @@
+from colorama import Fore
+
+
+class ConsoleColor:
+    def __init__(self, fore):
+        self._fore = fore
+
+    @property
+    def fore(self):
+        return self._fore
+
+    def __str__(self):
+        return self.fore
+
+
+class ForeBlack(ConsoleColor):
+    def __init__(self):
+        super().__init__(Fore.BLACK)
+
+
+class ForeRed(ConsoleColor):
+    def __init__(self):
+        super().__init__(Fore.RED)
+
+
+class ForeGreen(ConsoleColor):
+    def __init__(self):
+        super().__init__(Fore.GREEN)
+
+
+class ForeYellow(ConsoleColor):
+    def __init__(self):
+        super().__init__(Fore.YELLOW)
+
+
+class ForeBlue(ConsoleColor):
+    def __init__(self):
+        super().__init__(Fore.BLUE)
+
+
+class ForeMagenta(ConsoleColor):
+    def __init__(self):
+        super().__init__(Fore.MAGENTA)
+
+
+class ForeCyan(ConsoleColor):
+    def __init__(self):
+        super().__init__(Fore.CYAN)
+
+
+class ForeWhite(ConsoleColor):
+    def __init__(self):
+        super().__init__(Fore.WHITE)

rushlib-0.1.0/rushlib/color/util.py

@@ -0,0 +1,40 @@
+def vali_rgba(r, g, b, a=255):
+    return (
+        min(255, max(0, r)),
+        min(255, max(0, g)),
+        min(255, max(0, b)),
+        min(255, max(0, a))
+    )
+
+def hex_to_rgb(hex_str: str) -> tuple[int, int, int, int]:
+    r, g, b, a = 0, 0, 0, 255
+
+    hex_str = hex_str.lstrip('#')
+
+    if len(hex_str) not in (3, 4, 6, 8):
+        raise ValueError("十六进制颜色代码必须是3, 4, 6或8个字符")
+
+    if len(hex_str) == 3:
+        hex_str = ''.join([c * 2 for c in hex_str])
+    elif len(hex_str) == 4:
+        hex_str = ''.join([c * 2 for c in hex_str])
+        alpha_hex = hex_str[6:8]
+        a = int(alpha_hex, 16)
+        hex_str = hex_str[0:6]
+
+    if len(hex_str) == 8:
+        alpha_hex = hex_str[6:8]
+        a = int(alpha_hex, 16)
+        hex_str = hex_str[0:6]
+
+    try:
+        r = int(hex_str[0:2], 16)
+        g = int(hex_str[2:4], 16)
+        b = int(hex_str[4:6], 16)
+    except ValueError:
+        raise ValueError("无效的十六进制颜色代码")
+
+    return r, g, b, a
+
+def rgb_to_hex(r, g, b) -> str:
+    return '#%02x%02x%02x' % vali_rgba(r, g, b)[0:3]

rushlib-0.1.0/rushlib/func.py

@@ -0,0 +1,83 @@
+import inspect
+from inspect import Parameter
+from functools import wraps
+from typing import Callable, Any
+
+
+def smart_call(func: Callable, *args: Any, **kwargs: Any) -> Any:
+    """
+    智能调用函数，根据目标函数的参数签名自动匹配传入的参数
+
+    :param func: 要调用的目标函数
+    :param *args: 位置参数
+    :param **kwargs: 关键字参数
+
+    :return: 目标函数的执行结果
+    """
+    try:
+        # 获取函数签名
+        sig = inspect.signature(func)
+    except (ValueError, TypeError):
+        # 无法获取签名时直接尝试调用
+        return func(*args, **kwargs)
+
+    # 准备参数绑定
+    bound_args = {}
+    params = sig.parameters
+
+    # 处理位置参数
+    args_iter = iter(args)
+    for name, param in params.items():
+        if param.kind in (Parameter.POSITIONAL_ONLY,
+                          Parameter.POSITIONAL_OR_KEYWORD,
+                          Parameter.KEYWORD_ONLY):
+            # 尝试从位置参数获取值
+            if args_iter:
+                try:
+                    bound_args[name] = next(args_iter)
+                    continue
+                except StopIteration:
+                    pass
+
+            # 如果位置参数用完，尝试从关键字参数获取
+            if name in kwargs:
+                bound_args[name] = kwargs[name]
+            elif param.default is not Parameter.empty:
+                # 使用默认值
+                bound_args[name] = param.default
+            else:
+                # 必需参数缺失
+                raise TypeError(f"Missing required argument: {name}")
+
+        elif param.kind == Parameter.VAR_POSITIONAL:
+            # 处理 *args 参数
+            bound_args[name] = tuple(args_iter)
+            args_iter = None  # 标记位置参数已耗尽
+
+    # 处理剩余的关键字参数
+    for name, param in params.items():
+        if param.kind == Parameter.VAR_KEYWORD:
+            # 处理 **kwargs 参数
+            bound_args[name] = {
+                k: v for k, v in kwargs.items()
+                if k not in bound_args
+            }
+            break
+        elif name not in bound_args and param.kind == Parameter.KEYWORD_ONLY:
+            # 处理仅关键字参数
+            if name in kwargs:
+                bound_args[name] = kwargs[name]
+            elif param.default is not Parameter.empty:
+                bound_args[name] = param.default
+            else:
+                raise TypeError(f"Missing required keyword argument: {name}")
+
+    return func(**bound_args)
+
+
+def adapt_args(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        return smart_call(func, *args, **kwargs)
+
+    return wrapper

rushlib-0.1.0/rushlib/math.py

@@ -0,0 +1,309 @@
+import math
+from typing import Union
+
+Number = Union[int, float]
+
+
+class Vector2:
+    """二维向量类"""
+
+    __slots__ = ('x', 'y')
+
+    def __init__(self, x: Number = 0, y: Number = 0):
+        self.x = float(x)
+        self.y = float(y)
+
+    def __repr__(self) -> str:
+        return f"Vec2({self.x}, {self.y})"
+
+    def __str__(self) -> str:
+        return f"({self.x}, {self.y})"
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Vector2):
+            return False
+        return math.isclose(self.x, other.x) and math.isclose(self.y, other.y)
+
+    def __ne__(self, other: object) -> bool:
+        return not self.__eq__(other)
+
+    def __hash__(self) -> int:
+        return hash((self.x, self.y))
+
+    def __add__(self, other: 'Vector2') -> 'Vector2':
+        return Vector2(self.x + other.x, self.y + other.y)
+
+    def __sub__(self, other: 'Vector2') -> 'Vector2':
+        return Vector2(self.x - other.x, self.y - other.y)
+
+    def __mul__(self, scalar: Number) -> 'Vector2':
+        return Vector2(self.x * scalar, self.y * scalar)
+
+    def __rmul__(self, scalar: Number) -> 'Vector2':
+        return self.__mul__(scalar)
+
+    def __truediv__(self, scalar: Number) -> 'Vector2':
+        if abs(scalar) < 1e-10:
+            raise ZeroDivisionError("Division by near-zero scalar")
+        return Vector2(self.x / scalar, self.y / scalar)
+
+    def __neg__(self) -> 'Vector2':
+        return Vector2(-self.x, -self.y)
+
+    def __abs__(self) -> float:
+        return math.sqrt(self.x * self.x + self.y * self.y)
+
+    def dot(self, other: 'Vector2') -> float:
+        """点积"""
+        return self.x * other.x + self.y * other.y
+
+    def cross(self, other: 'Vector2') -> float:
+        """叉积（标量）"""
+        return self.x * other.y - self.y * other.x
+
+    def length(self) -> float:
+        """向量长度"""
+        return abs(self)
+
+    def length_squared(self) -> float:
+        """向量长度的平方"""
+        return self.x * self.x + self.y * self.y
+
+    def normalized(self) -> 'Vector2':
+        """单位向量"""
+        length = self.length()
+        if length < 1e-10:
+            return Vector2(0, 0)
+        return self / length
+
+    def normalize(self) -> None:
+        """将向量单位化（原地操作）"""
+        length = self.length()
+        if length < 1e-10:
+            self.x, self.y = 0, 0
+        else:
+            self.x /= length
+            self.y /= length
+
+    def distance_to(self, other: 'Vector2') -> float:
+        """到另一个向量的距离"""
+        return (self - other).length()
+
+    def angle(self) -> float:
+        """向量的角度（弧度）"""
+        return math.atan2(self.y, self.x)
+
+    def rotated(self, angle: float) -> 'Vector2':
+        """旋转指定弧度后的向量"""
+        cos_a = math.cos(angle)
+        sin_a = math.sin(angle)
+        return Vector2(
+            self.x * cos_a - self.y * sin_a,
+            self.x * sin_a + self.y * cos_a
+        )
+
+    def rotate(self, angle: float) -> None:
+        """旋转指定弧度（原地操作）"""
+        cos_a = math.cos(angle)
+        sin_a = math.sin(angle)
+        x = self.x * cos_a - self.y * sin_a
+        y = self.x * sin_a + self.y * cos_a
+        self.x, self.y = x, y
+
+    def lerp(self, other: 'Vector2', t: float) -> 'Vector2':
+        """线性插值"""
+        t = max(0.0, min(1.0, t))  # 限制t在[0,1]范围内
+        return Vector2(
+            self.x + (other.x - self.x) * t,
+            self.y + (other.y - self.y) * t
+        )
+
+    def copy(self) -> 'Vector2':
+        """返回向量的副本"""
+        return Vector2(self.x, self.y)
+
+    @classmethod
+    def from_angle(cls, angle: float, length: float = 1.0) -> 'Vector2':
+        """从角度和长度创建向量"""
+        return cls(math.cos(angle) * length, math.sin(angle) * length)
+
+    @classmethod
+    def zero(cls) -> 'Vector2':
+        """零向量"""
+        return cls(0, 0)
+
+    @classmethod
+    def one(cls) -> 'Vector2':
+        """全1向量"""
+        return cls(1, 1)
+
+    @classmethod
+    def up(cls) -> 'Vector2':
+        """上向量"""
+        return cls(0, 1)
+
+    @classmethod
+    def down(cls) -> 'Vector2':
+        """下向量"""
+        return cls(0, -1)
+
+    @classmethod
+    def left(cls) -> 'Vector2':
+        """左向量"""
+        return cls(-1, 0)
+
+    @classmethod
+    def right(cls) -> 'Vector2':
+        """右向量"""
+        return cls(1, 0)
+
+
+class Vector3:
+    """三维向量类"""
+
+    __slots__ = ('x', 'y', 'z')
+
+    def __init__(self, x: Number = 0, y: Number = 0, z: Number = 0):
+        self.x = float(x)
+        self.y = float(y)
+        self.z = float(z)
+
+    def __repr__(self) -> str:
+        return f"Vec3({self.x}, {self.y}, {self.z})"
+
+    def __str__(self) -> str:
+        return f"({self.x}, {self.y}, {self.z})"
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Vector3):
+            return False
+        return (math.isclose(self.x, other.x) and
+                math.isclose(self.y, other.y) and
+                math.isclose(self.z, other.z))
+
+    def __ne__(self, other: object) -> bool:
+        return not self.__eq__(other)
+
+    def __hash__(self) -> int:
+        return hash((self.x, self.y, self.z))
+
+    def __add__(self, other: 'Vector3') -> 'Vector3':
+        return Vector3(self.x + other.x, self.y + other.y, self.z + other.z)
+
+    def __sub__(self, other: 'Vector3') -> 'Vector3':
+        return Vector3(self.x - other.x, self.y - other.y, self.z - other.z)
+
+    def __mul__(self, scalar: Number) -> 'Vector3':
+        return Vector3(self.x * scalar, self.y * scalar, self.z * scalar)
+
+    def __rmul__(self, scalar: Number) -> 'Vector3':
+        return self.__mul__(scalar)
+
+    def __truediv__(self, scalar: Number) -> 'Vector3':
+        if abs(scalar) < 1e-10:
+            raise ZeroDivisionError("Division by near-zero scalar")
+        return Vector3(self.x / scalar, self.y / scalar, self.z / scalar)
+
+    def __neg__(self) -> 'Vector3':
+        return Vector3(-self.x, -self.y, -self.z)
+
+    def __abs__(self) -> float:
+        return math.sqrt(self.x * self.x + self.y * self.y + self.z * self.z)
+
+    def dot(self, other: 'Vector3') -> float:
+        """点积"""
+        return self.x * other.x + self.y * other.y + self.z * other.z
+
+    def cross(self, other: 'Vector3') -> 'Vector3':
+        """叉积（向量）"""
+        return Vector3(
+            self.y * other.z - self.z * other.y,
+            self.z * other.x - self.x * other.z,
+            self.x * other.y - self.y * other.x
+        )
+
+    def length(self) -> float:
+        """向量长度"""
+        return abs(self)
+
+    def length_squared(self) -> float:
+        """向量长度的平方"""
+        return self.x * self.x + self.y * self.y + self.z * self.z
+
+    def normalized(self) -> 'Vector3':
+        """单位向量"""
+        length = self.length()
+        if length < 1e-10:
+            return Vector3(0, 0, 0)
+        return self / length
+
+    def normalize(self) -> None:
+        """将向量单位化（原地操作）"""
+        length = self.length()
+        if length < 1e-10:
+            self.x, self.y, self.z = 0, 0, 0
+        else:
+            self.x /= length
+            self.y /= length
+            self.z /= length
+
+    def distance_to(self, other: 'Vector3') -> float:
+        """到另一个向量的距离"""
+        return (self - other).length()
+
+    def lerp(self, other: 'Vector3', t: float) -> 'Vector3':
+        """线性插值"""
+        t = max(0.0, min(1.0, t))  # 限制t在[0,1]范围内
+        return Vector3(
+            self.x + (other.x - self.x) * t,
+            self.y + (other.y - self.y) * t,
+            self.z + (other.z - self.z) * t
+        )
+
+    def copy(self) -> 'Vector3':
+        """返回向量的副本"""
+        return Vector3(self.x, self.y, self.z)
+
+    @classmethod
+    def zero(cls) -> 'Vector3':
+        """零向量"""
+        return cls(0, 0, 0)
+
+    @classmethod
+    def one(cls) -> 'Vector3':
+        """全1向量"""
+        return cls(1, 1, 1)
+
+    @classmethod
+    def up(cls) -> 'Vector3':
+        """上向量"""
+        return cls(0, 1, 0)
+
+    @classmethod
+    def down(cls) -> 'Vector3':
+        """下向量"""
+        return cls(0, -1, 0)
+
+    @classmethod
+    def left(cls) -> 'Vector3':
+        """左向量"""
+        return cls(-1, 0, 0)
+
+    @classmethod
+    def right(cls) -> 'Vector3':
+        """右向量"""
+        return cls(1, 0, 0)
+
+    @classmethod
+    def forward(cls) -> 'Vector3':
+        """前向量"""
+        return cls(0, 0, 1)
+
+    @classmethod
+    def back(cls) -> 'Vector3':
+        """后向量"""
+        return cls(0, 0, -1)
+
+
+vec2 = Vector2
+vec3 = Vector3

rushlib-0.1.0/rushlib/message.py

@@ -0,0 +1,22 @@
+from typing import TypeVar, Generic
+
+from rushlib.text import Error
+
+T = TypeVar('T')
+
+class Message(Generic[T]):
+    def __init__(self, var: T, msg: Exception | str | Error = None):
+        self.var: T = var
+
+        if isinstance(msg, Error):
+            tmp = msg
+        elif isinstance(msg, (self, Exception)):
+            tmp = Error(msg)
+        else:
+            raise TypeError(msg)
+
+        self.msg: Error = tmp
+
+    def __iter__(self):
+        yield self.var
+        yield self.msg

rushlib-0.1.0/rushlib/text.py

@@ -0,0 +1,64 @@
+from colorama import Style
+
+from rushlib.color import MColor, White, Red, Yellow
+
+
+class Text:
+    def __init__(self, text="", color: MColor = White()):
+        self._text = text
+        self._color = color
+
+    def sub_string(self, start: int, end: int) -> str:
+        return self.text[start:end]
+
+    @property
+    def text(self):
+        return self._text
+
+    @text.setter
+    def text(self, text):
+        self._text = text
+
+    @property
+    def color(self):
+        return self._color
+
+    @color.setter
+    def color(self, color):
+        self._color = color
+
+    def __add__(self, other):
+        if isinstance(other, Text):
+            return Text(self.text + other.text, self.color)
+
+        if isinstance(other, str):
+            return Text(self.text + other, self.color)
+
+        raise TypeError(other)
+
+    def __len__(self):
+        return len(self.text)
+
+    def __getitem__(self, item):
+        return self.text[item]
+
+    def __iter__(self):
+        return self.text.__iter__()
+
+    def __str__(self):
+        return f'{self.color}{self.text}{Style.RESET_ALL}'
+
+
+class Error(Text):
+    def __init__(self, text):
+        super().__init__(text, Red())
+
+
+class Info(Text):
+    def __init__(self, text):
+        super().__init__(text, White())
+
+
+class Warn(Text):
+    def __init__(self, text):
+        super().__init__(text, Yellow())

rushlib-0.1.0/rushlib.egg-info/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: rushlib
+Version: 0.1.0
+Summary: python lib
+Home-page: https://github.com/meatdumplings0019/rushlib
+Author: ndrzy
+Author-email: dandan0019@outlook.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires: colorama
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires
+Dynamic: requires-python
+Dynamic: summary
+
+# RushLib

rushlib-0.1.0/rushlib.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE.txt
+README.md
+setup.py
+rushlib/__init__.py
+rushlib/args.py
+rushlib/func.py
+rushlib/math.py
+rushlib/message.py
+rushlib/text.py
+rushlib.egg-info/PKG-INFO
+rushlib.egg-info/SOURCES.txt
+rushlib.egg-info/dependency_links.txt
+rushlib.egg-info/top_level.txt
+rushlib/color/__init__.py
+rushlib/color/util.py
+rushlib/color/_console/__init__.py

rushlib-0.1.0/rushlib.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rushlib-0.1.0/rushlib.egg-info/top_level.txt

@@ -0,0 +1 @@
+rushlib

rushlib-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rushlib-0.1.0/setup.py

@@ -0,0 +1,26 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf8") as fh:
+    long_description = fh.read()
+
+setup(
+    name='rushlib',
+    version='0.1.0',
+    packages=find_packages(),
+    requires=[
+        'colorama'
+    ],
+    description='python lib',
+    author='ndrzy',
+    author_email='dandan0019@outlook.com',
+    python_requires='>=3.10',
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/meatdumplings0019/rushlib",
+
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ]
+)