mirror of
https://github.com/hypervortex/VH-Bombsquad-Modded-Server-Files
synced 2025-11-07 17:36:08 +00:00
Delete dist directory
This commit is contained in:
Mikahael
GitHub
parent
b2bfb6afd8
commit
9e59089810
1776 changed files with 0 additions and 548278 deletions
366
dist/ba_data/python/efro/call.py
vendored
366
dist/ba_data/python/efro/call.py
vendored
|
|
@ -1,366 +0,0 @@
|
|||
# Released under the MIT License. See LICENSE for details.
|
||||
#
|
||||
"""Call related functionality shared between all efro components."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import TYPE_CHECKING, TypeVar, Generic, Callable, cast
|
||||
import functools
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from typing import Any, overload
|
||||
|
||||
CT = TypeVar('CT', bound=Callable)
|
||||
|
||||
|
||||
class _CallbackCall(Generic[CT]):
|
||||
"""Descriptor for exposing a call with a type defined by a TypeVar."""
|
||||
|
||||
def __get__(self, obj: Any, type_in: Any = None) -> CT:
|
||||
return cast(CT, None)
|
||||
|
||||
|
||||
class CallbackSet(Generic[CT]):
|
||||
"""Wrangles callbacks for a particular event in a type-safe manner."""
|
||||
|
||||
# In the type-checker's eyes, our 'run' attr is a CallbackCall which
|
||||
# returns a callable with the type we were created with. This lets us
|
||||
# type-check our run calls. (Is there another way to expose a function
|
||||
# with a signature defined by a generic?..)
|
||||
# At runtime, run() simply passes its args verbatim to its registered
|
||||
# callbacks; no types are checked.
|
||||
if TYPE_CHECKING:
|
||||
run: _CallbackCall[CT] = _CallbackCall()
|
||||
else:
|
||||
|
||||
def run(self, *args, **keywds):
|
||||
"""Run all callbacks."""
|
||||
print('HELLO FROM RUN', *args, **keywds)
|
||||
|
||||
def __init__(self) -> None:
|
||||
print('CallbackSet()')
|
||||
|
||||
def __del__(self) -> None:
|
||||
print('~CallbackSet()')
|
||||
|
||||
def add(self, call: CT) -> None:
|
||||
"""Add a callback to be run."""
|
||||
print('Would add call', call)
|
||||
|
||||
|
||||
# Define Call() which can be used in type-checking call-wrappers that behave
|
||||
# similarly to functools.partial (in that they take a callable and some
|
||||
# positional arguments to be passed to it).
|
||||
|
||||
# In type-checking land, We define several different _CallXArg classes
|
||||
# corresponding to different argument counts and define Call() as an
|
||||
# overloaded function which returns one of them based on how many args are
|
||||
# passed.
|
||||
|
||||
# To use this, simply assign your call type to this Call for type checking:
|
||||
# Example:
|
||||
# class _MyCallWrapper:
|
||||
# <runtime class defined here>
|
||||
# if TYPE_CHECKING:
|
||||
# MyCallWrapper = efro.call.Call
|
||||
# else:
|
||||
# MyCallWrapper = _MyCallWrapper
|
||||
|
||||
# Note that this setup currently only works with positional arguments; if you
|
||||
# would like to pass args via keyword you can wrap a lambda or local function
|
||||
# which takes keyword args and converts to a call containing keywords.
|
||||
|
||||
if TYPE_CHECKING:
|
||||
In1T = TypeVar('In1T')
|
||||
In2T = TypeVar('In2T')
|
||||
In3T = TypeVar('In3T')
|
||||
In4T = TypeVar('In4T')
|
||||
In5T = TypeVar('In5T')
|
||||
In6T = TypeVar('In6T')
|
||||
In7T = TypeVar('In7T')
|
||||
OutT = TypeVar('OutT')
|
||||
|
||||
class _CallNoArgs(Generic[OutT]):
|
||||
"""Single argument variant of call wrapper."""
|
||||
|
||||
def __init__(self, _call: Callable[[], OutT]):
|
||||
...
|
||||
|
||||
def __call__(self) -> OutT:
|
||||
...
|
||||
|
||||
class _Call1Arg(Generic[In1T, OutT]):
|
||||
"""Single argument variant of call wrapper."""
|
||||
|
||||
def __init__(self, _call: Callable[[In1T], OutT]):
|
||||
...
|
||||
|
||||
def __call__(self, _arg1: In1T) -> OutT:
|
||||
...
|
||||
|
||||
class _Call2Args(Generic[In1T, In2T, OutT]):
|
||||
"""Two argument variant of call wrapper"""
|
||||
|
||||
def __init__(self, _call: Callable[[In1T, In2T], OutT]):
|
||||
...
|
||||
|
||||
def __call__(self, _arg1: In1T, _arg2: In2T) -> OutT:
|
||||
...
|
||||
|
||||
class _Call3Args(Generic[In1T, In2T, In3T, OutT]):
|
||||
"""Three argument variant of call wrapper"""
|
||||
|
||||
def __init__(self, _call: Callable[[In1T, In2T, In3T], OutT]):
|
||||
...
|
||||
|
||||
def __call__(self, _arg1: In1T, _arg2: In2T, _arg3: In3T) -> OutT:
|
||||
...
|
||||
|
||||
class _Call4Args(Generic[In1T, In2T, In3T, In4T, OutT]):
|
||||
"""Four argument variant of call wrapper"""
|
||||
|
||||
def __init__(self, _call: Callable[[In1T, In2T, In3T, In4T], OutT]):
|
||||
...
|
||||
|
||||
def __call__(
|
||||
self, _arg1: In1T, _arg2: In2T, _arg3: In3T, _arg4: In4T
|
||||
) -> OutT:
|
||||
...
|
||||
|
||||
class _Call5Args(Generic[In1T, In2T, In3T, In4T, In5T, OutT]):
|
||||
"""Five argument variant of call wrapper"""
|
||||
|
||||
def __init__(
|
||||
self, _call: Callable[[In1T, In2T, In3T, In4T, In5T], OutT]
|
||||
):
|
||||
...
|
||||
|
||||
def __call__(
|
||||
self,
|
||||
_arg1: In1T,
|
||||
_arg2: In2T,
|
||||
_arg3: In3T,
|
||||
_arg4: In4T,
|
||||
_arg5: In5T,
|
||||
) -> OutT:
|
||||
...
|
||||
|
||||
class _Call6Args(Generic[In1T, In2T, In3T, In4T, In5T, In6T, OutT]):
|
||||
"""Six argument variant of call wrapper"""
|
||||
|
||||
def __init__(
|
||||
self, _call: Callable[[In1T, In2T, In3T, In4T, In5T, In6T], OutT]
|
||||
):
|
||||
...
|
||||
|
||||
def __call__(
|
||||
self,
|
||||
_arg1: In1T,
|
||||
_arg2: In2T,
|
||||
_arg3: In3T,
|
||||
_arg4: In4T,
|
||||
_arg5: In5T,
|
||||
_arg6: In6T,
|
||||
) -> OutT:
|
||||
...
|
||||
|
||||
class _Call7Args(Generic[In1T, In2T, In3T, In4T, In5T, In6T, In7T, OutT]):
|
||||
"""Seven argument variant of call wrapper"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
_call: Callable[[In1T, In2T, In3T, In4T, In5T, In6T, In7T], OutT],
|
||||
):
|
||||
...
|
||||
|
||||
def __call__(
|
||||
self,
|
||||
_arg1: In1T,
|
||||
_arg2: In2T,
|
||||
_arg3: In3T,
|
||||
_arg4: In4T,
|
||||
_arg5: In5T,
|
||||
_arg6: In6T,
|
||||
_arg7: In7T,
|
||||
) -> OutT:
|
||||
...
|
||||
|
||||
# No arg call; no args bundled.
|
||||
# noinspection PyPep8Naming
|
||||
@overload
|
||||
def Call(call: Callable[[], OutT]) -> _CallNoArgs[OutT]:
|
||||
...
|
||||
|
||||
# 1 arg call; 1 arg bundled.
|
||||
# noinspection PyPep8Naming
|
||||
@overload
|
||||
def Call(call: Callable[[In1T], OutT], arg1: In1T) -> _CallNoArgs[OutT]:
|
||||
...
|
||||
|
||||
# 1 arg call; no args bundled.
|
||||
# noinspection PyPep8Naming
|
||||
@overload
|
||||
def Call(call: Callable[[In1T], OutT]) -> _Call1Arg[In1T, OutT]:
|
||||
...
|
||||
|
||||
# 2 arg call; 2 args bundled.
|
||||
# noinspection PyPep8Naming
|
||||
@overload
|
||||
def Call(
|
||||
call: Callable[[In1T, In2T], OutT], arg1: In1T, arg2: In2T
|
||||
) -> _CallNoArgs[OutT]:
|
||||
...
|
||||
|
||||
# 2 arg call; 1 arg bundled.
|
||||
# noinspection PyPep8Naming
|
||||
@overload
|
||||
def Call(
|
||||
call: Callable[[In1T, In2T], OutT], arg1: In1T
|
||||
) -> _Call1Arg[In2T, OutT]:
|
||||
...
|
||||
|
||||
# 2 arg call; no args bundled.
|
||||
# noinspection PyPep8Naming
|
||||
@overload
|
||||
def Call(
|
||||
call: Callable[[In1T, In2T], OutT]
|
||||
) -> _Call2Args[In1T, In2T, OutT]:
|
||||
...
|
||||
|
||||
# 3 arg call; 3 args bundled.
|
||||
# noinspection PyPep8Naming
|
||||
@overload
|
||||
def Call(
|
||||
call: Callable[[In1T, In2T, In3T], OutT],
|
||||
arg1: In1T,
|
||||
arg2: In2T,
|
||||
arg3: In3T,
|
||||
) -> _CallNoArgs[OutT]:
|
||||
...
|
||||
|
||||
# 3 arg call; 2 args bundled.
|
||||
# noinspection PyPep8Naming
|
||||
@overload
|
||||
def Call(
|
||||
call: Callable[[In1T, In2T, In3T], OutT], arg1: In1T, arg2: In2T
|
||||
) -> _Call1Arg[In3T, OutT]:
|
||||
...
|
||||
|
||||
# 3 arg call; 1 arg bundled.
|
||||
# noinspection PyPep8Naming
|
||||
@overload
|
||||
def Call(
|
||||
call: Callable[[In1T, In2T, In3T], OutT], arg1: In1T
|
||||
) -> _Call2Args[In2T, In3T, OutT]:
|
||||
...
|
||||
|
||||
# 3 arg call; no args bundled.
|
||||
# noinspection PyPep8Naming
|
||||
@overload
|
||||
def Call(
|
||||
call: Callable[[In1T, In2T, In3T], OutT]
|
||||
) -> _Call3Args[In1T, In2T, In3T, OutT]:
|
||||
...
|
||||
|
||||
# 4 arg call; 4 args bundled.
|
||||
# noinspection PyPep8Naming
|
||||
@overload
|
||||
def Call(
|
||||
call: Callable[[In1T, In2T, In3T, In4T], OutT],
|
||||
arg1: In1T,
|
||||
arg2: In2T,
|
||||
arg3: In3T,
|
||||
arg4: In4T,
|
||||
) -> _CallNoArgs[OutT]:
|
||||
...
|
||||
|
||||
# 4 arg call; 3 args bundled.
|
||||
# noinspection PyPep8Naming
|
||||
@overload
|
||||
def Call(
|
||||
call: Callable[[In1T, In2T, In3T, In4T], OutT],
|
||||
arg1: In1T,
|
||||
arg2: In2T,
|
||||
arg3: In3T,
|
||||
) -> _Call1Arg[In4T, OutT]:
|
||||
...
|
||||
|
||||
# 4 arg call; 2 args bundled.
|
||||
# noinspection PyPep8Naming
|
||||
@overload
|
||||
def Call(
|
||||
call: Callable[[In1T, In2T, In3T, In4T], OutT],
|
||||
arg1: In1T,
|
||||
arg2: In2T,
|
||||
) -> _Call2Args[In3T, In4T, OutT]:
|
||||
...
|
||||
|
||||
# 4 arg call; 1 arg bundled.
|
||||
# noinspection PyPep8Naming
|
||||
@overload
|
||||
def Call(
|
||||
call: Callable[[In1T, In2T, In3T, In4T], OutT],
|
||||
arg1: In1T,
|
||||
) -> _Call3Args[In2T, In3T, In4T, OutT]:
|
||||
...
|
||||
|
||||
# 4 arg call; no args bundled.
|
||||
# noinspection PyPep8Naming
|
||||
@overload
|
||||
def Call(
|
||||
call: Callable[[In1T, In2T, In3T, In4T], OutT],
|
||||
) -> _Call4Args[In1T, In2T, In3T, In4T, OutT]:
|
||||
...
|
||||
|
||||
# 5 arg call; 5 args bundled.
|
||||
# noinspection PyPep8Naming
|
||||
@overload
|
||||
def Call(
|
||||
call: Callable[[In1T, In2T, In3T, In4T, In5T], OutT],
|
||||
arg1: In1T,
|
||||
arg2: In2T,
|
||||
arg3: In3T,
|
||||
arg4: In4T,
|
||||
arg5: In5T,
|
||||
) -> _CallNoArgs[OutT]:
|
||||
...
|
||||
|
||||
# 6 arg call; 6 args bundled.
|
||||
# noinspection PyPep8Naming
|
||||
@overload
|
||||
def Call(
|
||||
call: Callable[[In1T, In2T, In3T, In4T, In5T, In6T], OutT],
|
||||
arg1: In1T,
|
||||
arg2: In2T,
|
||||
arg3: In3T,
|
||||
arg4: In4T,
|
||||
arg5: In5T,
|
||||
arg6: In6T,
|
||||
) -> _CallNoArgs[OutT]:
|
||||
...
|
||||
|
||||
# 7 arg call; 7 args bundled.
|
||||
# noinspection PyPep8Naming
|
||||
@overload
|
||||
def Call(
|
||||
call: Callable[[In1T, In2T, In3T, In4T, In5T, In6T, In7T], OutT],
|
||||
arg1: In1T,
|
||||
arg2: In2T,
|
||||
arg3: In3T,
|
||||
arg4: In4T,
|
||||
arg5: In5T,
|
||||
arg6: In6T,
|
||||
arg7: In7T,
|
||||
) -> _CallNoArgs[OutT]:
|
||||
...
|
||||
|
||||
# noinspection PyPep8Naming
|
||||
def Call(*_args: Any, **_keywds: Any) -> Any:
|
||||
...
|
||||
|
||||
# (Type-safe Partial)
|
||||
# A convenient wrapper around functools.partial which adds type-safety
|
||||
# (though it does not support keyword arguments).
|
||||
tpartial = Call
|
||||
else:
|
||||
tpartial = functools.partial
|
||||
Loading…
Add table
Add a link
Reference in a new issue