From 2e9a61f834360e1c3ada9c5848d1863e8786f841 Mon Sep 17 00:00:00 2001 From: RedContritio Date: Mon, 16 Sep 2024 15:13:27 +0800 Subject: [PATCH] Add lupa stubs (#12650) --- stubs/lupa/METADATA.toml | 2 + stubs/lupa/lupa/__init__.pyi | 17 +++++++ stubs/lupa/lupa/lua51.pyi | 93 ++++++++++++++++++++++++++++++++++++ stubs/lupa/lupa/lua52.pyi | 93 ++++++++++++++++++++++++++++++++++++ stubs/lupa/lupa/lua53.pyi | 93 ++++++++++++++++++++++++++++++++++++ stubs/lupa/lupa/lua54.pyi | 93 ++++++++++++++++++++++++++++++++++++ stubs/lupa/lupa/luajit20.pyi | 93 ++++++++++++++++++++++++++++++++++++ stubs/lupa/lupa/luajit21.pyi | 93 ++++++++++++++++++++++++++++++++++++ stubs/lupa/lupa/version.pyi | 3 ++ 9 files changed, 580 insertions(+) create mode 100644 stubs/lupa/METADATA.toml create mode 100644 stubs/lupa/lupa/__init__.pyi create mode 100644 stubs/lupa/lupa/lua51.pyi create mode 100644 stubs/lupa/lupa/lua52.pyi create mode 100644 stubs/lupa/lupa/lua53.pyi create mode 100644 stubs/lupa/lupa/lua54.pyi create mode 100644 stubs/lupa/lupa/luajit20.pyi create mode 100644 stubs/lupa/lupa/luajit21.pyi create mode 100644 stubs/lupa/lupa/version.pyi diff --git a/stubs/lupa/METADATA.toml b/stubs/lupa/METADATA.toml new file mode 100644 index 000000000..6f7ead243 --- /dev/null +++ b/stubs/lupa/METADATA.toml @@ -0,0 +1,2 @@ +version = "2.2.*" +upstream_repository = "https://github.com/scoder/lupa" diff --git a/stubs/lupa/lupa/__init__.pyi b/stubs/lupa/lupa/__init__.pyi new file mode 100644 index 000000000..d14ef9182 --- /dev/null +++ b/stubs/lupa/lupa/__init__.pyi @@ -0,0 +1,17 @@ +from .lua54 import * + +__all__ = [ + # from lua54 (newest lib) + "LUA_VERSION", + "LUA_MAXINTEGER", + "LUA_MININTEGER", + "LuaRuntime", + "LuaError", + "LuaSyntaxError", + "LuaMemoryError", + "as_itemgetter", + "as_attrgetter", + "lua_type", + "unpacks_lua_table", + "unpacks_lua_table_method", +] diff --git a/stubs/lupa/lupa/lua51.pyi b/stubs/lupa/lupa/lua51.pyi new file mode 100644 index 000000000..cdd4e4b09 --- /dev/null +++ b/stubs/lupa/lupa/lua51.pyi @@ -0,0 +1,93 @@ +from _typeshed import MaybeNone +from collections.abc import Callable, Iterator +from typing import Any, Final, Generic, TypeVar, type_check_only + +__all__ = [ + "LUA_VERSION", + "LUA_MAXINTEGER", + "LUA_MININTEGER", + "LuaRuntime", + "LuaError", + "LuaSyntaxError", + "LuaMemoryError", + "as_itemgetter", + "as_attrgetter", + "lua_type", + "unpacks_lua_table", + "unpacks_lua_table_method", +] + +LUA_MAXINTEGER: Final[int] +LUA_MININTEGER: Final[int] +LUA_VERSION: Final[tuple[int, int]] + +# cyfunction object +as_attrgetter: Callable[[object], object] +as_itemgetter: Callable[[object], object] + +# cyfunction object +lua_type: Callable[[object], str | MaybeNone] + +# cyfunction object as decorator +unpacks_lua_table: Callable[[Callable[..., Any]], Callable[..., Any]] +unpacks_lua_table_method: Callable[[Callable[..., Any]], Callable[..., Any]] + +# inner classes + +@type_check_only +class _LuaIter: + def __iter__(self) -> Iterator[object]: ... + +@type_check_only +class _LuaTable: + def keys(self) -> _LuaIter: ... + def values(self) -> _LuaIter: ... + def items(self) -> _LuaIter: ... + +@type_check_only +class _LuaNoGC: ... + +@type_check_only +class _LuaObject: ... + +# classes + +_bint = TypeVar("_bint", bool, int) + +class FastRLock(Generic[_bint]): + # @classmethod + # def __init__(cls, /, *args: Any, **kwargs: Any) -> None: ... + def acquire(self, blocking: _bint = True) -> _bint: ... + def release(self) -> None: ... + def __enter__(self) -> _bint: ... + def __exit__(self, t: object, v: object, tb: object) -> None: ... + +class LuaError(Exception): ... +class LuaSyntaxError(LuaError): ... +class LuaMemoryError(LuaError, MemoryError): ... + +class LuaRuntime: + lua_implementation: Final[str] + lua_version: Final[tuple[int, int]] + + # @classmethod + # def __cinit__(cls, unpack_return_tuples: bool) -> None: ... + # def add_pending_unref(self, ref: int) -> None: ... + # def clean_up_pending_unrefs(self) -> int: ... + def get_max_memory(self, total: bool = False) -> int | MaybeNone: ... + def get_memory_used(self, total: bool = False) -> int | MaybeNone: ... + # def reraise_on_exceptions(self) -> int: ... + # def store_raised_exception(self, L: object, lua_error_msg: str) -> None: ... # unannotated + def eval(self, lua_code: str, *args: Any, name: str | None = None, mode: str | None = None) -> object: ... + def execute(self, lua_code: str, *args: Any, name: str | None = None, mode: str | None = None) -> object: ... + def compile(self, lua_code: str, name: str | None = None, mode: str | None = None) -> Callable[..., object]: ... + def require(self, modulename: str) -> object: ... + def globals(self) -> _LuaTable: ... + def table(self, *items: Any, **kwargs: Any) -> _LuaTable: ... + def table_from(self, *args: Any, recursive: bool = ...) -> _LuaTable: ... + def nogc(self) -> _LuaNoGC: ... + def gccollect(self) -> None: ... + def set_max_memory(self, max_memory: int, total: bool = False) -> None: ... + def set_overflow_handler(self, overflow_handler: Callable[..., None]) -> None: ... + # def register_py_object(self, cname: str, pyname: str, obj: object) -> int: ... + # def init_python_lib(self, register_eval: bool, register_builtins: bool) -> int: ... diff --git a/stubs/lupa/lupa/lua52.pyi b/stubs/lupa/lupa/lua52.pyi new file mode 100644 index 000000000..cdd4e4b09 --- /dev/null +++ b/stubs/lupa/lupa/lua52.pyi @@ -0,0 +1,93 @@ +from _typeshed import MaybeNone +from collections.abc import Callable, Iterator +from typing import Any, Final, Generic, TypeVar, type_check_only + +__all__ = [ + "LUA_VERSION", + "LUA_MAXINTEGER", + "LUA_MININTEGER", + "LuaRuntime", + "LuaError", + "LuaSyntaxError", + "LuaMemoryError", + "as_itemgetter", + "as_attrgetter", + "lua_type", + "unpacks_lua_table", + "unpacks_lua_table_method", +] + +LUA_MAXINTEGER: Final[int] +LUA_MININTEGER: Final[int] +LUA_VERSION: Final[tuple[int, int]] + +# cyfunction object +as_attrgetter: Callable[[object], object] +as_itemgetter: Callable[[object], object] + +# cyfunction object +lua_type: Callable[[object], str | MaybeNone] + +# cyfunction object as decorator +unpacks_lua_table: Callable[[Callable[..., Any]], Callable[..., Any]] +unpacks_lua_table_method: Callable[[Callable[..., Any]], Callable[..., Any]] + +# inner classes + +@type_check_only +class _LuaIter: + def __iter__(self) -> Iterator[object]: ... + +@type_check_only +class _LuaTable: + def keys(self) -> _LuaIter: ... + def values(self) -> _LuaIter: ... + def items(self) -> _LuaIter: ... + +@type_check_only +class _LuaNoGC: ... + +@type_check_only +class _LuaObject: ... + +# classes + +_bint = TypeVar("_bint", bool, int) + +class FastRLock(Generic[_bint]): + # @classmethod + # def __init__(cls, /, *args: Any, **kwargs: Any) -> None: ... + def acquire(self, blocking: _bint = True) -> _bint: ... + def release(self) -> None: ... + def __enter__(self) -> _bint: ... + def __exit__(self, t: object, v: object, tb: object) -> None: ... + +class LuaError(Exception): ... +class LuaSyntaxError(LuaError): ... +class LuaMemoryError(LuaError, MemoryError): ... + +class LuaRuntime: + lua_implementation: Final[str] + lua_version: Final[tuple[int, int]] + + # @classmethod + # def __cinit__(cls, unpack_return_tuples: bool) -> None: ... + # def add_pending_unref(self, ref: int) -> None: ... + # def clean_up_pending_unrefs(self) -> int: ... + def get_max_memory(self, total: bool = False) -> int | MaybeNone: ... + def get_memory_used(self, total: bool = False) -> int | MaybeNone: ... + # def reraise_on_exceptions(self) -> int: ... + # def store_raised_exception(self, L: object, lua_error_msg: str) -> None: ... # unannotated + def eval(self, lua_code: str, *args: Any, name: str | None = None, mode: str | None = None) -> object: ... + def execute(self, lua_code: str, *args: Any, name: str | None = None, mode: str | None = None) -> object: ... + def compile(self, lua_code: str, name: str | None = None, mode: str | None = None) -> Callable[..., object]: ... + def require(self, modulename: str) -> object: ... + def globals(self) -> _LuaTable: ... + def table(self, *items: Any, **kwargs: Any) -> _LuaTable: ... + def table_from(self, *args: Any, recursive: bool = ...) -> _LuaTable: ... + def nogc(self) -> _LuaNoGC: ... + def gccollect(self) -> None: ... + def set_max_memory(self, max_memory: int, total: bool = False) -> None: ... + def set_overflow_handler(self, overflow_handler: Callable[..., None]) -> None: ... + # def register_py_object(self, cname: str, pyname: str, obj: object) -> int: ... + # def init_python_lib(self, register_eval: bool, register_builtins: bool) -> int: ... diff --git a/stubs/lupa/lupa/lua53.pyi b/stubs/lupa/lupa/lua53.pyi new file mode 100644 index 000000000..cdd4e4b09 --- /dev/null +++ b/stubs/lupa/lupa/lua53.pyi @@ -0,0 +1,93 @@ +from _typeshed import MaybeNone +from collections.abc import Callable, Iterator +from typing import Any, Final, Generic, TypeVar, type_check_only + +__all__ = [ + "LUA_VERSION", + "LUA_MAXINTEGER", + "LUA_MININTEGER", + "LuaRuntime", + "LuaError", + "LuaSyntaxError", + "LuaMemoryError", + "as_itemgetter", + "as_attrgetter", + "lua_type", + "unpacks_lua_table", + "unpacks_lua_table_method", +] + +LUA_MAXINTEGER: Final[int] +LUA_MININTEGER: Final[int] +LUA_VERSION: Final[tuple[int, int]] + +# cyfunction object +as_attrgetter: Callable[[object], object] +as_itemgetter: Callable[[object], object] + +# cyfunction object +lua_type: Callable[[object], str | MaybeNone] + +# cyfunction object as decorator +unpacks_lua_table: Callable[[Callable[..., Any]], Callable[..., Any]] +unpacks_lua_table_method: Callable[[Callable[..., Any]], Callable[..., Any]] + +# inner classes + +@type_check_only +class _LuaIter: + def __iter__(self) -> Iterator[object]: ... + +@type_check_only +class _LuaTable: + def keys(self) -> _LuaIter: ... + def values(self) -> _LuaIter: ... + def items(self) -> _LuaIter: ... + +@type_check_only +class _LuaNoGC: ... + +@type_check_only +class _LuaObject: ... + +# classes + +_bint = TypeVar("_bint", bool, int) + +class FastRLock(Generic[_bint]): + # @classmethod + # def __init__(cls, /, *args: Any, **kwargs: Any) -> None: ... + def acquire(self, blocking: _bint = True) -> _bint: ... + def release(self) -> None: ... + def __enter__(self) -> _bint: ... + def __exit__(self, t: object, v: object, tb: object) -> None: ... + +class LuaError(Exception): ... +class LuaSyntaxError(LuaError): ... +class LuaMemoryError(LuaError, MemoryError): ... + +class LuaRuntime: + lua_implementation: Final[str] + lua_version: Final[tuple[int, int]] + + # @classmethod + # def __cinit__(cls, unpack_return_tuples: bool) -> None: ... + # def add_pending_unref(self, ref: int) -> None: ... + # def clean_up_pending_unrefs(self) -> int: ... + def get_max_memory(self, total: bool = False) -> int | MaybeNone: ... + def get_memory_used(self, total: bool = False) -> int | MaybeNone: ... + # def reraise_on_exceptions(self) -> int: ... + # def store_raised_exception(self, L: object, lua_error_msg: str) -> None: ... # unannotated + def eval(self, lua_code: str, *args: Any, name: str | None = None, mode: str | None = None) -> object: ... + def execute(self, lua_code: str, *args: Any, name: str | None = None, mode: str | None = None) -> object: ... + def compile(self, lua_code: str, name: str | None = None, mode: str | None = None) -> Callable[..., object]: ... + def require(self, modulename: str) -> object: ... + def globals(self) -> _LuaTable: ... + def table(self, *items: Any, **kwargs: Any) -> _LuaTable: ... + def table_from(self, *args: Any, recursive: bool = ...) -> _LuaTable: ... + def nogc(self) -> _LuaNoGC: ... + def gccollect(self) -> None: ... + def set_max_memory(self, max_memory: int, total: bool = False) -> None: ... + def set_overflow_handler(self, overflow_handler: Callable[..., None]) -> None: ... + # def register_py_object(self, cname: str, pyname: str, obj: object) -> int: ... + # def init_python_lib(self, register_eval: bool, register_builtins: bool) -> int: ... diff --git a/stubs/lupa/lupa/lua54.pyi b/stubs/lupa/lupa/lua54.pyi new file mode 100644 index 000000000..cdd4e4b09 --- /dev/null +++ b/stubs/lupa/lupa/lua54.pyi @@ -0,0 +1,93 @@ +from _typeshed import MaybeNone +from collections.abc import Callable, Iterator +from typing import Any, Final, Generic, TypeVar, type_check_only + +__all__ = [ + "LUA_VERSION", + "LUA_MAXINTEGER", + "LUA_MININTEGER", + "LuaRuntime", + "LuaError", + "LuaSyntaxError", + "LuaMemoryError", + "as_itemgetter", + "as_attrgetter", + "lua_type", + "unpacks_lua_table", + "unpacks_lua_table_method", +] + +LUA_MAXINTEGER: Final[int] +LUA_MININTEGER: Final[int] +LUA_VERSION: Final[tuple[int, int]] + +# cyfunction object +as_attrgetter: Callable[[object], object] +as_itemgetter: Callable[[object], object] + +# cyfunction object +lua_type: Callable[[object], str | MaybeNone] + +# cyfunction object as decorator +unpacks_lua_table: Callable[[Callable[..., Any]], Callable[..., Any]] +unpacks_lua_table_method: Callable[[Callable[..., Any]], Callable[..., Any]] + +# inner classes + +@type_check_only +class _LuaIter: + def __iter__(self) -> Iterator[object]: ... + +@type_check_only +class _LuaTable: + def keys(self) -> _LuaIter: ... + def values(self) -> _LuaIter: ... + def items(self) -> _LuaIter: ... + +@type_check_only +class _LuaNoGC: ... + +@type_check_only +class _LuaObject: ... + +# classes + +_bint = TypeVar("_bint", bool, int) + +class FastRLock(Generic[_bint]): + # @classmethod + # def __init__(cls, /, *args: Any, **kwargs: Any) -> None: ... + def acquire(self, blocking: _bint = True) -> _bint: ... + def release(self) -> None: ... + def __enter__(self) -> _bint: ... + def __exit__(self, t: object, v: object, tb: object) -> None: ... + +class LuaError(Exception): ... +class LuaSyntaxError(LuaError): ... +class LuaMemoryError(LuaError, MemoryError): ... + +class LuaRuntime: + lua_implementation: Final[str] + lua_version: Final[tuple[int, int]] + + # @classmethod + # def __cinit__(cls, unpack_return_tuples: bool) -> None: ... + # def add_pending_unref(self, ref: int) -> None: ... + # def clean_up_pending_unrefs(self) -> int: ... + def get_max_memory(self, total: bool = False) -> int | MaybeNone: ... + def get_memory_used(self, total: bool = False) -> int | MaybeNone: ... + # def reraise_on_exceptions(self) -> int: ... + # def store_raised_exception(self, L: object, lua_error_msg: str) -> None: ... # unannotated + def eval(self, lua_code: str, *args: Any, name: str | None = None, mode: str | None = None) -> object: ... + def execute(self, lua_code: str, *args: Any, name: str | None = None, mode: str | None = None) -> object: ... + def compile(self, lua_code: str, name: str | None = None, mode: str | None = None) -> Callable[..., object]: ... + def require(self, modulename: str) -> object: ... + def globals(self) -> _LuaTable: ... + def table(self, *items: Any, **kwargs: Any) -> _LuaTable: ... + def table_from(self, *args: Any, recursive: bool = ...) -> _LuaTable: ... + def nogc(self) -> _LuaNoGC: ... + def gccollect(self) -> None: ... + def set_max_memory(self, max_memory: int, total: bool = False) -> None: ... + def set_overflow_handler(self, overflow_handler: Callable[..., None]) -> None: ... + # def register_py_object(self, cname: str, pyname: str, obj: object) -> int: ... + # def init_python_lib(self, register_eval: bool, register_builtins: bool) -> int: ... diff --git a/stubs/lupa/lupa/luajit20.pyi b/stubs/lupa/lupa/luajit20.pyi new file mode 100644 index 000000000..cdd4e4b09 --- /dev/null +++ b/stubs/lupa/lupa/luajit20.pyi @@ -0,0 +1,93 @@ +from _typeshed import MaybeNone +from collections.abc import Callable, Iterator +from typing import Any, Final, Generic, TypeVar, type_check_only + +__all__ = [ + "LUA_VERSION", + "LUA_MAXINTEGER", + "LUA_MININTEGER", + "LuaRuntime", + "LuaError", + "LuaSyntaxError", + "LuaMemoryError", + "as_itemgetter", + "as_attrgetter", + "lua_type", + "unpacks_lua_table", + "unpacks_lua_table_method", +] + +LUA_MAXINTEGER: Final[int] +LUA_MININTEGER: Final[int] +LUA_VERSION: Final[tuple[int, int]] + +# cyfunction object +as_attrgetter: Callable[[object], object] +as_itemgetter: Callable[[object], object] + +# cyfunction object +lua_type: Callable[[object], str | MaybeNone] + +# cyfunction object as decorator +unpacks_lua_table: Callable[[Callable[..., Any]], Callable[..., Any]] +unpacks_lua_table_method: Callable[[Callable[..., Any]], Callable[..., Any]] + +# inner classes + +@type_check_only +class _LuaIter: + def __iter__(self) -> Iterator[object]: ... + +@type_check_only +class _LuaTable: + def keys(self) -> _LuaIter: ... + def values(self) -> _LuaIter: ... + def items(self) -> _LuaIter: ... + +@type_check_only +class _LuaNoGC: ... + +@type_check_only +class _LuaObject: ... + +# classes + +_bint = TypeVar("_bint", bool, int) + +class FastRLock(Generic[_bint]): + # @classmethod + # def __init__(cls, /, *args: Any, **kwargs: Any) -> None: ... + def acquire(self, blocking: _bint = True) -> _bint: ... + def release(self) -> None: ... + def __enter__(self) -> _bint: ... + def __exit__(self, t: object, v: object, tb: object) -> None: ... + +class LuaError(Exception): ... +class LuaSyntaxError(LuaError): ... +class LuaMemoryError(LuaError, MemoryError): ... + +class LuaRuntime: + lua_implementation: Final[str] + lua_version: Final[tuple[int, int]] + + # @classmethod + # def __cinit__(cls, unpack_return_tuples: bool) -> None: ... + # def add_pending_unref(self, ref: int) -> None: ... + # def clean_up_pending_unrefs(self) -> int: ... + def get_max_memory(self, total: bool = False) -> int | MaybeNone: ... + def get_memory_used(self, total: bool = False) -> int | MaybeNone: ... + # def reraise_on_exceptions(self) -> int: ... + # def store_raised_exception(self, L: object, lua_error_msg: str) -> None: ... # unannotated + def eval(self, lua_code: str, *args: Any, name: str | None = None, mode: str | None = None) -> object: ... + def execute(self, lua_code: str, *args: Any, name: str | None = None, mode: str | None = None) -> object: ... + def compile(self, lua_code: str, name: str | None = None, mode: str | None = None) -> Callable[..., object]: ... + def require(self, modulename: str) -> object: ... + def globals(self) -> _LuaTable: ... + def table(self, *items: Any, **kwargs: Any) -> _LuaTable: ... + def table_from(self, *args: Any, recursive: bool = ...) -> _LuaTable: ... + def nogc(self) -> _LuaNoGC: ... + def gccollect(self) -> None: ... + def set_max_memory(self, max_memory: int, total: bool = False) -> None: ... + def set_overflow_handler(self, overflow_handler: Callable[..., None]) -> None: ... + # def register_py_object(self, cname: str, pyname: str, obj: object) -> int: ... + # def init_python_lib(self, register_eval: bool, register_builtins: bool) -> int: ... diff --git a/stubs/lupa/lupa/luajit21.pyi b/stubs/lupa/lupa/luajit21.pyi new file mode 100644 index 000000000..cdd4e4b09 --- /dev/null +++ b/stubs/lupa/lupa/luajit21.pyi @@ -0,0 +1,93 @@ +from _typeshed import MaybeNone +from collections.abc import Callable, Iterator +from typing import Any, Final, Generic, TypeVar, type_check_only + +__all__ = [ + "LUA_VERSION", + "LUA_MAXINTEGER", + "LUA_MININTEGER", + "LuaRuntime", + "LuaError", + "LuaSyntaxError", + "LuaMemoryError", + "as_itemgetter", + "as_attrgetter", + "lua_type", + "unpacks_lua_table", + "unpacks_lua_table_method", +] + +LUA_MAXINTEGER: Final[int] +LUA_MININTEGER: Final[int] +LUA_VERSION: Final[tuple[int, int]] + +# cyfunction object +as_attrgetter: Callable[[object], object] +as_itemgetter: Callable[[object], object] + +# cyfunction object +lua_type: Callable[[object], str | MaybeNone] + +# cyfunction object as decorator +unpacks_lua_table: Callable[[Callable[..., Any]], Callable[..., Any]] +unpacks_lua_table_method: Callable[[Callable[..., Any]], Callable[..., Any]] + +# inner classes + +@type_check_only +class _LuaIter: + def __iter__(self) -> Iterator[object]: ... + +@type_check_only +class _LuaTable: + def keys(self) -> _LuaIter: ... + def values(self) -> _LuaIter: ... + def items(self) -> _LuaIter: ... + +@type_check_only +class _LuaNoGC: ... + +@type_check_only +class _LuaObject: ... + +# classes + +_bint = TypeVar("_bint", bool, int) + +class FastRLock(Generic[_bint]): + # @classmethod + # def __init__(cls, /, *args: Any, **kwargs: Any) -> None: ... + def acquire(self, blocking: _bint = True) -> _bint: ... + def release(self) -> None: ... + def __enter__(self) -> _bint: ... + def __exit__(self, t: object, v: object, tb: object) -> None: ... + +class LuaError(Exception): ... +class LuaSyntaxError(LuaError): ... +class LuaMemoryError(LuaError, MemoryError): ... + +class LuaRuntime: + lua_implementation: Final[str] + lua_version: Final[tuple[int, int]] + + # @classmethod + # def __cinit__(cls, unpack_return_tuples: bool) -> None: ... + # def add_pending_unref(self, ref: int) -> None: ... + # def clean_up_pending_unrefs(self) -> int: ... + def get_max_memory(self, total: bool = False) -> int | MaybeNone: ... + def get_memory_used(self, total: bool = False) -> int | MaybeNone: ... + # def reraise_on_exceptions(self) -> int: ... + # def store_raised_exception(self, L: object, lua_error_msg: str) -> None: ... # unannotated + def eval(self, lua_code: str, *args: Any, name: str | None = None, mode: str | None = None) -> object: ... + def execute(self, lua_code: str, *args: Any, name: str | None = None, mode: str | None = None) -> object: ... + def compile(self, lua_code: str, name: str | None = None, mode: str | None = None) -> Callable[..., object]: ... + def require(self, modulename: str) -> object: ... + def globals(self) -> _LuaTable: ... + def table(self, *items: Any, **kwargs: Any) -> _LuaTable: ... + def table_from(self, *args: Any, recursive: bool = ...) -> _LuaTable: ... + def nogc(self) -> _LuaNoGC: ... + def gccollect(self) -> None: ... + def set_max_memory(self, max_memory: int, total: bool = False) -> None: ... + def set_overflow_handler(self, overflow_handler: Callable[..., None]) -> None: ... + # def register_py_object(self, cname: str, pyname: str, obj: object) -> int: ... + # def init_python_lib(self, register_eval: bool, register_builtins: bool) -> int: ... diff --git a/stubs/lupa/lupa/version.pyi b/stubs/lupa/lupa/version.pyi new file mode 100644 index 000000000..c5dd95466 --- /dev/null +++ b/stubs/lupa/lupa/version.pyi @@ -0,0 +1,3 @@ +from typing import Final + +__version__: Final[str]