melobot.typ

class melobot.typ.LogicMode

基类：Enum

逻辑模式枚举类型

AND = 'and'

OR = 'or'

NOT = 'not'

XOR = 'xor'

get_operator() → Callable[[Any, Any], bool]

返回类型:

Callable[[Any, 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，无约束