Improve toml typings

stubs/toml/toml/__init__.pyi

@@ -0,0 +1,16 @@
+from . import decoder as decoder, encoder as encoder
+
+load = decoder.load
+loads = decoder.loads
+TomlDecoder = decoder.TomlDecoder
+TomlDecodeError = decoder.TomlDecodeError
+TomlPreserveCommentDecoder = decoder.TomlPreserveCommentDecoder
+
+dump = encoder.dump
+dumps = encoder.dumps
+TomlEncoder = encoder.TomlEncoder
+TomlArraySeparatorEncoder = encoder.TomlArraySeparatorEncoder
+TomlPreserveInlineDictEncoder = encoder.TomlPreserveInlineDictEncoder
+TomlNumpyEncoder = encoder.TomlNumpyEncoder
+TomlPreserveCommentEncoder = encoder.TomlPreserveCommentEncoder
+TomlPathlibEncoder = encoder.TomlPathlibEncoder

stubs/toml/toml/decoder.pyi

@@ -0,0 +1,79 @@
+import sys
+from _typeshed import SupportsRead
+from typing import Any, Callable, Generic, MutableMapping, Pattern, Protocol, Text, TypeVar, overload
+
+_MutableMappingT = TypeVar("_MutableMappingT", bound=MutableMapping[str, Any])
+_KT_contra = TypeVar("_KT_contra", contravariant=True)
+_VT = TypeVar("_VT")
+
+if sys.version_info >= (3, 0):
+    from pathlib import PurePath
+
+    FNFError = FileNotFoundError
+    _PathLike = str | bytes | PurePath
+else:
+    FNFError = IOError
+    _PathLike = str | bytes
+
+class _SupportsGetSetItem(Protocol[_KT_contra, _VT]):
+    def __getitem__(self, __k: _KT_contra) -> _VT: ...
+    def __setitem__(self, __k: _KT_contra, __v: _VT) -> None: ...
+
+TIME_RE: Pattern[str]
+
+class TomlDecodeError(ValueError):
+    msg: str
+    doc: str
+    pos: int
+    lineno: int
+    colno: int
+    def __init__(self, msg: str, doc: str, pos: int) -> None: ...
+
+class CommentValue(_SupportsGetSetItem[_KT_contra, _VT]):
+    val: _SupportsGetSetItem[_KT_contra, _VT]
+    comment: str
+    def __init__(
+        self, val: _SupportsGetSetItem[_KT_contra, _VT], comment: str, beginline: bool, _dict: type[_MutableMappingT]
+    ) -> None: ...
+    def __getitem__(self, key: _KT_contra) -> _VT: ...
+    def __setitem__(self, key: _KT_contra, value: _VT) -> None: ...
+    def dump(self, dump_value_func: Callable[[Any], str]) -> str: ...
+
+@overload
+def load(
+    f: _PathLike | list[_PathLike] | SupportsRead[Text],
+    _dict: type[dict[str, Any]] = ...,
+    decoder: TomlDecoder[dict[str, Any]] | None = ...,
+) -> dict[str, Any]: ...
+@overload
+def load(
+    f: _PathLike | list[_PathLike] | SupportsRead[Text],
+    _dict: type[_MutableMappingT],
+    decoder: TomlDecoder[_MutableMappingT] | None = ...,
+) -> _MutableMappingT: ...
+@overload
+def loads(s: Text, _dict: type[_MutableMappingT] = ..., decoder: TomlDecoder[dict[str, Any]] | None = ...) -> dict[str, Any]: ...
+@overload
+def loads(s: Text, _dict: type[_MutableMappingT], decoder: TomlDecoder[_MutableMappingT] | None = ...) -> _MutableMappingT: ...
+
+class InlineTableDict: ...
+
+class TomlDecoder(Generic[_MutableMappingT]):
+    _dict: type[_MutableMappingT]
+    def __init__(self, _dict: type[_MutableMappingT] = ...) -> None: ...
+    def get_empty_table(self) -> _MutableMappingT: ...
+    def get_empty_inline_table(self) -> InlineTableDict: ...  # incomplete python/typing#213
+    def load_inline_object(
+        self, line: str, currentlevel: _MutableMappingT, multikey: bool = ..., multibackslash: bool = ...
+    ) -> None: ...
+    def load_line(
+        self, line: str, currentlevel: _MutableMappingT, multikey: bool | None, multibackslash: bool
+    ) -> tuple[bool | None, str, bool] | None: ...
+    def load_value(self, v: str, strictly_valid: bool = ...) -> tuple[Any, str]: ...
+    def bounded_string(self, s: str) -> bool: ...
+    def load_array(self, a: str) -> list[Any]: ...
+    def preserve_comment(self, line_no: int, key: str, comment: str, beginline: bool) -> None: ...
+    def embed_comments(self, idx: int, currentlevel: _MutableMappingT) -> None: ...
+
+class TomlPreserveCommentDecoder(TomlDecoder[_MutableMappingT]):
+    saved_comments: MutableMapping[int, tuple[str, str, bool]]

stubs/toml/toml/encoder.pyi

@@ -0,0 +1,30 @@
+from _typeshed import SupportsWrite
+from typing import Any, Callable, Generic, Iterable, Mapping, MutableMapping, TypeVar
+
+_MappingT = TypeVar("_MappingT", bound=Mapping[str, Any])
+
+def dump(o: _MappingT, f: SupportsWrite[str], encoder: TomlEncoder[_MappingT] | None = ...) -> str: ...
+def dumps(o: _MappingT, encoder: TomlEncoder[_MappingT] | None = ...) -> str: ...
+
+class TomlEncoder(Generic[_MappingT]):
+    _dict: type[_MappingT]
+    preserve: bool
+    dump_funcs: MutableMapping[type[Any], Callable[[Any], str]]
+    def __init__(self, _dict: type[_MappingT] = ..., preserve: bool = ...) -> None: ...
+    def get_empty_table(self) -> _MappingT: ...
+    def dump_list(self, v: Iterable[object]) -> str: ...
+    def dump_inline_table(self, section: dict[str, Any] | Any) -> str: ...
+    def dump_value(self, v: Any) -> str: ...
+    def dump_sections(self, o: _MappingT, sup: str) -> tuple[str, _MappingT]: ...
+
+class TomlPreserveInlineDictEncoder(TomlEncoder[_MappingT]):
+    def __init__(self, _dict: type[Mapping[str, _MappingT]] = ...) -> None: ...
+
+class TomlArraySeparatorEncoder(TomlEncoder[_MappingT]):
+    separator: str
+    def __init__(self, _dict: type[Mapping[str, _MappingT]] = ..., preserve: bool = ..., separator: str = ...) -> None: ...
+    def dump_list(self, v: Iterable[Any]) -> str: ...
+
+class TomlNumpyEncoder(TomlEncoder[_MappingT]): ...
+class TomlPreserveCommentEncoder(TomlEncoder[_MappingT]): ...
+class TomlPathlibEncoder(TomlEncoder[_MappingT]): ...

stubs/toml/toml/ordered.pyi

@@ -0,0 +1,13 @@
+from typing import Any, Mapping, MutableMapping, TypeVar
+
+from .decoder import TomlDecoder
+from .encoder import TomlEncoder
+
+_MutableMappingT = TypeVar("_MutableMappingT", bound=MutableMapping[str, Any])
+_MappingT = TypeVar("_MappingT", bound=Mapping[str, Any])
+
+class TomlOrderedDecoder(TomlDecoder[_MutableMappingT]):
+    def __init__(self) -> None: ...
+
+class TomlOrderedEncoder(TomlEncoder[_MappingT]):
+    def __init__(self) -> None: ...

stubs/toml/toml/tz.pyi

@@ -0,0 +1,10 @@
+from _typeshed import Self
+from datetime import datetime, timedelta, tzinfo
+from typing import Any
+
+class TomlTz(tzinfo):
+    def __init__(self, toml_offset: str) -> None: ...
+    def __deepcopy__(self: Self, memo: Any) -> Self: ...
+    def tzname(self, dt: datetime | None) -> str: ...
+    def utcoffset(self, dt: datetime | None) -> timedelta: ...
+    def dst(self, dt: datetime | None) -> timedelta: ...