basedpyright 1.28.4 → 1.28.5

package/dist/typeshed-fallback/stubs/passlib/passlib/handlers/django.pyi

@@ -79,3 +79,14 @@ class django_disabled(DisabledHash, uh.StaticHandler):
     def identify(cls, hash: str | bytes) -> bool: ...
     @classmethod
     def verify(cls, secret: str | bytes, hash: str | bytes) -> bool: ...  # type: ignore[override]
+
+__all__ = [
+    "django_salted_sha1",
+    "django_salted_md5",
+    "django_bcrypt",
+    "django_pbkdf2_sha1",
+    "django_pbkdf2_sha256",
+    "django_argon2",
+    "django_des_crypt",
+    "django_disabled",
+]

package/dist/typeshed-fallback/stubs/passlib/passlib/handlers/fshp.pyi

@@ -24,3 +24,5 @@ class fshp(uh.HasRounds, uh.HasRawSalt, uh.HasRawChecksum, uh.GenericHandler):
     def checksum_size(self): ...
     @classmethod
     def from_string(cls, hash): ...
+
+__all__ = ["fshp"]

package/dist/typeshed-fallback/stubs/passlib/passlib/handlers/md5_crypt.pyi

@@ -18,3 +18,5 @@ class md5_crypt(uh.HasManyBackends, _MD5_Common):
 class apr_md5_crypt(_MD5_Common):
     name: ClassVar[str]
     ident: ClassVar[str]
+
+__all__ = ["md5_crypt", "apr_md5_crypt"]

package/dist/typeshed-fallback/stubs/passlib/passlib/handlers/misc.pyi

@@ -48,3 +48,5 @@ class plaintext(uh.MinimalHandler):
     def genconfig(cls): ...
     @classmethod
     def genhash(cls, secret, config, encoding: str | None = None): ...  # type: ignore[override]
+
+__all__ = ["unix_disabled", "unix_fallback", "plaintext"]

package/dist/typeshed-fallback/stubs/passlib/passlib/handlers/mssql.pyi

@@ -19,3 +19,5 @@ class mssql2005(uh.HasRawSalt, uh.HasRawChecksum, uh.GenericHandler):
     max_salt_size: ClassVar[int]
     @classmethod
     def from_string(cls, hash): ...
+
+__all__ = ["mssql2000", "mssql2005"]

package/dist/typeshed-fallback/stubs/passlib/passlib/handlers/pbkdf2.pyi

@@ -87,3 +87,5 @@ class grub_pbkdf2_sha512(uh.HasRounds, uh.HasRawSalt, uh.HasRawChecksum, uh.Gene
     rounds_cost: ClassVar[str]
     @classmethod
     def from_string(cls, hash): ...
+
+__all__ = ["pbkdf2_sha1", "pbkdf2_sha256", "pbkdf2_sha512", "cta_pbkdf2_sha1", "dlitz_pbkdf2_sha1", "grub_pbkdf2_sha512"]

package/dist/typeshed-fallback/stubs/passlib/passlib/handlers/phpass.pyi

@@ -18,3 +18,5 @@ class phpass(uh.HasManyIdents, uh.HasRounds, uh.HasSalt, uh.GenericHandler):  #
     ident_aliases: ClassVar[dict[str, str]]
     @classmethod
     def from_string(cls, hash: str | bytes) -> Self: ...  # type: ignore[override]
+
+__all__ = ["phpass"]

package/dist/typeshed-fallback/stubs/passlib/passlib/handlers/postgres.pyi

@@ -6,3 +6,5 @@ class postgres_md5(uh.HasUserContext, uh.StaticHandler):
     name: ClassVar[str]
     checksum_chars: ClassVar[str]
     checksum_size: ClassVar[int]
+
+__all__ = ["postgres_md5"]

package/dist/typeshed-fallback/stubs/passlib/passlib/handlers/roundup.pyi

@@ -3,3 +3,5 @@ from typing import Any
 roundup_plaintext: Any
 ldap_hex_md5: Any
 ldap_hex_sha1: Any
+
+__all__ = ["roundup_plaintext", "ldap_hex_md5", "ldap_hex_sha1"]

package/dist/typeshed-fallback/stubs/passlib/passlib/handlers/scram.pyi

@@ -27,3 +27,5 @@ class scram(uh.HasRounds, uh.HasRawSalt, uh.HasRawChecksum, uh.GenericHandler):
     def __init__(self, algs: Incomplete | None = None, **kwds) -> None: ...
     @classmethod
     def verify(cls, secret, hash, full: bool = False): ...  # type: ignore[override]
+
+__all__ = ["scram"]

package/dist/typeshed-fallback/stubs/passlib/passlib/handlers/scrypt.pyi

@@ -31,3 +31,5 @@ class scrypt(uh.ParallelismMixin, uh.HasRounds, uh.HasRawSalt, uh.HasRawChecksum
     def has_backend(cls, name: str = "any"): ...
     @classmethod
     def set_backend(cls, name: str = "any", dryrun: bool = False) -> None: ...
+
+__all__ = ["scrypt"]

package/dist/typeshed-fallback/stubs/passlib/passlib/handlers/sha1_crypt.pyi

@@ -21,3 +21,5 @@ class sha1_crypt(uh.HasManyBackends, uh.HasRounds, uh.HasSalt, uh.GenericHandler
     def from_string(cls, hash: str | bytes) -> Self: ...  # type: ignore[override]
     def to_string(self, config: bool = False) -> str: ...
     backends: ClassVar[tuple[str, ...]]
+
+__all__: list[str] = []

package/dist/typeshed-fallback/stubs/passlib/passlib/handlers/sha2_crypt.pyi

@@ -27,3 +27,5 @@ class sha512_crypt(_SHA2_Common):
     ident: ClassVar[str]
     checksum_size: ClassVar[int]
     default_rounds: ClassVar[int]
+
+__all__ = ["sha512_crypt", "sha256_crypt"]

package/dist/typeshed-fallback/stubs/passlib/passlib/handlers/sun_md5_crypt.pyi

@@ -22,3 +22,5 @@ class sun_md5_crypt(uh.HasRounds, uh.HasSalt, uh.GenericHandler):  # type: ignor
     @classmethod
     def from_string(cls, hash: str | bytes) -> Self: ...  # type: ignore[override]
     def to_string(self, _withchk: bool = True) -> str: ...
+
+__all__ = ["sun_md5_crypt"]

package/dist/typeshed-fallback/stubs/passlib/passlib/handlers/windows.pyi

@@ -1,5 +1,5 @@
 from _typeshed import Incomplete
-from typing import Any, ClassVar
+from typing import Any, ClassVar, Literal, overload
 
 import passlib.utils.handlers as uh
 
@@ -17,8 +17,15 @@ class nthash(uh.StaticHandler):
     checksum_size: ClassVar[int]
     @classmethod
     def raw(cls, secret): ...
+    @overload
     @classmethod
-    def raw_nthash(cls, secret, hex: bool = False): ...
+    def raw_nthash(cls, secret: str | bytes, hex: Literal[True]) -> str: ...
+    @overload
+    @classmethod
+    def raw_nthash(cls, secret: str | bytes, hex: Literal[False] = False) -> bytes: ...
+    @overload
+    @classmethod
+    def raw_nthash(cls, secret: str | bytes, hex: bool = False) -> str | bytes: ...
 
 bsd_nthash: Any
 
@@ -35,3 +42,5 @@ class msdcc2(uh.HasUserContext, uh.StaticHandler):
     checksum_size: ClassVar[int]
     @classmethod
     def raw(cls, secret, user): ...
+
+__all__ = ["lmhash", "nthash", "bsd_nthash", "msdcc", "msdcc2"]

package/dist/typeshed-fallback/stubs/passlib/passlib/hosts.pyi

@@ -1,13 +1,15 @@
 import sys
-from typing import Any
 
 from passlib.context import CryptContext
 
-linux_context: Any
-linux2_context: Any
-freebsd_context: Any
-openbsd_context: Any
-netbsd_context: Any
+linux_context: CryptContext
+linux2_context: CryptContext
+freebsd_context: CryptContext
+openbsd_context: CryptContext
+netbsd_context: CryptContext
 # Only exists if crypt is present
-if sys.version_info < (3, 13):
+if sys.version_info < (3, 13) and sys.platform != "win32":
     host_context: CryptContext
+    __all__ = ["linux_context", "linux2_context", "openbsd_context", "netbsd_context", "freebsd_context", "host_context"]
+else:
+    __all__ = ["linux_context", "linux2_context", "openbsd_context", "netbsd_context", "freebsd_context"]

package/dist/typeshed-fallback/stubs/passlib/passlib/ifc.pyi

@@ -35,3 +35,5 @@ class DisabledHash(PasswordHash, metaclass=ABCMeta):
     def disable(cls, hash: str | None = None) -> str: ...
     @classmethod
     def enable(cls, hash: str) -> str: ...
+
+__all__ = ["PasswordHash"]

package/dist/typeshed-fallback/stubs/passlib/passlib/pwd.pyi

@@ -1,60 +1,142 @@
-from _typeshed import Incomplete
+import random
 from abc import abstractmethod
-from collections.abc import MutableMapping
-from typing import Any
+from collections.abc import Callable, Iterator, MutableMapping, Sequence
+from typing import Any, Final, Literal, overload
+from typing_extensions import Self, TypeAlias
 
 class SequenceGenerator:
-    length: Any
+    length: int | None
     requested_entropy: str
-    rng: Any
+    rng: random.Random
     @property
     @abstractmethod
     def symbol_count(self) -> int: ...
-    def __init__(
-        self, entropy: Incomplete | None = None, length: Incomplete | None = None, rng: Incomplete | None = None, **kwds
-    ) -> None: ...
+    def __init__(self, entropy: int | None = None, length: int | None = None, rng: random.Random | None = None) -> None: ...
     @property
     def entropy_per_symbol(self) -> float: ...
     @property
     def entropy(self) -> float: ...
-    def __next__(self) -> None: ...
-    def __call__(self, returns: Incomplete | None = None): ...
-    def __iter__(self): ...
+    def __next__(self) -> str: ...
+    @overload
+    def __call__(self, returns: None = None) -> str: ...
+    @overload
+    def __call__(self, returns: int) -> list[str]: ...
+    @overload
+    def __call__(self, returns: Callable[[Any], Iterator[Any]]) -> Iterator[str]: ...  # "returns" must be the "iter" builtin
+    def __iter__(self) -> Self: ...
 
-default_charsets: Any
+_Charset: TypeAlias = Literal["ascii_72", "ascii_62", "ascii_50", "hex"]
+default_charsets: Final[dict[_Charset, str]]
 
 class WordGenerator(SequenceGenerator):
-    charset: str
-    chars: Any
-    def __init__(self, chars: Incomplete | None = None, charset: Incomplete | None = None, **kwds) -> None: ...
+    charset: _Charset
+    chars: str | bytes | None
+    def __init__(
+        self,
+        chars: str | bytes | None = None,
+        charset: _Charset | None = None,
+        *,
+        entropy: int | None = None,
+        length: int | None = None,
+        rng: random.Random | None = None,
+    ) -> None: ...
     @property
-    def symbol_count(self): ...
-    def __next__(self): ...
+    def symbol_count(self) -> int: ...
 
-def genword(entropy: Incomplete | None = None, length: Incomplete | None = None, returns: Incomplete | None = None, **kwds): ...
+@overload
+def genword(
+    entropy: int | None = None,
+    length: int | None = None,
+    returns: None = None,
+    *,
+    chars: str | None = None,
+    charset: _Charset | None = None,
+    rng: random.Random | None = None,
+) -> str: ...
+@overload
+def genword(
+    returns: int,
+    entropy: int | None = None,
+    length: int | None = None,
+    *,
+    chars: str | None = None,
+    charset: _Charset | None = None,
+    rng: random.Random | None = None,
+) -> list[str]: ...
+@overload
+def genword(
+    returns: Callable[[Any], Iterator[Any]],
+    entropy: int | None = None,
+    length: int | None = None,
+    *,
+    chars: str | None = None,
+    charset: _Charset | None = None,
+    rng: random.Random | None = None,
+) -> Iterator[str]: ...
 
 class WordsetDict(MutableMapping[Any, Any]):
-    paths: Any
+    paths: dict[str, str] | None
     def __init__(self, *args, **kwds) -> None: ...
-    def __getitem__(self, key): ...
-    def set_path(self, key, path) -> None: ...
-    def __setitem__(self, key, value) -> None: ...
-    def __delitem__(self, key) -> None: ...
-    def __iter__(self): ...
+    def __getitem__(self, key: str) -> tuple[str | bytes, ...]: ...
+    def set_path(self, key: str, path: str) -> None: ...
+    def __setitem__(self, key: str, value: tuple[str | bytes, ...]) -> None: ...
+    def __delitem__(self, key: str) -> None: ...
+    def __iter__(self) -> Iterator[str]: ...
     def __len__(self) -> int: ...
-    def __contains__(self, key): ...
+    def __contains__(self, key: object) -> bool: ...
 
-default_wordsets: Any
+default_wordsets: WordsetDict
+_Wordset: TypeAlias = Literal["eff_long", "eff_short", "eff_prefixed", "bip39"]
 
 class PhraseGenerator(SequenceGenerator):
-    wordset: str
-    words: Any
-    sep: str
+    wordset: _Wordset
+    words: Sequence[str | bytes] | None
+    sep: str | None
     def __init__(
-        self, wordset: Incomplete | None = None, words: Incomplete | None = None, sep: Incomplete | None = None, **kwds
+        self,
+        wordset: _Wordset | None = None,
+        words: Sequence[str | bytes] | None = None,
+        sep: str | bytes | None = None,
+        *,
+        entropy: int | None = None,
+        length: int | None = None,
+        rng: random.Random | None = None,
     ) -> None: ...
     @property
-    def symbol_count(self): ...
-    def __next__(self): ...
+    def symbol_count(self) -> int: ...
+
+@overload
+def genphrase(
+    entropy: int | None = None,
+    length: int | None = None,
+    returns: None = None,
+    *,
+    wordset: _Wordset | None = None,
+    words: Sequence[str | bytes] | None = None,
+    sep: str | bytes | None = None,
+    rng: random.Random | None = None,
+) -> str: ...
+@overload
+def genphrase(
+    returns: int,
+    entropy: int | None = None,
+    length: int | None = None,
+    *,
+    wordset: _Wordset | None = None,
+    words: Sequence[str | bytes] | None = None,
+    sep: str | bytes | None = None,
+    rng: random.Random | None = None,
+) -> list[str]: ...
+@overload
+def genphrase(
+    returns: Callable[[Any], Iterator[Any]],
+    entropy: int | None = None,
+    length: int | None = None,
+    *,
+    wordset: _Wordset | None = None,
+    words: Sequence[str | bytes] | None = None,
+    sep: str | bytes | None = None,
+    rng: random.Random | None = None,
+) -> Iterator[str]: ...
 
-def genphrase(entropy: Incomplete | None = None, length: Incomplete | None = None, returns: Incomplete | None = None, **kwds): ...
+__all__ = ["genword", "default_charsets", "genphrase", "default_wordsets"]

package/dist/typeshed-fallback/stubs/passlib/passlib/registry.pyi

@@ -1,14 +1,17 @@
-from _typeshed import Incomplete
 from typing import Any
 
 class _PasslibRegistryProxy:
     __name__: str
-    __package__: Any
-    def __getattr__(self, attr: str): ...
+    __package__: str | None
+    def __getattr__(self, attr: str) -> Any: ...  # returns handler that is a value from object.__dict__
     def __setattr__(self, attr: str, value) -> None: ...
-    def __dir__(self): ...
+    def __dir__(self) -> list[str]: ...
 
-def register_crypt_handler_path(name, path) -> None: ...
-def register_crypt_handler(handler, force: bool = False, _attr: Incomplete | None = None) -> None: ...
-def get_crypt_handler(name, default=...): ...
-def list_crypt_handlers(loaded_only: bool = False): ...
+def register_crypt_handler_path(name: str, path: str) -> None: ...
+def register_crypt_handler(
+    handler: Any, force: bool = False, _attr: str | None = None
+) -> None: ...  # expected handler is object with attr handler.name
+def get_crypt_handler(name: str, default: Any = ...) -> Any: ...  # returns handler or default
+def list_crypt_handlers(loaded_only: bool = False) -> list[str]: ...
+
+__all__ = ["register_crypt_handler_path", "register_crypt_handler", "get_crypt_handler", "list_crypt_handlers"]

package/dist/typeshed-fallback/stubs/passlib/passlib/totp.pyi

@@ -146,3 +146,14 @@ class TotpMatch(SequenceMixin):
     def cache_seconds(self) -> int: ...
     @property
     def cache_time(self) -> int: ...
+
+__all__ = [
+    "AppWallet",
+    "TOTP",
+    "TokenError",
+    "MalformedTokenError",
+    "InvalidTokenError",
+    "UsedTokenError",
+    "TotpToken",
+    "TotpMatch",
+]

package/dist/typeshed-fallback/stubs/passlib/passlib/utils/__init__.pyi

@@ -1,8 +1,9 @@
+import random
 import timeit
-from _typeshed import Incomplete
-from collections.abc import Generator
+from _typeshed import ReadableBuffer
+from collections.abc import Iterable
 from hmac import compare_digest
-from typing import Any
+from typing import Final, Literal, SupportsBytes, SupportsIndex, overload
 
 from passlib.utils.compat import JYTHON as JYTHON
 
@@ -34,9 +35,9 @@ __all__ = [
     "has_salt_info",
 ]
 
-sys_bits: Any
+sys_bits: Final[int]
 unix_crypt_schemes: list[str]
-rounds_cost_values: Any
+rounds_cost_values: Final[list[str]]
 
 class SequenceMixin:
     def __getitem__(self, idx): ...
@@ -47,29 +48,40 @@ class SequenceMixin:
 
 consteq = compare_digest
 
-def str_consteq(left, right): ...
-def saslprep(source, param: str = "value"): ...
-def render_bytes(source, *args): ...
-def xor_bytes(left, right): ...
-def is_same_codec(left, right): ...
-def is_ascii_safe(source): ...
-def to_bytes(source, encoding: str = "utf-8", param: str = "value", source_encoding: Incomplete | None = None): ...
-def to_unicode(source, encoding: str = "utf-8", param: str = "value"): ...
-def to_native_str(source, encoding: str = "utf-8", param: str = "value"): ...
+def str_consteq(left: str | bytes, right: str | bytes) -> bool: ...
+def splitcomma(source: str, sep: str = ",") -> list[str]: ...
+def saslprep(source: str, param: str = "value") -> str: ...
+def render_bytes(source: str | bytes, *args: str | bytes) -> bytes: ...
+def bytes_to_int(value: Iterable[SupportsIndex] | SupportsBytes | ReadableBuffer) -> int: ...
+def int_to_bytes(value: int, count: SupportsIndex) -> bytes: ...
+def xor_bytes(
+    left: Iterable[SupportsIndex] | SupportsBytes | ReadableBuffer,
+    right: Iterable[SupportsIndex] | SupportsBytes | ReadableBuffer,
+) -> bytes: ...
+def repeat_string(source: str | bytes, size: int) -> str | bytes: ...
+def is_ascii_codec(codec: str) -> bool: ...
+def is_same_codec(left: str, right: str) -> bool: ...
+def is_ascii_safe(source: str | bytes) -> bool: ...
+def to_bytes(source: str | bytes, encoding: str = "utf-8", param: str = "value", source_encoding: str | None = None) -> bytes: ...
+def to_unicode(source: str | bytes, encoding: str = "utf-8", param: str = "value") -> str: ...
+def to_native_str(source: str | bytes, encoding: str = "utf-8", param: str = "value") -> str: ...
 
 has_crypt: bool
 
-def safe_crypt(secret, hash) -> None: ...
-def test_crypt(secret, hash): ...
+def safe_crypt(secret: str | bytes, hash: str | bytes) -> str | None: ...
+def test_crypt(secret: str | bytes, hash: str) -> bool: ...
 
 timer = timeit.default_timer
 tick = timer
-rng: Any
+rng: random.Random
 
-def getrandbytes(rng, count) -> Generator[None, None, Any]: ...
-def getrandstr(rng, charset, count) -> Generator[None, None, Any]: ...
-def generate_password(size: int = 10, charset=...): ...
-def is_crypt_handler(obj): ...
-def is_crypt_context(obj): ...
-def has_rounds_info(handler): ...
-def has_salt_info(handler): ...
+@overload
+def getrandbytes(rng: random.Random, count: None) -> Literal[b""]: ...
+@overload
+def getrandbytes(rng: random.Random, count) -> bytes: ...
+def getrandstr(rng: random.Random, charset: str, count: int) -> str: ...
+def generate_password(size: int = 10, charset: str = ...) -> str: ...
+def is_crypt_handler(obj) -> bool: ...
+def is_crypt_context(obj) -> bool: ...
+def has_rounds_info(handler) -> bool: ...
+def has_salt_info(handler) -> bool: ...

package/dist/typeshed-fallback/stubs/passlib/passlib/utils/binary.pyi

@@ -1,23 +1,26 @@
-from _typeshed import Incomplete
-from typing import Any
+from _typeshed import ReadableBuffer
+from logging import Logger
+from typing import Any, Final
 
-BASE64_CHARS: Any
-AB64_CHARS: Any
-HASH64_CHARS: Any
-BCRYPT_CHARS: Any
-PADDED_BASE64_CHARS: Any
-HEX_CHARS: Any
-UPPER_HEX_CHARS: Any
-LOWER_HEX_CHARS: Any
-ALL_BYTE_VALUES: Any
+log: Logger
 
-def compile_byte_translation(mapping, source: Incomplete | None = None): ...
-def b64s_encode(data): ...
-def b64s_decode(data): ...
-def ab64_encode(data): ...
-def ab64_decode(data): ...
-def b32encode(source): ...
-def b32decode(source): ...
+BASE64_CHARS: Final[str]
+AB64_CHARS: Final[str]
+HASH64_CHARS: Final[str]
+BCRYPT_CHARS: Final[str]
+PADDED_BASE64_CHARS: Final[str]
+HEX_CHARS: Final[str]
+UPPER_HEX_CHARS: Final[str]
+LOWER_HEX_CHARS: Final[str]
+ALL_BYTE_VALUES: Final[bytes]
+
+def compile_byte_translation(mapping: dict[str | bytes | int, str | bytes], source: bytes | None = None) -> bytes: ...
+def b64s_encode(data: ReadableBuffer) -> bytes: ...
+def b64s_decode(data: str | ReadableBuffer) -> bytes: ...
+def ab64_encode(data: ReadableBuffer) -> bytes: ...
+def ab64_decode(data: str | ReadableBuffer) -> bytes: ...
+def b32encode(source: ReadableBuffer) -> str: ...
+def b32decode(source: str | bytes) -> bytes: ...
 
 class Base64Engine:
     bytemap: Any
@@ -46,6 +49,35 @@ class LazyBase64Engine(Base64Engine):
     def __init__(self, *args, **kwds) -> None: ...
     def __getattribute__(self, attr: str): ...
 
-h64: Any
-h64big: Any
-bcrypt64: Any
+h64: Base64Engine
+h64big: Base64Engine
+bcrypt64: Base64Engine
+
+__all__ = [
+    # constants
+    "BASE64_CHARS",
+    "PADDED_BASE64_CHARS",
+    "AB64_CHARS",
+    "HASH64_CHARS",
+    "BCRYPT_CHARS",
+    "HEX_CHARS",
+    "LOWER_HEX_CHARS",
+    "UPPER_HEX_CHARS",
+    "ALL_BYTE_VALUES",
+    # misc
+    "compile_byte_translation",
+    # base64
+    "ab64_encode",
+    "ab64_decode",
+    "b64s_encode",
+    "b64s_decode",
+    # base32
+    "b32encode",
+    "b32decode",
+    # custom encodings
+    "Base64Engine",
+    "LazyBase64Engine",
+    "h64",
+    "h64big",
+    "bcrypt64",
+]

package/dist/typeshed-fallback/stubs/passlib/passlib/utils/decor.pyi

@@ -40,3 +40,12 @@ def deprecated_method(
     updoc: bool = True,
     replacement: Incomplete | None = None,
 ): ...
+
+__all__ = [
+    "classproperty",
+    "hybrid_method",
+    "memoize_single_value",
+    "memoized_property",
+    "deprecated_function",
+    "deprecated_method",
+]

package/dist/typeshed-fallback/stubs/passlib/passlib/utils/handlers.pyi

@@ -183,3 +183,23 @@ class PrefixWrapper:
     def encrypt(self, secret, **kwds): ...
     def hash(self, secret, **kwds): ...
     def verify(self, secret, hash, **kwds): ...
+
+__all__ = [
+    # helpers for implementing MCF handlers
+    "parse_mc2",
+    "parse_mc3",
+    "render_mc2",
+    "render_mc3",
+    # framework for implementing handlers
+    "GenericHandler",
+    "StaticHandler",
+    "HasUserContext",
+    "HasRawChecksum",
+    "HasManyIdents",
+    "HasSalt",
+    "HasRawSalt",
+    "HasRounds",
+    "HasManyBackends",
+    # other helpers
+    "PrefixWrapper",
+]

package/dist/typeshed-fallback/stubs/passlib/passlib/utils/md4.pyi

@@ -1,3 +1,5 @@
 from typing import Any
 
 md4: Any
+
+__all__ = ["md4"]

package/dist/typeshed-fallback/stubs/passlib/passlib/utils/pbkdf2.pyi

@@ -5,3 +5,13 @@ from passlib.crypto.digest import norm_hash_name as norm_hash_name
 def get_prf(name): ...
 def pbkdf1(secret, salt, rounds, keylen: Incomplete | None = None, hash: str = "sha1"): ...
 def pbkdf2(secret, salt, rounds, keylen: Incomplete | None = None, prf: str = "hmac-sha1"): ...
+
+__all__ = [
+    # hash utils
+    "norm_hash_name",
+    # prf utils
+    "get_prf",
+    # kdfs
+    "pbkdf1",
+    "pbkdf2",
+]

package/dist/typeshed-fallback/stubs/passlib/passlib/win32.pyi

@@ -1,7 +1,16 @@
-from typing import Any
+from binascii import hexlify as hexlify
+from typing import Final, Literal, overload
 
-from passlib.hash import nthash as nthash
+from passlib.handlers.windows import nthash as nthash
 
-raw_nthash: Any
+LM_MAGIC: Final[bytes]
+raw_nthash = nthash.raw_nthash
 
-def raw_lmhash(secret, encoding: str = "ascii", hex: bool = False): ...
+@overload
+def raw_lmhash(secret: str | bytes, encoding: str = "ascii", hex: Literal[False] = False) -> bytes: ...
+@overload
+def raw_lmhash(secret: str | bytes, encoding: str, hex: Literal[True]) -> str: ...
+@overload
+def raw_lmhash(secret: str | bytes, *, hex: Literal[True]) -> str: ...
+
+__all__ = ["nthash", "raw_lmhash", "raw_nthash"]