melobot.typ¶

class melobot.typ.LogicMode[源代码]¶

基类：Enum

逻辑模式枚举类型

AND = 1¶

OR = 2¶

NOT = 3¶

XOR = 4¶

classmethod calc(logic: LogicMode, v1: Any, v2: Any | None = None) → bool[源代码]¶

将两个值使用指定逻辑模式运算

参数:

logic (LogicMode) -- 逻辑模式
v1 (Any) -- 值 1
v2 (Any | None) -- 值 2

返回:

布尔值

返回类型:

bool

classmethod short_calc(logic: LogicMode, v1: Callable[[], Any], v2: Callable[[], Any] | None) → bool[源代码]¶

与 calc() 功能类似，但运算支持短路

参数:

logic (LogicMode) -- 逻辑模式
v1 (Callable[[], Any]) -- 生成值 1 的可调用对象
v2 (Callable[[], Any] | None) -- 生成值 2 的可调用对象

返回:

布尔值

返回类型:

bool

async classmethod async_short_calc(logic: LogicMode, v1: AsyncCallable[(), Any], v2: AsyncCallable[(), Any] | None) → bool[源代码]¶

与 short_calc() 功能类似，但运算支持异步

参数:

logic (LogicMode) -- 逻辑模式
v1 (AsyncCallable[(), Any]) -- 生成值 1 的异步可调用对象
v2 (AsyncCallable[(), Any] | None) -- 生成值 2 的异步可调用对象

返回:

布尔值

返回类型:

bool

classmethod seq_calc(logic: LogicMode, values: list[Any]) → bool[源代码]¶

使用指定的逻辑模式，对值序列进行运算

# 操作等价与：True and False and True
LogicMode.seq_calc(LogicMode.AND, [True, False, True])

参数:

logic (LogicMode) -- 逻辑模式
values (list[Any]) -- 值序列

返回:

布尔值

返回类型:

bool

classmethod short_seq_calc(logic: LogicMode, getters: Sequence[Callable[[], Any]]) → bool[源代码]¶

与 seq_calc() 功能类似，但运算支持短路

参数:

logic (LogicMode) -- 逻辑模式
getters (Sequence[Callable[[], Any]]) -- 一组获取值的可调用对象

返回:

布尔值

返回类型:

bool

async classmethod async_short_seq_calc(logic: LogicMode, getters: Sequence[AsyncCallable[(), Any]]) → bool[源代码]¶

与 short_seq_calc() 功能类似，但运算支持异步

参数:

logic (LogicMode) -- 逻辑模式
getters (Sequence[AsyncCallable[(), Any]]) -- 一组获取值的异步可调用对象

返回:

布尔值

返回类型:

bool

melobot.typ.is_type(obj: T, hint: type[Any]) → TypeIs[T][源代码]¶

检查 obj 是否是类型注解 hint 所表示的类型

参数:

obj (T) -- 任意对象
hint (type[Any]) -- 任意类型注解

返回:

布尔值

返回类型:

TypeIs[T]

class melobot.typ.BetterABCMeta[源代码]¶

基类：ABCMeta

更好的抽象元类，兼容 ABCMeta 的所有功能，但是额外支持 abstractattr()

class melobot.typ.BetterABC[源代码]¶

基类：object

更好的抽象类，兼容 ABC 的所有功能，但是额外支持 abstractattr()

melobot.typ.abstractattr(obj: Callable[[Any], T] | None = None) → T[源代码]¶

抽象属性

与 abstractproperty 相比更灵活，abstractattr 不关心你以何种形式定义属性。只要子类在实例化后，该属性存在，即认为合法。

但注意它必须与 BetterABC 或 BetterABCMeta 或 SingletonBetterABCMeta 配合使用

这意味着可以在类层级、实例层级定义属性，或使用 property 定义属性：

class A(BetterABC):
    foo: int = abstractattr()  # 声明为抽象属性

    # 或者使用装饰器的形式声明，这与上面是等价的
    @abstractattr
    def bar(self) -> int: ...

# 以下实现都是合法的：

class B(A):
    foo = 2
    bar = 4

class C(A):
    foo = 3
    def __init__(self) -> None:
        self.bar = 5

class D(A):
    def __init__(self) -> None:
        self.foo = 8

    @property
    def bar(self) -> int:
        return self.foo + 10

参数:: obj (Callable[[Any], T] | None)
返回类型:: T

class melobot.typ.SingletonMeta[源代码]¶

基类：type

单例元类

相比单例装饰器，可以自动保证所有子类都为单例

class melobot.typ.SingletonBetterABCMeta[源代码]¶

基类：BetterABCMeta

单例抽象元类

相比普通的抽象元类，还可以自动保证所有子类都为单例

class melobot.typ.VoidType[源代码]¶

基类：Enum

空类型，需要区别于 None 时使用

# 有些时候 `None` 也是合法值，因此需要一个额外的哨兵值：
def foo(val: Any | VoidType = VoidType.VOID) -> None:
    ...

VOID = <class 'melobot.typ._enum._VOID'>¶

class melobot.typ.AsyncCallable[源代码]¶

基类：Protocol[P, T_co]

用法：AsyncCallable[P, T]

是该类型的等价形式：Callable[P, Awaitable[T]]

class melobot.typ.SyncOrAsyncCallable[源代码]¶

基类：Protocol[P, T_co]

用法：SyncOrAsyncCallable[P, T]

是该类型的等价形式：Callable[P, T | Awaitable[T]]

melobot.typ.T¶: 泛型 T，无约束

melobot.typ.U¶: 泛型 U，无约束

melobot.typ.V¶: 泛型 V，无约束

melobot.typ.T_co¶: 泛型 T_co，协变无约束

melobot.typ.P¶: ParamSpec 泛型 P，无约束