gaskill 2.15.2__py3-none-any.whl

gaskill/__init__.py

@@ -0,0 +1,13 @@
+# ruff: noqa: F403
+from .gaskill import *
+from .plus import *
+print(r"""
+           _ _ _     
+ _ __ ___ | (_) |__  
+| '_ ` _ \| | | '_ \ 
+| | | | | | | | |_) |
+|_| |_| |_|_|_|_.__/ """)
+print("Hello from mlib. It isn't a serious library. Welcome to raise PRs. If you want to know the rules, please see PRlicense.")
+__PRlicense__ = "Do not use any C or Rust extensions, and ensure neither exists in the dependency tree."
+__license__ = "MIT"
+__author__ = "everyone"

gaskill/gaskill/__init__.py

@@ -0,0 +1,28 @@
+# ruff: noqa: F403
+from .smath import *
+from .sfrac import *
+from .svector import *
+from .smatrix import *
+from .squaternion import *
+from .srandom import *
+from .scolor import *
+from .sgeometry import *
+from .sgeometry3d import *
+from .scurve import *
+from .seasing import *
+from .sinterp import *
+from .scache import *
+from .sevent import *
+from .sfsm import *
+from .spool import *
+from .spathfinder import *
+from .ssaver import *
+from .sui import *
+from .sformat import *
+from .snoise import *
+from .scrypt import *
+from .solver import *
+from .sstat import *
+from .sbase64 import *
+from .abc import *
+from .pickle import *

gaskill/gaskill/_roll.py

@@ -0,0 +1,169 @@
+def parse_dice(expr):
+    expr = expr.replace(' ', '')
+
+    # 按加减号分割表达式
+    parts = _split_expression(expr)
+
+    result = {
+        'expr': expr,
+        'parts': [],
+        'total': 0
+    }
+
+    for part in parts:
+        if 'd' in part.lower():
+            part_result = _parse_single_dice(part)
+        else:
+            part_result = _parse_number(part)
+
+        result['parts'].append(part_result)
+        result['total'] += part_result['value']
+
+    return result
+
+
+def _split_expression(expr):
+    parts = []
+    current = ''
+
+    for i, char in enumerate(expr):
+        if char in '+-' and i > 0:
+            parts.append(current)
+            current = char
+        else:
+            current += char
+
+    if current:
+        parts.append(current)
+
+    return parts
+
+
+def _parse_single_dice(expr):
+    d_pos = expr.lower().find('d')
+
+    # 解析骰子数量
+    count_str = expr[:d_pos]
+    count = int(count_str) if count_str else 1
+
+    # 解析剩余部分
+    rest = expr[d_pos+1:]
+
+    # 初始化结果
+    result = {
+        'expr': expr,
+        'type': 'dice',
+        'count': count,
+        'sides': 0,
+        'modifier': None,
+        'modifier_value': 0,
+        'explode': None,
+        'bonus': 0,
+        'value': 0  # 占位，实际掷骰时计算
+    }
+
+    i = 0
+    # 读骰子面数
+    sides_str = ''
+    while i < len(rest) and rest[i].isdigit():
+        sides_str += rest[i]
+        i += 1
+
+    result['sides'] = int(sides_str)
+
+    # 读修饰符
+    if i < len(rest) and rest[i].isalpha():
+        mod = rest[i]
+        i += 1
+        if i < len(rest) and rest[i].isalpha():
+            mod += rest[i]
+            i += 1
+        result['modifier'] = mod
+
+        # 读修饰符数值
+        mod_val_str = ''
+        while i < len(rest) and rest[i].isdigit():
+            mod_val_str += rest[i]
+            i += 1
+        result['modifier_value'] = int(mod_val_str) if mod_val_str else 1
+
+    # 读爆炸骰
+    if i < len(rest) and rest[i] == 'x':
+        i += 1
+        explode_str = ''
+        while i < len(rest) and rest[i].isdigit():
+            explode_str += rest[i]
+            i += 1
+        result['explode'] = int(explode_str)
+
+    # 读加减
+    if i < len(rest) and rest[i] in '+-':
+        result['bonus'] = int(rest[i:])
+
+    return result
+
+
+def _parse_number(expr):
+    return {
+        'expr': expr,
+        'type': 'number',
+        'value': int(expr)
+    }
+
+
+def roll_dice(parse_result, random_func):
+    if parse_result['type'] == 'number':
+        return parse_result['value']
+
+    # 先掷出所有骰子
+    rolls = [random_func(1, parse_result['sides'])
+             for _ in range(parse_result['count'])]
+
+    # 应用爆炸骰
+    if parse_result['explode']:
+        rolls = _apply_explode(rolls, parse_result['sides'],
+                               parse_result['explode'], random_func)
+
+    # 应用修饰符
+    if parse_result['modifier'] == 'kh':
+        rolls = sorted(rolls, reverse=True)[:parse_result['modifier_value']]
+    elif parse_result['modifier'] == 'kl':
+        rolls = sorted(rolls)[:parse_result['modifier_value']]
+    elif parse_result['modifier'] == 'd':
+        rolls = sorted(rolls)[parse_result['modifier_value']:]
+
+    return sum(rolls) + parse_result['bonus']
+
+
+def _apply_explode(rolls, sides, target, random_func):
+    """递归应用爆炸骰"""
+    result = rolls.copy()
+    for roll in rolls:
+        if roll == target:
+            extra = random_func(1, sides)
+            result.append(extra)
+            if extra == target:  # 递归爆炸
+                result.extend(_apply_explode([extra], sides, target, random_func))
+    return result
+
+
+def get_dice_info(expr):
+    result = parse_dice(expr)
+    info = {
+        'expr': expr,
+        'dice_count': 0,
+        'total_sides': 0,
+        'has_modifier': False,
+        'has_explode': False
+    }
+
+    for part in result['parts']:
+        if part['type'] == 'dice':
+            info['dice_count'] += part['count']
+            info['total_sides'] += part['sides'] * part['count']
+            if part['modifier']:
+                info['has_modifier'] = True
+            if part['explode']:
+                info['has_explode'] = True
+
+    return info

gaskill/gaskill/abc.py

@@ -0,0 +1,73 @@
+"""
+gaskill.abc - 抽象基类模块（零依赖）
+"""
+
+
+class ABCMeta(type):
+    """元类：自动收集抽象方法"""
+
+    def __new__(cls, name, bases, dct):
+        # 1. 从所有父类继承抽象方法
+        abstract_methods = set()
+        for base in bases:
+            if hasattr(base, '_abstract_methods'):
+                abstract_methods.update(base._abstract_methods)
+
+        # 2. 处理当前类定义的方法
+        for key, value in dct.items():
+            # 如果当前类显式定义了抽象方法（有 _is_abstract 标记）
+            if hasattr(value, '_is_abstract') and value._is_abstract:
+                abstract_methods.add(key)
+            else:
+                # 如果当前类定义了具体实现（没有 _is_abstract 标记）
+                # 并且该方法在抽象方法集合中，则移除（即实现了该抽象方法）
+                if key in abstract_methods:
+                    abstract_methods.remove(key)
+
+        # 3. 存储最终的抽象方法集合
+        dct['_abstract_methods'] = frozenset(abstract_methods)
+        return super().__new__(cls, name, bases, dct)
+
+    def __call__(cls, *args, **kwargs):
+        """实例化时检查抽象方法是否都已实现"""
+        if cls._abstract_methods:
+            methods = ', '.join(cls._abstract_methods)
+            raise TypeError(
+                f"Can't instantiate abstract class {cls.__name__} "
+                f"with abstract methods {methods}"
+            )
+        return super().__call__(*args, **kwargs)
+
+
+class ABC(metaclass=ABCMeta):
+    """抽象基类"""
+
+    def __init__(self):
+
+        if type(self) is ABC:
+            raise TypeError(
+                "Can't instantiate abstract class ABC with abstract methods")
+
+
+def abstractmethod(func):
+    """装饰器：标记抽象方法"""
+    func._is_abstract = True
+    return func
+
+
+def abstractclassmethod(func):
+    """装饰器：标记抽象类方法"""
+    func._is_abstract = True
+    return classmethod(func)
+
+
+def abstractstaticmethod(func):
+    """装饰器：标记抽象静态方法"""
+    func._is_abstract = True
+    return staticmethod(func)
+
+
+def abstractproperty(func):
+    """装饰器：标记抽象属性"""
+    func._is_abstract = True
+    return property(func)

gaskill/gaskill/builtins_plus.py

@@ -0,0 +1,73 @@
+from .abc import ABC, abstractmethod
+
+
+class Iterable(ABC):
+    @abstractmethod
+    def __iter__(self):
+        while False:
+            yield None
+
+    @classmethod
+    def __subclasshook__(cls, C):
+        if cls is Iterable:
+            if any("__iter__" in B.__dict__ for B in C.__mro__):
+                return True
+        return NotImplemented
+
+
+class DefaultDict:
+    """带默认值的字典"""
+
+    def __init__(self, default_factory=None, **kwargs):
+        self._data = {}
+        self._default_factory = default_factory
+        self.update(kwargs)
+
+    def __getitem__(self, key):
+        try:
+            return self._data[key]
+        except KeyError:
+            if self._default_factory is None:
+                raise
+            value = self._default_factory()
+            self._data[key] = value
+            return value
+
+    def __setitem__(self, key, value):
+        self._data[key] = value
+
+    def __delitem__(self, key):
+        del self._data[key]
+
+    def __iter__(self):
+        return iter(self._data)
+
+    def __len__(self):
+        return len(self._data)
+
+    def __repr__(self):
+        return f"DefaultDict({self._default_factory}, {self._data})"
+
+    def update(self, other):
+        self._data.update(other)
+
+    def get(self, key, default=None):
+        return self._data.get(key, default)
+
+    def pop(self, key, default=None):
+        return self._data.pop(key, default)
+
+    def keys(self):
+        return self._data.keys()
+
+    def values(self):
+        return self._data.values()
+
+    def items(self):
+        return self._data.items()
+
+    def copy(self):
+        return DefaultDict(self._default_factory, **self._data)
+
+    def clear(self):
+        self._data.clear()

gaskill/gaskill/pickle.py

@@ -0,0 +1,318 @@
+def pack_float(num):
+    """将浮点数转换为二进制表示"""
+
+    if num == 0:
+        if str(num) == "0.0":
+            return '0' * 64
+        else:
+            return '1' + '0' * 63
+
+    if num == float("inf") or num == float("-inf"):
+        return '0' + '1'*11 + '0'*52 if num > 0 else '1' + '1'*11 + '0'*52
+
+    if str(num) == 'nan':
+        return '0' + '1'*11 + '1' + '0'*51
+
+    sign = '0' if num > 0 else '1'
+    num = abs(num)
+
+    int_part = int(num)
+    frac_part = num - int_part
+
+    int_bits = []
+    if int_part == 0:
+        int_bits = ['0']
+    else:
+        temp = int_part
+        while temp > 0:
+            int_bits.append(str(temp % 2))
+            temp //= 2
+        int_bits.reverse()
+
+    frac_bits = []
+    temp = frac_part
+    count = 0
+    while temp > 0 and count < 60:
+        temp *= 2
+        if temp >= 1:
+            frac_bits.append('1')
+            temp -= 1
+        else:
+            frac_bits.append('0')
+        count += 1
+    binary = int_bits + frac_bits
+
+    first_one = -1
+    for i, bit in enumerate(binary):
+        if bit == '1':
+            first_one = i
+            break
+
+    if first_one == -1:  # 全是0
+        return '0' * 64
+
+    if first_one < len(int_bits):
+        exponent = len(int_bits) - first_one - 1
+    else:
+        exponent = - (first_one - len(int_bits) + 1)
+
+    biased_exponent = exponent + 1023
+    exp_bits = bin(biased_exponent)[2:].zfill(11)
+
+    mantissa_start = first_one + 1
+    mantissa_bits = binary[mantissa_start:mantissa_start + 52]
+
+    mantissa_bits = mantissa_bits + ['0'] * (52 - len(mantissa_bits))
+    mantissa_bits = ''.join(mantissa_bits[:52])
+
+    result = sign + exp_bits + mantissa_bits
+
+    return result
+
+
+def unpack_float(byte_data):
+    """从 8 字节解析 IEEE 754 双精度浮点数（不用 struct）"""
+    # 修复：如果传入的是字符串，先转换为字节
+    if isinstance(byte_data, str):
+        # 将二进制字符串转换为字节
+        if len(byte_data) == 64:
+            # 每 8 位转一个字节
+            byte_list = []
+            for i in range(0, 64, 8):
+                byte_list.append(int(byte_data[i:i+8], 2))
+            byte_data = bytes(byte_list)
+        else:
+            raise ValueError("二进制字符串长度必须是64")
+
+    # 1. 转成 64 位二进制字符串
+    bits = ''.join(format(b, '08b') for b in byte_data)
+
+    # 2. 解析符号、指数、尾数
+    sign = int(bits[0])
+    exponent = int(bits[1:12], 2)
+    mantissa = int(bits[12:], 2)
+
+    # 3. 特殊值
+    if exponent == 2047:
+        if mantissa == 0:
+            return float('-inf') if sign else float('inf')
+        return float('nan')
+
+    # 4. 零
+    if exponent == 0 and mantissa == 0:
+        return -0.0 if sign else 0.0
+
+    # 5. 非规格化数
+    if exponent == 0:
+        value = (mantissa / (2**52)) * (2 ** -1022)
+        return -value if sign else value
+
+    # 6. 规格化数
+    value = (1 + mantissa / (2**52)) * (2 ** (exponent - 1023))
+    return -value if sign else value
+
+
+def pack_int(n, bits=None):
+    if bits is None:
+        # 自动计算所需位数（包括符号位）
+        if n >= 0:
+            bits = max(1, n.bit_length() + 1)
+        else:
+            bits = max(1, (-n).bit_length() + 1)
+
+    if n < 0:
+        n = (1 << bits) + n
+
+    return bin(n)[2:].zfill(bits)[-bits:]
+
+
+def pack_str(n):
+    from .smath import ceil
+    result = bin(int.from_bytes(n.encode(), "big"))[2:]
+    return result.rjust(ceil(len(result) / 8) * 8, "0")
+
+
+def bits_to_bytes(bits):
+    """二进制字符串 → bytes"""
+    # 补齐到 8 的倍数
+    if len(bits) % 8 != 0:
+        bits = bits.rjust((len(bits) + 7) // 8 * 8, "0")
+
+    # 每 8 位转一个字节
+    result = []
+    for i in range(0, len(bits), 8):
+        result.append(int(bits[i:i+8], 2))
+    return bytes(result)
+
+
+def bytes_to_bits(data):
+    """bytes → 二进制字符串"""
+    return ''.join(format(b, '08b') for b in data)
+
+
+def pack_to_file(obj, filename):
+    """打包对象并写入文件"""
+    # 1. 打包对象
+    packed = pack(obj)  # 返回 b'类型标记 + 二进制字符串 + \x00'
+
+    # 2. 写入文件
+    with open(filename, 'wb') as f:
+        f.write(packed)
+
+
+# ============ 辅助函数 ============
+
+def pack_varint(n):
+    """变长整数编码（无符号）"""
+    if n == 0:
+        return b'\x00'
+    result = []
+    while n > 0:
+        byte = n & 0x7F
+        n >>= 7
+        if n > 0:
+            byte |= 0x80
+        result.append(byte)
+    return bytes(result)
+
+
+def unpack_varint(data, pos):
+    """解包变长整数"""
+    result = 0
+    shift = 0
+    while pos < len(data):
+        byte = data[pos]
+        pos += 1
+        result |= (byte & 0x7F) << shift
+        if not (byte & 0x80):
+            return result, pos
+        shift += 7
+    raise ValueError("不完整的变长整数")
+
+
+# ============ pack ============
+
+def pack(obj):
+    """打包任意对象为二进制"""
+    if isinstance(obj, str):
+        # 字符串：S + 变长长度 + UTF-8 数据
+        data = obj.encode('utf-8')
+        return b'S' + pack_varint(len(data)) + data
+
+    elif isinstance(obj, int):
+        # 整数：I + 变长编码
+        if obj >= 0:
+            return b'I' + pack_varint(obj)
+        else:
+            # 负数用补码
+            return b'i' + pack_varint(-obj)
+
+    elif isinstance(obj, float):
+        # 浮点数：F + 8字节 IEEE 754
+        bits = pack_float(obj)  # 您的函数，返回二进制字符串
+        return b'F' + bits_to_bytes(bits)
+
+    elif isinstance(obj, bool):
+        # 布尔值：B + 1字节 (0 或 1)
+        return b'B' + (b'\x01' if obj else b'\x00')
+
+    elif isinstance(obj, (list, tuple)):
+        # 列表：L + 每个元素递归 + E
+        result = b'L'
+        for item in obj:
+            result += pack(item)
+        return result + b'E'
+
+    elif isinstance(obj, dict):
+        # 字典：D + 每个键值对递归 + E
+        result = b'D'
+        for key, value in obj.items():
+            result += pack(key) + pack(value)
+        return result + b'E'
+
+    elif obj is None:
+        # None：N
+        return b'N'
+
+    else:
+        raise TypeError(f"不支持的类型: {type(obj)}")
+
+
+# ============ unpack ============
+
+def unpack(data, pos=0):
+    """从二进制解包"""
+    if pos >= len(data):
+        return None, pos
+
+    type_code = data[pos:pos+1]
+    pos += 1
+
+    if type_code == b'S':
+        # 字符串
+        length, pos = unpack_varint(data, pos)
+        value = data[pos:pos+length].decode('utf-8')
+        return value, pos + length
+
+    elif type_code == b'I':
+        # 无符号整数
+        value, pos = unpack_varint(data, pos)
+        return value, pos
+
+    elif type_code == b'i':
+        # 负整数
+        value, pos = unpack_varint(data, pos)
+        return -value, pos
+
+    elif type_code == b'F':
+        # 浮点数 - 直接传入字节数据
+        value = unpack_float(data[pos:pos+8])
+        return value, pos + 8
+
+    elif type_code == b'B':
+        # 布尔值
+        value = data[pos] == 1
+        return value, pos + 1
+
+    elif type_code == b'L':
+        # 列表
+        result = []
+        while pos < len(data):
+            if data[pos:pos+1] == b'E':
+                pos += 1
+                break
+            item, pos = unpack(data, pos)
+            result.append(item)
+        return result, pos
+
+    elif type_code == b'D':
+        # 字典
+        result = {}
+        while pos < len(data):
+            if data[pos:pos+1] == b'E':
+                pos += 1
+                break
+            key, pos = unpack(data, pos)
+            value, pos = unpack(data, pos)
+            result[key] = value
+        return result, pos
+
+    elif type_code == b'N':
+        # None
+        return None, pos
+
+    else:
+        raise TypeError(f"未知类型码: {type_code}")
+
+
+def dump(obj, filename):
+    """保存对象到文件"""
+    with open(filename, 'wb') as f:
+        f.write(pack(obj))
+
+
+def load(filename):
+    """从文件加载对象"""
+    with open(filename, 'rb') as f:
+        data = f.read()
+    return unpack(data)[0]