enhanced stubs for expr.py and added an generator script
This commit is contained in:
Tim Rid
parent
12d94f89e4
commit
f472732cd6
2 changed files with 584 additions and 92 deletions
|
|
@ -2,110 +2,525 @@ import operator
|
|||
import typing as t
|
||||
from construct.core import *
|
||||
|
||||
UniOperator = t.Literal[
|
||||
operator.not_,
|
||||
operator.neg,
|
||||
operator.pos,
|
||||
]
|
||||
UniOperator = t.Callable[[t.Any], t.Any]
|
||||
BinOperator = t.Callable[[t.Any, t.Any], t.Any]
|
||||
|
||||
BinOperator = t.Literal[
|
||||
operator.add,
|
||||
operator.sub,
|
||||
operator.mul,
|
||||
operator.floordiv,
|
||||
operator.mod,
|
||||
operator.pow,
|
||||
operator.xor,
|
||||
operator.lshift,
|
||||
operator.rshift,
|
||||
operator.and_,
|
||||
operator.or_,
|
||||
operator.contains,
|
||||
operator.gt,
|
||||
operator.ge,
|
||||
operator.lt,
|
||||
operator.le,
|
||||
operator.eq,
|
||||
operator.ne,
|
||||
]
|
||||
ReturnType = t.TypeVar("ReturnType")
|
||||
LhsReturnType = t.TypeVar("LhsReturnType")
|
||||
RhsReturnType = t.TypeVar("RhsReturnType")
|
||||
|
||||
class ExprMixin(object):
|
||||
def __add__(self, other: t.Any) -> BinExpr: ...
|
||||
def __sub__(self, other: t.Any) -> BinExpr: ...
|
||||
def __mul__(self, other: t.Any) -> BinExpr: ...
|
||||
def __floordiv__(self, other: t.Any) -> BinExpr: ...
|
||||
def __truediv__(self, other: t.Any) -> BinExpr: ...
|
||||
__div__: t.Callable[[t.Any], BinExpr]
|
||||
def __mod__(self, other: t.Any) -> BinExpr: ...
|
||||
def __pow__(self, other: t.Any) -> BinExpr: ...
|
||||
def __xor__(self, other: t.Any) -> BinExpr: ...
|
||||
def __rshift__(self, other: t.Any) -> BinExpr: ...
|
||||
def __lshift__(self, other: t.Any) -> BinExpr: ...
|
||||
def __and__(self, other: t.Any) -> BinExpr: ...
|
||||
def __or__(self, other: t.Any) -> BinExpr: ...
|
||||
|
||||
def __radd__(self, other: t.Any) -> BinExpr: ...
|
||||
def __rsub__(self, other: t.Any) -> BinExpr: ...
|
||||
def __rmul__(self, other: t.Any) -> BinExpr: ...
|
||||
def __rfloordiv__(self, other: t.Any) -> BinExpr: ...
|
||||
def __rtruediv__(self, other: t.Any) -> BinExpr: ...
|
||||
__rdiv__: t.Callable[[t.Any], BinExpr]
|
||||
def __rmod__(self, other: t.Any) -> BinExpr: ...
|
||||
def __rpow__(self, other: t.Any) -> BinExpr: ...
|
||||
def __rxor__(self, other: t.Any) -> BinExpr: ...
|
||||
def __rrshift__(self, other: t.Any) -> BinExpr: ...
|
||||
def __rlshift__(self, other: t.Any) -> BinExpr: ...
|
||||
def __rand__(self, other: t.Any) -> BinExpr: ...
|
||||
def __ror__(self, other: t.Any) -> BinExpr: ...
|
||||
|
||||
def __neg__(self) -> UniExpr: ...
|
||||
def __pos__(self) -> UniExpr: ...
|
||||
def __invert__(self) -> UniExpr: ...
|
||||
__inv__: t.Callable[[], UniExpr]
|
||||
|
||||
def __contains__(self, other: t.Any) -> BinExpr: ...
|
||||
def __gt__(self, other: t.Any) -> BinExpr: ...
|
||||
def __ge__(self, other: t.Any) -> BinExpr: ...
|
||||
def __lt__(self, other: t.Any) -> BinExpr: ...
|
||||
def __le__(self, other: t.Any) -> BinExpr: ...
|
||||
def __eq__(self, other: t.Any) -> BinExpr: ...
|
||||
def __ne__(self, other: t.Any) -> BinExpr: ...
|
||||
ConstOrCallable = t.Union[ReturnType, t.Callable[[ReturnType], ReturnType]]
|
||||
|
||||
|
||||
class UniExpr(ExprMixin):
|
||||
class ExprMixin(t.Generic[ReturnType], object):
|
||||
# __add__ ##########################################################################################################
|
||||
@t.overload
|
||||
def __add__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __add__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __add__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __add__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __add__(self: ExprMixin[float], other: ConstOrCallable[int]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __add__(self: ExprMixin[float], other: ConstOrCallable[bool]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __add__(self: ExprMixin[float], other: ConstOrCallable[float]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
|
||||
# __sub__ ##########################################################################################################
|
||||
@t.overload
|
||||
def __sub__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __sub__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __sub__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __sub__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __sub__(self: ExprMixin[float], other: ConstOrCallable[int]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __sub__(self: ExprMixin[float], other: ConstOrCallable[bool]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __sub__(self: ExprMixin[float], other: ConstOrCallable[float]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __sub__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __mul__ ##########################################################################################################
|
||||
@t.overload
|
||||
def __mul__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __mul__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __mul__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __mul__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __mul__(self: ExprMixin[float], other: ConstOrCallable[int]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __mul__(self: ExprMixin[float], other: ConstOrCallable[bool]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __mul__(self: ExprMixin[float], other: ConstOrCallable[float]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __mul__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __floordiv__ #####################################################################################################
|
||||
@t.overload
|
||||
def __floordiv__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __floordiv__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __floordiv__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __floordiv__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __floordiv__(self: ExprMixin[float], other: ConstOrCallable[int]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __floordiv__(self: ExprMixin[float], other: ConstOrCallable[bool]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __floordiv__(self: ExprMixin[float], other: ConstOrCallable[float]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __floordiv__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __truediv__ ######################################################################################################
|
||||
@t.overload
|
||||
def __truediv__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __truediv__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __truediv__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __truediv__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __truediv__(self: ExprMixin[float], other: ConstOrCallable[int]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __truediv__(self: ExprMixin[float], other: ConstOrCallable[bool]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __truediv__(self: ExprMixin[float], other: ConstOrCallable[float]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __truediv__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __div__ ##########################################################################################################
|
||||
def __div__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __mod__ ##########################################################################################################
|
||||
@t.overload
|
||||
def __mod__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __mod__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __mod__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __mod__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __mod__(self: ExprMixin[float], other: ConstOrCallable[int]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __mod__(self: ExprMixin[float], other: ConstOrCallable[bool]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __mod__(self: ExprMixin[float], other: ConstOrCallable[float]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __mod__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __pow__ ##########################################################################################################
|
||||
@t.overload
|
||||
def __pow__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __pow__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __pow__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __pow__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __pow__(self: ExprMixin[float], other: ConstOrCallable[int]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __pow__(self: ExprMixin[float], other: ConstOrCallable[bool]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __pow__(self: ExprMixin[float], other: ConstOrCallable[float]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __pow__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __xor__ ##########################################################################################################
|
||||
@t.overload
|
||||
def __xor__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __xor__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __xor__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __xor__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __rshift__ #######################################################################################################
|
||||
@t.overload
|
||||
def __rshift__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rshift__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rshift__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rshift__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rshift__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __lshift__ #######################################################################################################
|
||||
@t.overload
|
||||
def __lshift__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __lshift__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __lshift__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __lshift__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __lshift__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __and__ ##########################################################################################################
|
||||
@t.overload
|
||||
def __and__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __and__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __and__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __and__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __or__ ###########################################################################################################
|
||||
@t.overload
|
||||
def __or__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __or__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __or__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __or__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __radd__ #########################################################################################################
|
||||
@t.overload
|
||||
def __radd__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __radd__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __radd__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __radd__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __radd__(self: ExprMixin[float], other: ConstOrCallable[int]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __radd__(self: ExprMixin[float], other: ConstOrCallable[bool]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __radd__(self: ExprMixin[float], other: ConstOrCallable[float]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __radd__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __rsub__ #########################################################################################################
|
||||
@t.overload
|
||||
def __rsub__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rsub__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rsub__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rsub__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rsub__(self: ExprMixin[float], other: ConstOrCallable[int]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __rsub__(self: ExprMixin[float], other: ConstOrCallable[bool]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __rsub__(self: ExprMixin[float], other: ConstOrCallable[float]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __rsub__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __rmul__ #########################################################################################################
|
||||
@t.overload
|
||||
def __rmul__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rmul__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rmul__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rmul__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rmul__(self: ExprMixin[float], other: ConstOrCallable[int]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __rmul__(self: ExprMixin[float], other: ConstOrCallable[bool]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __rmul__(self: ExprMixin[float], other: ConstOrCallable[float]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __rmul__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __rfloordiv__ ####################################################################################################
|
||||
@t.overload
|
||||
def __rfloordiv__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rfloordiv__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rfloordiv__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rfloordiv__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rfloordiv__(self: ExprMixin[float], other: ConstOrCallable[int]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __rfloordiv__(self: ExprMixin[float], other: ConstOrCallable[bool]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __rfloordiv__(self: ExprMixin[float], other: ConstOrCallable[float]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __rfloordiv__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __rtruediv__ #####################################################################################################
|
||||
@t.overload
|
||||
def __rtruediv__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __rtruediv__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __rtruediv__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __rtruediv__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __rtruediv__(self: ExprMixin[float], other: ConstOrCallable[int]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __rtruediv__(self: ExprMixin[float], other: ConstOrCallable[bool]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __rtruediv__(self: ExprMixin[float], other: ConstOrCallable[float]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __rtruediv__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __rdiv__ #########################################################################################################
|
||||
def __rdiv__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __rmod__ #########################################################################################################
|
||||
@t.overload
|
||||
def __rmod__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rmod__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rmod__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rmod__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rmod__(self: ExprMixin[float], other: ConstOrCallable[int]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __rmod__(self: ExprMixin[float], other: ConstOrCallable[bool]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __rmod__(self: ExprMixin[float], other: ConstOrCallable[float]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __rmod__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __rpow__ #########################################################################################################
|
||||
@t.overload
|
||||
def __rpow__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rpow__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rpow__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rpow__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rpow__(self: ExprMixin[float], other: ConstOrCallable[int]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __rpow__(self: ExprMixin[float], other: ConstOrCallable[bool]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __rpow__(self: ExprMixin[float], other: ConstOrCallable[float]) -> BinExpr[float]: ...
|
||||
@t.overload
|
||||
def __rpow__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __rxor__ #########################################################################################################
|
||||
@t.overload
|
||||
def __rxor__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rxor__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rxor__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rxor__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __rrshift__ ######################################################################################################
|
||||
@t.overload
|
||||
def __rrshift__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rrshift__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rrshift__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rrshift__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rrshift__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __rlshift__ ######################################################################################################
|
||||
@t.overload
|
||||
def __rlshift__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rlshift__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rlshift__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rlshift__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rlshift__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __rand__ #########################################################################################################
|
||||
@t.overload
|
||||
def __rand__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rand__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rand__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __rand__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __ror__ ##########################################################################################################
|
||||
@t.overload
|
||||
def __ror__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __ror__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __ror__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[int]: ...
|
||||
@t.overload
|
||||
def __ror__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __contains__ #####################################################################################################
|
||||
def __contains__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __gt__ ###########################################################################################################
|
||||
@t.overload
|
||||
def __gt__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __gt__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __gt__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __gt__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __gt__(self: ExprMixin[float], other: ConstOrCallable[int]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __gt__(self: ExprMixin[float], other: ConstOrCallable[bool]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __gt__(self: ExprMixin[float], other: ConstOrCallable[float]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __gt__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __ge__ ###########################################################################################################
|
||||
@t.overload
|
||||
def __ge__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __ge__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __ge__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __ge__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __ge__(self: ExprMixin[float], other: ConstOrCallable[int]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __ge__(self: ExprMixin[float], other: ConstOrCallable[bool]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __ge__(self: ExprMixin[float], other: ConstOrCallable[float]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __ge__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __lt__ ###########################################################################################################
|
||||
@t.overload
|
||||
def __lt__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __lt__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __lt__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __lt__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __lt__(self: ExprMixin[float], other: ConstOrCallable[int]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __lt__(self: ExprMixin[float], other: ConstOrCallable[bool]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __lt__(self: ExprMixin[float], other: ConstOrCallable[float]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __lt__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __le__ ###########################################################################################################
|
||||
@t.overload
|
||||
def __le__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __le__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __le__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __le__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __le__(self: ExprMixin[float], other: ConstOrCallable[int]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __le__(self: ExprMixin[float], other: ConstOrCallable[bool]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __le__(self: ExprMixin[float], other: ConstOrCallable[float]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __le__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __eq__ ###########################################################################################################
|
||||
@t.overload
|
||||
def __eq__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __eq__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __eq__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __eq__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __eq__(self: ExprMixin[float], other: ConstOrCallable[int]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __eq__(self: ExprMixin[float], other: ConstOrCallable[bool]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __eq__(self: ExprMixin[float], other: ConstOrCallable[float]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __eq__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
# __ne__ ###########################################################################################################
|
||||
@t.overload
|
||||
def __ne__(self: ExprMixin[int], other: ConstOrCallable[int]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __ne__(self: ExprMixin[int], other: ConstOrCallable[bool]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __ne__(self: ExprMixin[bool], other: ConstOrCallable[int]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __ne__(self: ExprMixin[bool], other: ConstOrCallable[bool]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __ne__(self: ExprMixin[float], other: ConstOrCallable[int]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __ne__(self: ExprMixin[float], other: ConstOrCallable[bool]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __ne__(self: ExprMixin[float], other: ConstOrCallable[float]) -> BinExpr[bool]: ...
|
||||
@t.overload
|
||||
def __ne__(self, other: t.Any) -> BinExpr[t.Any]: ...
|
||||
|
||||
class UniExpr(ExprMixin[ReturnType]):
|
||||
def __init__(self, op: UniOperator, operand: t.Any) -> None: ...
|
||||
def __call__(self, obj: t.Union[Context, dict[str, t.Any]], *args: t.Any) -> t.Any: ...
|
||||
def __call__(self, obj: t.Union[Context, dict[str, t.Any], t.Any], *args: t.Any) -> ReturnType: ...
|
||||
|
||||
|
||||
class BinExpr(ExprMixin):
|
||||
class BinExpr(ExprMixin[ReturnType]):
|
||||
def __init__(self, op: BinOperator, lhs: t.Any, rhs: t.Any) -> None: ...
|
||||
def __call__(self, obj: t.Union[Context, dict[str, t.Any]], *args: t.Any) -> t.Any: ...
|
||||
def __call__(self, obj: t.Union[Context, dict[str, t.Any], t.Any], *args: t.Any) -> ReturnType: ...
|
||||
|
||||
class Path(ExprMixin[ReturnType]):
|
||||
def __init__(self, name: str, field: t.Optional[str] = ..., parent: t.Optional[Path[t.Any]] = ...) -> None: ...
|
||||
def __call__(self, obj: t.Union[Context, dict[str, t.Any], t.Any], *args: t.Any) -> ReturnType: ...
|
||||
def __getattr__(self, name: str) -> Path[t.Any]: ...
|
||||
def __getitem__(self, name: str) -> Path[t.Any]: ...
|
||||
|
||||
|
||||
class Path(ExprMixin):
|
||||
def __init__(self, name: str, field: t.Optional[str] = ..., parent: t.Optional[Path] = ...) -> None: ...
|
||||
def __call__(self, obj: t.Union[Context, dict[str, t.Any]], *args: t.Any) -> t.Any: ...
|
||||
def __getattr__(self, name: str) -> Path: ...
|
||||
def __getitem__(self, name: str) -> Path: ...
|
||||
class Path2(ExprMixin[ReturnType]):
|
||||
def __init__(self, name: str, index: t.Optional[int] = ..., parent: t.Optional[Path2[t.Any]] = ...) -> None: ...
|
||||
def __call__(self, *args: t.Any) -> ReturnType: ...
|
||||
def __getitem__(self, index: int) -> Path2[t.Any]: ...
|
||||
|
||||
|
||||
class Path2(ExprMixin):
|
||||
def __init__(self, name: str, index: t.Optional[int] = ..., parent: t.Optional[Path2] = ...) -> None: ...
|
||||
def __call__(self, *args: t.Any) -> t.Any: ...
|
||||
def __getitem__(self, index: int) -> Path2: ...
|
||||
|
||||
|
||||
class FuncPath(ExprMixin):
|
||||
class FuncPath(ExprMixin[ReturnType]):
|
||||
def __init__(self, func: t.Callable[[t.Any], t.Any], operand: t.Optional[t.Any] = ...) -> None: ...
|
||||
def __call__(self, operand: t.Any, *args: t.Any) -> t.Any: ...
|
||||
def __call__(self, operand: t.Any, *args: t.Any) -> ReturnType: ...
|
||||
|
||||
|
||||
this: Path
|
||||
obj_: Path
|
||||
list_: Path2
|
||||
this: Path[t.Any]
|
||||
obj_: Path[t.Any]
|
||||
list_: Path2[t.Any]
|
||||
|
||||
len_: FuncPath
|
||||
sum_: FuncPath
|
||||
min_: FuncPath
|
||||
max_: FuncPath
|
||||
abs_: FuncPath
|
||||
len_: FuncPath[int]
|
||||
sum_: FuncPath[int]
|
||||
min_: FuncPath[int]
|
||||
max_: FuncPath[int]
|
||||
abs_: FuncPath[int]
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue