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,57 @@
+import sys
+from _typeshed import StrPath, SupportsRead
+from typing import Any, Callable, Generic, MutableMapping, Pattern, Text, TypeVar
+
+_T = TypeVar("_T")
+
+if sys.version_info >= (3, 3):
+    FNFError = FileNotFoundError
+else:
+    FNFError = IOError
+
+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(Generic[_T]):
+    val: _T
+    comment: str
+    def __init__(self, val: _T, comment: str, beginline: bool, _dict: type[MutableMapping[str, _T]]) -> None: ...
+    def __getitem__(self, key: _T) -> _T: ...
+    def __setitem__(self, key: _T, value: _T) -> None: ...
+    def dump(self, dump_value_func: Callable[[_T], str]) -> str: ...
+
+def load(
+    f: StrPath | list[Text] | SupportsRead[str], _dict: type[MutableMapping[str, _T]] = ..., decoder: TomlDecoder[_T] | None = ...
+) -> MutableMapping[str, _T]: ...
+def loads(
+    s: Text, _dict: type[MutableMapping[str, _T]] = ..., decoder: TomlDecoder[_T] | None = ...
+) -> MutableMapping[str, _T]: ...
+
+class InlineTableDict: ...
+
+class TomlDecoder(Generic[_T]):
+    _dict: type[MutableMapping[str, _T]]
+    def __init__(self, _dict: type[MutableMapping[str, _T]] = ...) -> None: ...
+    def get_empty_table(self) -> MutableMapping[str, _T]: ...
+    def get_empty_inline_table(self) -> InlineTableDict: ...  # incomplete python/typing#213
+    def load_inline_object(
+        self, line: str, currentlevel: MutableMapping[str, _T], multikey: bool = ..., multibackslash: bool = ...
+    ) -> None: ...
+    def load_line(
+        self, line: str, currentlevel: MutableMapping[str, _T], 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[_T]: ...
+    def preserve_comment(self, line_no: int, key: str, comment: str, beginline: bool) -> None: ...
+    def embed_comments(self, idx: int, currentlevel: MutableMapping[str, _T]) -> None: ...
+
+class TomlPreserveCommentDecoder(TomlDecoder[_T]):
+    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
+
+_T = TypeVar("_T")
+
+def dump(o: Mapping[str, _T], f: SupportsWrite[str], encoder: TomlEncoder[_T] | None = ...) -> str: ...
+def dumps(o: Mapping[str, _T], encoder: TomlEncoder[_T] | None = ...) -> str: ...
+
+class TomlEncoder(Generic[_T]):
+    _dict: type[Mapping[str, _T]]
+    preserve: bool
+    dump_funcs: MutableMapping[type[Any], Callable[[Any], str]]
+    def __init__(self, _dict: type[Mapping[str, _T]] = ..., preserve: bool = ...) -> None: ...
+    def get_empty_table(self) -> Mapping[str, _T]: ...
+    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: Mapping[str, _T], sup: str) -> tuple[str, Mapping[str, _T]]: ...
+
+class TomlPreserveInlineDictEncoder(TomlEncoder[_T]):
+    def __init__(self, _dict: type[Mapping[str, _T]] = ...) -> None: ...
+
+class TomlArraySeparatorEncoder(TomlEncoder[_T]):
+    separator: str
+    def __init__(self, _dict: type[Mapping[str, _T]] = ..., preserve: bool = ..., separator: str = ...) -> None: ...
+    def dump_list(self, v: Iterable[Any]) -> str: ...
+
+class TomlNumpyEncoder(TomlEncoder[_T]): ...
+class TomlPreserveCommentEncoder(TomlEncoder[_T]): ...
+class TomlPathlibEncoder(TomlEncoder[_T]): ...

stubs/toml/toml/ordered.pyi

@@ -0,0 +1,12 @@
+from typing import TypeVar
+
+from .decoder import TomlDecoder
+from .encoder import TomlEncoder
+
+_T = TypeVar("_T")
+
+class TomlOrderedDecoder(TomlDecoder[_T]):
+    def __init__(self) -> None: ...
+
+class TomlOrderedEncoder(TomlEncoder[_T]):
+    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: ...