diff --git a/pyrightconfig.stricter.json b/pyrightconfig.stricter.json index 05e6455833a1..c56e60464758 100644 --- a/pyrightconfig.stricter.json +++ b/pyrightconfig.stricter.json @@ -92,6 +92,7 @@ "stubs/reportlab", "stubs/requests", "stubs/requests-oauthlib", + "stubs/ruamel.yaml", "stubs/seaborn", "stubs/setuptools/setuptools", "stubs/shapely", diff --git a/stubs/ruamel.yaml/METADATA.toml b/stubs/ruamel.yaml/METADATA.toml new file mode 100644 index 000000000000..6bd5f97bb141 --- /dev/null +++ b/stubs/ruamel.yaml/METADATA.toml @@ -0,0 +1,6 @@ +version = "0.18.*" +upstream_repository = "https://sourceforge.net/p/ruamel-yaml/code/" + +[tool.stubtest] +skip = true # mypy parse errors in upstream package +stubtest_requirements = ["configobj"] diff --git a/stubs/ruamel.yaml/_ruamel_yaml.pyi b/stubs/ruamel.yaml/_ruamel_yaml.pyi new file mode 100644 index 000000000000..e95ff1e06ded --- /dev/null +++ b/stubs/ruamel.yaml/_ruamel_yaml.pyi @@ -0,0 +1,55 @@ +from _typeshed import SupportsRead, SupportsWrite +from collections.abc import Mapping, Sequence + +from ruamel.yaml.events import Event +from ruamel.yaml.nodes import Node +from ruamel.yaml.tokens import Token + +def get_version_string() -> str: ... +def get_version() -> tuple[int, int, int]: ... + +class Mark: + name: str | None + index: int + line: int + column: int + buffer: None + pointer: None + def __init__(self, name: str | None, index: int, line: int, column: int, buffer: None, pointer: None) -> None: ... + def get_snippet(self) -> None: ... + +class CParser: + def __init__(self, stream: str | bytes | SupportsRead[str | bytes]) -> None: ... + def dispose(self) -> None: ... + def get_token(self) -> Token | None: ... + def peek_token(self) -> Token | None: ... + def check_token(self, *choices: type[Token]) -> bool: ... + def get_event(self) -> Event | None: ... + def peek_event(self) -> Event | None: ... + def check_event(self, *choices: type[Token]) -> bool: ... + def check_node(self) -> bool: ... + def get_node(self) -> Node | None: ... + def get_single_node(self) -> Node | None: ... + def raw_parse(self) -> int: ... + def raw_scan(self) -> int: ... + +class CEmitter: + def __init__( + self, + stream: SupportsWrite[str | bytes], + canonical: bool | None = ..., + indent: int | None = ..., + width: int | None = ..., + allow_unicode: bool | None = ..., + line_break: str | None = ..., + encoding: str | None = ..., + explicit_start: bool | None = ..., + explicit_end: bool | None = ..., + version: Sequence[int] | None = ..., + tags: Mapping[str, str] | None = ..., + ) -> None: ... + def dispose(self) -> None: ... + def emit(self, event_object: Event) -> None: ... + def open(self) -> None: ... + def close(self) -> None: ... + def serialize(self, node: Node) -> None: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/__init__.pyi b/stubs/ruamel.yaml/ruamel/yaml/__init__.pyi new file mode 100644 index 000000000000..cda76b6fa666 --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/__init__.pyi @@ -0,0 +1,16 @@ +from .comments import CommentedMap as CommentedMap, CommentedSeq as CommentedSeq +from .constructor import * +from .cyaml import * +from .dumper import * +from .error import YAMLError as YAMLError +from .events import * +from .loader import * +from .main import * +from .nodes import * +from .representer import * +from .resolver import * +from .tokens import * + +version_info: tuple[int, int, int] +__version__: str +__with_libyaml__: bool diff --git a/stubs/ruamel.yaml/ruamel/yaml/anchor.pyi b/stubs/ruamel.yaml/ruamel/yaml/anchor.pyi new file mode 100644 index 000000000000..6ddc8f10b72c --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/anchor.pyi @@ -0,0 +1,9 @@ +from typing import Final + +anchor_attrib: Final = "_yaml_anchor" + +class Anchor: + attrib: Final = anchor_attrib + value: str | None + always_dump: bool + def __init__(self) -> None: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/comments.pyi b/stubs/ruamel.yaml/ruamel/yaml/comments.pyi new file mode 100644 index 000000000000..843692522fd7 --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/comments.pyi @@ -0,0 +1,184 @@ +import sys +from _typeshed import SupportsWrite, sentinel +from collections.abc import Hashable, Iterable, Iterator, Mapping, MutableSet, Set as AbstractSet, Sized +from typing import Any, Final, Generic, NoReturn, TypeVar +from typing_extensions import Self, TypeAlias + +from .anchor import Anchor +from .compat import MutableSliceableSequence, ordereddict +from .nodes import _ScalarNodeStyle +from .tag import Tag +from .tokens import CommentToken, _CommentGroup + +__all__ = [ + "CommentedSeq", + "CommentedKeySeq", + "CommentedMap", + "CommentedOrderedMap", + "CommentedSet", + "comment_attrib", + "merge_attrib", + "TaggedScalar", + "C_POST", + "C_PRE", + "C_SPLIT_ON_FIRST_BLANK", + "C_BLANK_LINE_PRESERVE_SPACE", +] + +_Index: TypeAlias = int +_Key: TypeAlias = Hashable + +_T = TypeVar("_T") +_KT = TypeVar("_KT") +_VT = TypeVar("_VT") +_KT_co = TypeVar("_KT_co", covariant=True) +_VT_co = TypeVar("_VT_co", covariant=True) +_Commented = TypeVar("_Commented", bound=CommentedBase) + +C_POST: Final = 0b00 +C_PRE: Final = 0b01 +C_SPLIT_ON_FIRST_BLANK: Final = 0b10 +C_BLANK_LINE_PRESERVE_SPACE: Final = 0b100 + +comment_attrib: Final = "_yaml_comment" +format_attrib: Final = "_yaml_format" +line_col_attrib: Final = "_yaml_line_col" +merge_attrib: Final = "_yaml_merge" + +class Comment: + attrib: Final = comment_attrib + comment: _CommentGroup | None + def __init__(self, *, old: bool = True) -> None: ... + @property + def items(self) -> dict[_Index | _Key, _CommentGroup]: ... + @property + def end(self): ... # RTSC + @end.setter + def end(self, value) -> None: ... # RTSC + @property + def pre(self): ... # RTSC + @pre.setter + def pre(self, value) -> None: ... # RTSC + def get(self, item: _Index | _Key, pos: int): ... # RTSC + def set(self, item: _Index | _Key, pos: int, value: list[int]): ... # RTSC + def __contains__(self, x: str, /) -> bool: ... + +class Format: + attrib: Final = format_attrib + def __init__(self) -> None: ... + def set_flow_style(self) -> None: ... + def set_block_style(self) -> None: ... + def flow_style(self, default: bool | None = None) -> bool | None: ... + +class LineCol: + attrib: Final = line_col_attrib + line: int | None + col: int | None + data: dict[_Key, list[int]] | None + def __init__(self) -> None: ... + def add_kv_line_col(self, key: _Key, data: list[int]) -> None: ... + def key(self, k: str, /) -> tuple[int, int] | None: ... + def value(self, k: str, /) -> tuple[int, int] | None: ... + def item(self, idx: int, /) -> tuple[int, int] | None: ... + def add_idx_line_col(self, key: _Index, data: list[int]) -> None: ... + +class CommentedBase: + @property + def ca(self) -> Comment: ... + def yaml_end_comment_extend(self, comment: list[CommentToken] | None, *, clear: bool = False) -> None: ... + def yaml_key_comment_extend(self, key: _Index | _Key, comment: _CommentGroup, *, clear: bool = False) -> None: ... + def yaml_value_comment_extend(self, key: _Key, comment: _CommentGroup, *, clear: bool = False) -> None: ... + def yaml_set_start_comment(self, comment: str, *, indent: int = 0) -> None: ... + def yaml_set_comment_before_after_key( + self, key: _Key, before: str | None = None, indent: int = 0, after: str | None = None, after_indent: int | None = None + ) -> None: ... + @property + def fa(self) -> Format: ... + def yaml_add_eol_comment(self, comment: str, key: _Index | _Key = sentinel, column: int | None = None) -> None: ... + @property + def lc(self) -> LineCol: ... + @property + def anchor(self) -> Anchor: ... + def yaml_anchor(self) -> Anchor | None: ... + def yaml_set_anchor(self, value: str, *, always_dump: bool = False) -> None: ... + @property + def tag(self) -> Tag: ... + def yaml_set_ctag(self, value: Tag, /) -> None: ... + def copy_attributes(self, t: _Commented, memo: dict[int, Any] | None = None) -> _Commented: ... + +class CommentedSeq(MutableSliceableSequence[_T], list[_T], CommentedBase): # type: ignore[misc] + def __getsingleitem__(self, idx: int) -> _T: ... + def __setsingleitem__(self, idx: int, value: _T) -> None: ... + def __delsingleitem__(self, idx: int) -> None: ... + def __deepcopy__(self, memo: dict[int, Any]) -> Self: ... + +class CommentedKeySeq(tuple[_T, ...], CommentedBase): ... + +class CommentedMapView(Sized): + def __init__(self, mapping: CommentedMap[Any, Any]) -> None: ... + def __len__(self) -> int: ... + +class CommentedMapKeysView(CommentedMapView, AbstractSet[_KT_co]): + def __init__(self, mapping: CommentedMap[_KT_co, Any]) -> None: ... + def __contains__(self, key: object) -> bool: ... + def __iter__(self) -> Iterator[_KT_co]: ... + +class CommentedMapItemsView(CommentedMapView, AbstractSet[tuple[_KT_co, _VT_co]]): + def __init__(self, mapping: CommentedMap[_KT_co, _VT_co]) -> None: ... + def __contains__(self, item: object) -> bool: ... + def __iter__(self) -> Iterator[tuple[_KT_co, _VT_co]]: ... + +class CommentedMapValuesView(CommentedMapView, Generic[_VT_co]): + def __init__(self, mapping: CommentedMap[Any, _VT_co]) -> None: ... + def __contains__(self, value: object) -> bool: ... + def __iter__(self) -> Iterator[_VT_co]: ... + +class CommentedMap(ordereddict[_KT, _VT], CommentedBase): + def insert(self, pos: int, key: _KT, value: _VT, comment: str | None = None) -> None: ... + def mlget(self, key: list[_Index | _Key], default: Any = None, list_ok: bool = False) -> Any: ... + def non_merged_items(self) -> Iterator[tuple[_KT, _VT]]: ... + def keys(self) -> CommentedMapKeysView[_KT]: ... # type: ignore[override] + def values(self) -> CommentedMapValuesView[_VT]: ... # type: ignore[override] + def items(self) -> CommentedMapItemsView[_KT, _VT]: ... # type: ignore[override] + @property + def merge(self) -> list[tuple[int, Self]]: ... + def add_referent(self, cm: Self) -> None: ... + def add_yaml_merge(self, value: list[tuple[int, Self]]) -> None: ... + def update_key_value(self, key: _KT) -> None: ... + def __deepcopy__(self, memo: dict[int, Any]) -> Self: ... + +class CommentedKeyMap(CommentedBase, Mapping[_KT, _VT]): + def __init__(self, *args, **kwargs) -> None: ... + def __delitem__(self, *args, **kwargs) -> NoReturn: ... + def __setitem__(self, *args, **kwargs) -> NoReturn: ... + def clear(self, *args, **kwargs) -> NoReturn: ... + def pop(self, *args, **kwargs) -> NoReturn: ... + def popitem(self, *args, **kwargs) -> NoReturn: ... + def setdefault(self, *args, **kwargs) -> NoReturn: ... + def update(self, *args, **kwargs) -> NoReturn: ... + def __getitem__(self, index: _KT) -> _VT: ... + def __iter__(self) -> Iterator[_KT]: ... + def __len__(self) -> int: ... + def __hash__(self) -> int: ... + @classmethod + def fromkeys(keys, v=None) -> NoReturn: ... # broken + +class CommentedOrderedMap(CommentedMap[_KT, _VT]): ... + +class CommentedSet(MutableSet[_T], CommentedBase): + odict: ordereddict[_T, None] + def __init__(self, values: Iterable[_T] | None = None) -> None: ... + def add(self, value: _T) -> None: ... + def discard(self, value: _T) -> None: ... + def __contains__(self, x: object) -> bool: ... + def __iter__(self) -> Iterator[_T]: ... + def __len__(self) -> int: ... + +class TaggedScalar(CommentedBase): + value: str | None + style: _ScalarNodeStyle | None + def __init__(self, value: str | None = None, style: _ScalarNodeStyle | None = None, tag: Tag | str | None = None) -> None: ... + def count(self, s: str, start: int | None = None, end: int | None = None) -> int: ... + def __getitem__(self, pos: int) -> str: ... + +def dump_comments(d: object, name: str = "", sep: str = ".", out: SupportsWrite[str] = sys.stdout) -> None: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/compat.pyi b/stubs/ruamel.yaml/ruamel/yaml/compat.pyi new file mode 100644 index 000000000000..81084de1213b --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/compat.pyi @@ -0,0 +1,65 @@ +from _typeshed import SupportsRead, SupportsWrite +from abc import ABCMeta, abstractmethod +from collections import OrderedDict +from collections.abc import Iterable, MutableSequence +from typing import IO, Any, Final, TypeVar, overload +from typing_extensions import Self, TypeAlias + +from .docinfo import Version + +_T = TypeVar("_T") +_KT = TypeVar("_KT") +_VT = TypeVar("_VT") + +_ReadStream: TypeAlias = str | bytes | SupportsRead[str] | SupportsRead[bytes] +_WriteStream: TypeAlias = SupportsWrite[str] | SupportsWrite[bytes] + +StreamType: TypeAlias = _WriteStream +StreamTextType: TypeAlias = _ReadStream +VersionType: TypeAlias = str | tuple[int, int] | list[int] | Version | None + +class ordereddict(OrderedDict[_KT, _VT]): + def insert(self, pos: int, key: _KT, value: _VT) -> None: ... + +builtins_module: Final = "builtins" + +def with_metaclass(meta, *bases): ... + +DBG_TOKEN: Final = 1 +DBG_EVENT: Final = 2 +DBG_NODE: Final = 4 + +def dbg(val: int | None = None) -> int: ... + +class Nprint: + def __init__(self, file_name: str | None = None) -> None: ... + def __call__(self, *args, **kw) -> None: ... + def set_max_print(self, i: int) -> None: ... + def fp(self, mode: str = "a") -> IO[Any]: ... + +nprint: Nprint +nprintf: Nprint + +def check_namespace_char(ch: str) -> bool: ... +def check_anchorname_char(ch: str) -> bool: ... +def version_tnf(t1: tuple[int, ...], t2: tuple[int, ...] | None = None) -> bool | None: ... + +class MutableSliceableSequence(MutableSequence[_T], metaclass=ABCMeta): + @overload + def __getitem__(self, index: int) -> _T: ... + @overload + def __getitem__(self, index: slice) -> Self: ... + @overload + def __setitem__(self, index: int, value: _T) -> None: ... + @overload + def __setitem__(self, index: slice, value: Iterable[_T]) -> None: ... + @overload + def __delitem__(self, index: int) -> None: ... + @overload + def __delitem__(self, index: slice) -> None: ... + @abstractmethod + def __getsingleitem__(self, index: int) -> _T: ... + @abstractmethod + def __setsingleitem__(self, index: int, value: _T) -> None: ... + @abstractmethod + def __delsingleitem__(self, index: int) -> None: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/composer.pyi b/stubs/ruamel.yaml/ruamel/yaml/composer.pyi new file mode 100644 index 000000000000..3427c7d4452a --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/composer.pyi @@ -0,0 +1,31 @@ +from .error import MarkedYAMLError +from .events import MappingEndEvent, SequenceEndEvent +from .loader import _Loader +from .main import YAML +from .nodes import CollectionNode, MappingNode, Node, ScalarNode, SequenceNode +from .parser import Parser +from .resolver import BaseResolver + +__all__ = ["Composer", "ComposerError"] + +class ComposerError(MarkedYAMLError): ... + +class Composer: + loader: YAML | _Loader | None + anchors: dict[str, Node] + warn_double_anchors: bool + def __init__(self, loader: YAML | _Loader | None = None) -> None: ... + @property + def parser(self) -> Parser: ... + @property + def resolver(self) -> BaseResolver: ... + def check_node(self) -> bool: ... + def get_node(self) -> Node: ... + def get_single_node(self) -> Node: ... + def compose_document(self) -> Node: ... + def return_alias(self, a: Node) -> Node: ... + def compose_node(self, parent: CollectionNode | None, index: int | Node | None) -> Node: ... + def compose_scalar_node(self, anchor: str | None) -> ScalarNode: ... + def compose_sequence_node(self, anchor: str | None) -> SequenceNode: ... + def compose_mapping_node(self, anchor: str | None) -> MappingNode: ... + def check_end_doc_comment(self, end_event: SequenceEndEvent | MappingEndEvent, node: SequenceNode | MappingNode) -> None: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/configobjwalker.pyi b/stubs/ruamel.yaml/ruamel/yaml/configobjwalker.pyi new file mode 100644 index 000000000000..c2e054ab5827 --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/configobjwalker.pyi @@ -0,0 +1,7 @@ +from collections.abc import Iterator +from typing_extensions import deprecated + +from configobj import ConfigObj # type: ignore[import-not-found] # pyright: ignore[reportMissingImports] + +@deprecated("configobj_walker has moved to ruamel.yaml.util") +def configobj_walker(cfg: ConfigObj, /) -> Iterator[str]: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/constructor.pyi b/stubs/ruamel.yaml/ruamel/yaml/constructor.pyi new file mode 100644 index 000000000000..1abc99aa3740 --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/constructor.pyi @@ -0,0 +1,155 @@ +from collections.abc import Generator, Iterable, Iterator, Mapping, Set as AbstractSet +from datetime import date, datetime +from re import Pattern +from types import ModuleType +from typing import Any, ClassVar, Final, NoReturn, Protocol, TypeVar, overload +from typing_extensions import Self + +from .comments import CommentedMap, CommentedOrderedMap, CommentedSeq, CommentedSet, TaggedScalar +from .compat import ordereddict +from .composer import Composer +from .error import MarkedYAMLError, MarkedYAMLFutureWarning, _Mark +from .loader import _Loader +from .main import YAML +from .nodes import MappingNode, Node, ScalarNode, SequenceNode +from .resolver import BaseResolver +from .scalarbool import ScalarBoolean +from .scalarfloat import ScalarFloat +from .scanner import ScannedComments, Scanner +from .tag import Tag +from .timestamp import TimeStamp + +__all__ = ["BaseConstructor", "SafeConstructor", "Constructor", "ConstructorError", "RoundTripConstructor"] + +_T = TypeVar("_T") +_Constructor = TypeVar("_Constructor", bound=BaseConstructor, contravariant=True) + +class _ConstructorFunction(Protocol[_Constructor]): + def __call__(self, loader: _Constructor, node: Node, /) -> Any: ... + +class _MultiConstructorFunction(Protocol[_Constructor]): + def __call__(self, loader: _Constructor, tag_suffix: str, node: Node, /) -> Any: ... + +class ConstructorError(MarkedYAMLError): ... +class DuplicateKeyFutureWarning(MarkedYAMLFutureWarning): ... +class DuplicateKeyError(MarkedYAMLError): ... + +class BaseConstructor: + yaml_constructors: ClassVar[dict[str | None, _ConstructorFunction[Self]]] + yaml_multi_constructors: ClassVar[dict[str | None, _MultiConstructorFunction[Self]]] + loader: YAML | _Loader | None + yaml_base_dict_type: type[dict[Any, Any]] + yaml_base_list_type: type[list[Any]] + constructed_objects: dict[Node, Any] + recursive_objects: dict[Node, Any] + state_generators: list[Generator[Any, Any, Any]] + deep_construct: bool + allow_duplicate_keys: bool | None + def __init__(self, preserve_quotes: bool | None = None, loader: YAML | _Loader | None = None) -> None: ... + @property + def composer(self) -> Composer: ... + @property + def resolver(self) -> BaseResolver: ... + @property + def scanner(self) -> Scanner: ... + def check_data(self) -> bool: ... + def get_data(self) -> Any: ... + def get_single_data(self) -> Any: ... + def construct_document(self, node: Node) -> Any: ... + def construct_object(self, node: Node, deep: bool = False) -> Any: ... + def construct_non_recursive_object(self, node: Node, tag: str | None = None) -> Any: ... + def construct_scalar(self, node: ScalarNode) -> str: ... + def construct_sequence(self, node: SequenceNode, deep: bool = False) -> list[Any]: ... + def construct_mapping(self, node: MappingNode, deep: bool = False) -> dict[Any, Any]: ... + def check_mapping_key(self, node: MappingNode, key_node: Node, mapping: Mapping[Any, Any], key: Any, value: Any) -> bool: ... + def check_set_key(self, node: MappingNode, key_node: ScalarNode, setting: AbstractSet[Any], key: Any) -> None: ... + def construct_pairs(self, node: MappingNode, deep: bool = False) -> list[tuple[Any, Any]]: ... + @classmethod + def add_constructor( + cls, tag: Tag | str | None, constructor: _ConstructorFunction[Self] + ) -> _ConstructorFunction[Self] | None: ... + @classmethod + def add_multi_constructor(cls, tag_prefix: str | None, multi_constructor: _MultiConstructorFunction[Self]) -> None: ... + @classmethod + def add_default_constructor(cls, tag: str, method: str | None = None, tag_base: str = "tag:yaml.org,2002:") -> None: ... + +class SafeConstructor(BaseConstructor): + def construct_scalar(self, node: ScalarNode) -> str: ... + def flatten_mapping(self, node: MappingNode) -> list[Any] | None: ... + def construct_mapping(self, node: MappingNode, deep: bool = False) -> dict[Any, Any]: ... + def construct_yaml_null(self, node: ScalarNode) -> None: ... + bool_values: Final[dict[str, bool]] + def construct_yaml_bool(self, node: ScalarNode) -> bool: ... + def construct_yaml_int(self, node: ScalarNode) -> int: ... + inf_value: Final[float] + nan_value: Final[float] + def construct_yaml_float(self, node: ScalarNode) -> float: ... + def construct_yaml_binary(self, node: ScalarNode) -> bytes: ... + timestamp_regexp: Final[Pattern[str]] + def construct_yaml_timestamp(self, node: ScalarNode, values: dict[str, str | None] | None = None) -> date | datetime: ... + def construct_yaml_omap(self, node: SequenceNode) -> Iterator[ordereddict[Any, Any]]: ... + def construct_yaml_pairs(self, node: SequenceNode) -> Iterator[list[tuple[Any, Any]]]: ... + def construct_yaml_set(self, node: MappingNode) -> Iterator[set[Any]]: ... + def construct_yaml_str(self, node: ScalarNode) -> str: ... + def construct_yaml_seq(self, node: SequenceNode) -> Iterator[list[Any]]: ... + def construct_yaml_map(self, node: MappingNode) -> Iterator[dict[Any, Any]]: ... + def construct_yaml_object(self, node: MappingNode, cls: type[_T]) -> Iterator[_T]: ... + def construct_undefined(self, node: Node) -> NoReturn: ... + +class Constructor(SafeConstructor): + def construct_python_str(self, node: ScalarNode) -> str: ... + def construct_python_unicode(self, node: ScalarNode) -> str: ... + def construct_python_bytes(self, node: ScalarNode) -> bytes: ... + def construct_python_long(self, node: ScalarNode) -> int: ... + def construct_python_complex(self, node: ScalarNode) -> complex: ... + def construct_python_tuple(self, node: SequenceNode) -> tuple[Any, ...]: ... + def find_python_module(self, name: str, mark: _Mark) -> ModuleType: ... + def find_python_name(self, name: str, mark: _Mark) -> Any: ... + def construct_python_name(self, suffix: str, node: ScalarNode) -> Any: ... + def construct_python_module(self, suffix: str, node: ScalarNode) -> ModuleType: ... + def make_python_instance( + self, + suffix: str, + node: Node, + args: Iterable[Any] | None = None, + kwds: Mapping[str, Any] | None = None, + newobj: bool = False, + ) -> Any: ... + def set_python_instance_state(self, instance, state) -> None: ... + def construct_python_object(self, suffix: str, node: MappingNode) -> Iterator[Any]: ... + def construct_python_object_apply(self, suffix: str, node: SequenceNode | MappingNode, newobj: bool = False) -> Any: ... + def construct_python_object_new(self, suffix: str, node: SequenceNode | MappingNode) -> Any: ... + @classmethod + def add_default_constructor( + cls, tag: str, method: str | None = None, tag_base: str = "tag:yaml.org,2002:python/" + ) -> None: ... + +class RoundTripConstructor(SafeConstructor): + def comment(self, idx: int) -> ScannedComments: ... # RTSC + def comments(self, list_of_comments: list[list[int] | None], idx: int | None = None) -> Iterator[ScannedComments]: ... # RTSC + def construct_scalar(self, node: ScalarNode) -> str: ... + def construct_yaml_int(self, node: ScalarNode) -> int: ... + def construct_yaml_float(self, node: ScalarNode) -> float | ScalarFloat: ... + def construct_yaml_str(self, node: ScalarNode) -> str | TaggedScalar: ... # type: ignore[override] + def construct_rt_sequence(self, node: SequenceNode, seqtyp: CommentedSeq[_T], deep: bool = False) -> list[_T]: ... + def flatten_mapping(self, node: MappingNode) -> list[tuple[int, CommentedMap[Any, Any]]]: ... + def construct_mapping(self, node: MappingNode, maptyp: CommentedMap[Any, Any], deep: bool = False) -> None: ... # type: ignore[override] + def construct_setting(self, node: MappingNode, typ: CommentedSet[Any], deep: bool = False) -> None: ... + def construct_yaml_seq(self, node: SequenceNode) -> Iterator[CommentedSeq[Any]]: ... + def construct_yaml_map(self, node: MappingNode) -> Iterator[CommentedMap[Any, Any]]: ... + def set_collection_style( + self, data: CommentedSeq[Any] | CommentedMap[Any, Any], node: SequenceNode | MappingNode + ) -> None: ... + def construct_yaml_object(self, node: MappingNode, cls: type[_T]) -> Iterator[_T]: ... + def construct_yaml_omap(self, node: SequenceNode) -> Iterator[CommentedOrderedMap[Any, Any]]: ... + def construct_yaml_set(self, node: MappingNode) -> Iterator[CommentedSet[Any]]: ... # type: ignore[override] + @overload + def construct_unknown(self, node: ScalarNode) -> Iterator[TaggedScalar]: ... + @overload + def construct_unknown(self, node: SequenceNode) -> Iterator[CommentedSeq[Any]]: ... + @overload + def construct_unknown(self, node: MappingNode) -> Iterator[CommentedMap[Any, Any]]: ... + def construct_yaml_timestamp( + self, node: ScalarNode, values: dict[str, str | None] | None = None + ) -> date | datetime | TimeStamp: ... + def construct_yaml_sbool(self, node: ScalarNode) -> bool | ScalarBoolean: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/cyaml.pyi b/stubs/ruamel.yaml/ruamel/yaml/cyaml.pyi new file mode 100644 index 000000000000..534985a95ce8 --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/cyaml.pyi @@ -0,0 +1,85 @@ +from _typeshed import Unused + +from _ruamel_yaml import CEmitter, CParser + +from .compat import _ReadStream, _WriteStream +from .constructor import BaseConstructor, Constructor, SafeConstructor +from .emitter import _LineBreak +from .representer import BaseRepresenter, Representer, SafeRepresenter +from .resolver import BaseResolver, Resolver +from .tag import _TagHandleToPrefix +from .tokens import _ScalarStyle, _VersionTuple + +__all__ = ["CBaseLoader", "CSafeLoader", "CLoader", "CBaseDumper", "CSafeDumper", "CDumper"] + +class CBaseLoader(CParser, BaseConstructor, BaseResolver): + def __init__(self, stream: _ReadStream, version: Unused = None, preserve_quotes: Unused = None) -> None: ... + +class CSafeLoader(CParser, SafeConstructor, Resolver): + def __init__(self, stream: _ReadStream, version: Unused = None, preserve_quotes: Unused = None) -> None: ... + +class CLoader(CParser, Constructor, Resolver): + def __init__(self, stream: _ReadStream, version: Unused = None, preserve_quotes: Unused = None) -> None: ... + +class CBaseDumper(CEmitter, BaseRepresenter, BaseResolver): + def __init__( + self, + stream: _WriteStream, + default_style: _ScalarStyle | None = None, + default_flow_style: bool | None = None, + canonical: bool | None = None, + indent: int | None = None, + width: int | None = None, + allow_unicode: bool | None = None, + line_break: _LineBreak | None = None, + encoding: str | None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: _VersionTuple | None = None, + tags: _TagHandleToPrefix | None = None, + block_seq_indent: Unused = None, + top_level_colon_align: Unused = None, + prefix_colon: Unused = None, + ) -> None: ... + +class CSafeDumper(CEmitter, SafeRepresenter, Resolver): + def __init__( + self, + stream: _WriteStream, + default_style: _ScalarStyle | None = None, + default_flow_style: bool | None = None, + canonical: bool | None = None, + indent: int | None = None, + width: int | None = None, + allow_unicode: bool | None = None, + line_break: _LineBreak | None = None, + encoding: str | None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: _VersionTuple | None = None, + tags: _TagHandleToPrefix | None = None, + block_seq_indent: Unused = None, + top_level_colon_align: Unused = None, + prefix_colon: Unused = None, + ) -> None: ... + +class CDumper(CEmitter, Representer, Resolver): + def __init__( + self, + stream: _WriteStream, + default_style: _ScalarStyle | None = None, + default_flow_style: bool | None = None, + canonical: bool | None = None, + indent: int | None = None, + width: int | None = None, + allow_unicode: bool | None = None, + line_break: _LineBreak | None = None, + encoding: str | None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: _VersionTuple | None = None, + tags: _TagHandleToPrefix | None = None, + block_seq_indent: Unused = None, + top_level_colon_align: Unused = None, + prefix_colon: Unused = None, + ) -> None: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/docinfo.pyi b/stubs/ruamel.yaml/ruamel/yaml/docinfo.pyi new file mode 100644 index 000000000000..7a87a03539d7 --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/docinfo.pyi @@ -0,0 +1,28 @@ +class Version: + def __init__(self, major: int, minor: int) -> None: ... + @property + def major(self) -> int: ... + @property + def minor(self) -> int: ... + def __eq__(self, v: object) -> bool: ... + def __lt__(self, v: Version) -> bool: ... + def __le__(self, v: Version) -> bool: ... + def __gt__(self, v: Version) -> bool: ... + def __ge__(self, v: Version) -> bool: ... + +def version(major: int | str | tuple[int, int] | None, minor: int | None = None) -> Version | None: ... + +class Tag: + def __init__(self, handle: str, prefix: str) -> None: ... + @property + def handle(self) -> str: ... + @property + def prefix(self) -> str: ... + +class DocInfo: + requested_version: Version | None + doc_version: Version | None + tags: list[Tag] + def __init__( + self, requested_version: Version | None = None, doc_version: Version | None = None, tags: list[Tag] | None = None + ) -> None: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/dumper.pyi b/stubs/ruamel.yaml/ruamel/yaml/dumper.pyi new file mode 100644 index 000000000000..a2400c08177f --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/dumper.pyi @@ -0,0 +1,98 @@ +from _typeshed import Unused +from typing_extensions import TypeAlias + +from .compat import VersionType, _WriteStream +from .emitter import Emitter, _Inf, _LineBreak +from .representer import BaseRepresenter, Representer, RoundTripRepresenter, SafeRepresenter +from .resolver import BaseResolver, Resolver, VersionedResolver +from .serializer import Serializer +from .tag import _TagHandleToPrefix +from .tokens import _ScalarStyle + +__all__ = ["BaseDumper", "SafeDumper", "Dumper", "RoundTripDumper"] + +_Dumper: TypeAlias = BaseDumper | SafeDumper | Dumper | RoundTripDumper # noqa: Y047 + +class BaseDumper(Emitter, Serializer, BaseRepresenter, BaseResolver): + def __init__( + self, + stream: _WriteStream, + default_style: _ScalarStyle | None = None, + default_flow_style: bool | None = None, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: _LineBreak | None = None, + encoding: str | None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: VersionType | None = None, + tags: _TagHandleToPrefix | None = None, + block_seq_indent: int | None = None, + top_level_colon_align: Unused = None, + prefix_colon: Unused = None, + ) -> None: ... + +class SafeDumper(Emitter, Serializer, SafeRepresenter, Resolver): + def __init__( + self, + stream: _WriteStream, + default_style: _ScalarStyle | None = None, + default_flow_style: bool | None = None, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: _LineBreak | None = None, + encoding: str | None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: VersionType | None = None, + tags: _TagHandleToPrefix | None = None, + block_seq_indent: int | None = None, + top_level_colon_align: Unused = None, + prefix_colon: Unused = None, + ) -> None: ... + +class Dumper(Emitter, Serializer, Representer, Resolver): + def __init__( + self, + stream: _WriteStream, + default_style: _ScalarStyle | None = None, + default_flow_style: bool | None = None, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: _LineBreak | None = None, + encoding: str | None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: VersionType | None = None, + tags: _TagHandleToPrefix | None = None, + block_seq_indent: int | None = None, + top_level_colon_align: Unused = None, + prefix_colon: Unused = None, + ) -> None: ... + +class RoundTripDumper(Emitter, Serializer, RoundTripRepresenter, VersionedResolver): + def __init__( + self, + stream: _WriteStream, + default_style: _ScalarStyle | None = None, + default_flow_style: bool | None = None, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: _LineBreak | None = None, + encoding: str | None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: VersionType | None = None, + tags: _TagHandleToPrefix | None = None, + block_seq_indent: int | None = None, + top_level_colon_align: int | None = None, + prefix_colon: str | None = None, + ) -> None: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/emitter.pyi b/stubs/ruamel.yaml/ruamel/yaml/emitter.pyi new file mode 100644 index 000000000000..13e2f767cf5d --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/emitter.pyi @@ -0,0 +1,195 @@ +from collections.abc import Callable +from typing import Final, Literal +from typing_extensions import TypeAlias + +from .compat import _WriteStream +from .dumper import _Dumper +from .error import YAMLError +from .events import Event +from .main import YAML +from .serializer import Serializer +from .tag import Tag, _TagHandleToPrefix +from .tokens import CommentToken, _ScalarStyle, _VersionTuple + +__all__ = ["Emitter", "EmitterError"] + +# https://github.com/python/typeshed/pull/8973 +_Inf: TypeAlias = float + +_LineBreak: TypeAlias = Literal["\r", "\n", "\r\n"] + +class EmitterError(YAMLError): ... + +class ScalarAnalysis: + scalar: str + empty: bool + multiline: bool + allow_flow_plain: bool + allow_block_plain: bool + allow_single_quoted: bool + allow_double_quoted: bool + allow_block: bool + def __init__( + self, + scalar: str, + empty: bool, + multiline: bool, + allow_flow_plain: bool, + allow_block_plain: bool, + allow_single_quoted: bool, + allow_double_quoted: bool, + allow_block: bool, + ) -> None: ... + +class Indents: + values: list[tuple[int | None, bool | None]] + def __init__(self) -> None: ... + def append(self, val: int | None, seq: bool | None) -> None: ... + def pop(self) -> int | None: ... + def seq_seq(self) -> bool: ... + def last_seq(self) -> bool | None: ... + def seq_flow_align(self, seq_indent: int, column: int, pre_comment: bool | None = False) -> int: ... + def __len__(self) -> int: ... + +class Emitter: + DEFAULT_TAG_PREFIXES: Final[_TagHandleToPrefix] + MAX_SIMPLE_KEY_LENGTH: Final = 128 + flow_seq_start: Final = "[" + flow_seq_end: Final = "]" + flow_seq_separator: Final = "," + flow_map_start: Final = "{" + flow_map_end: Final = "}" + flow_map_separator: Final = "," + dumper: YAML | _Dumper | None + encoding: str | None + allow_space_break: bool | None + states: list[Callable[[], None]] + state: Callable[[], None] | None + events: list[Event] + event: Event | None + indents: Indents + indent: int | None + flow_context: list[str] + root_context: bool + sequence_context: bool + mapping_context: bool + simple_key_context: bool + line: int + column: int + whitespace: bool + indention: bool + compact_seq_seq: bool + compact_seq_map: bool + no_newline: bool | None + open_ended: bool + colon: str + prefixed_colon: str + brace_single_entry_mapping_in_flow_sequence: bool | None + canonical: bool | None + allow_unicode: bool | None + unicode_supplementary: bool + sequence_dash_offset: int + top_level_colon_align: int | None + best_sequence_indent: int + requested_indent: int | None + best_map_indent: int + best_width: int | _Inf + best_line_break: _LineBreak + tag_prefixes: _TagHandleToPrefix | None + prepared_anchor: str | None + prepared_tag: str | None + analysis: ScalarAnalysis | None + style: _ScalarStyle | None + scalar_after_indicator: bool + alt_null: str + def __init__( + self, + stream: _WriteStream, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: _LineBreak | None = None, + block_seq_indent: int | None = None, + top_level_colon_align: int | None = None, + prefix_colon: str | None = None, + brace_single_entry_mapping_in_flow_sequence: bool | None = None, + dumper: YAML | _Dumper | None = None, + ) -> None: ... + @property + def stream(self) -> _WriteStream: ... + @stream.setter + def stream(self, val: _WriteStream) -> None: ... + @property + def serializer(self) -> Serializer: ... + @property + def flow_level(self) -> int: ... + def dispose(self) -> None: ... + def emit(self, event: Event) -> None: ... + def need_more_events(self) -> bool: ... + def need_events(self, count: int) -> bool: ... + def increase_indent(self, flow: bool = False, sequence: bool | None = None, indentless: bool = False) -> None: ... + def expect_stream_start(self) -> None: ... + def expect_nothing(self) -> None: ... + def expect_first_document_start(self) -> None: ... + def expect_document_start(self, first: bool = False) -> None: ... + def expect_document_end(self) -> None: ... + def expect_document_root(self) -> None: ... + def expect_node( + self, root: bool = False, sequence: bool = False, mapping: bool = False, simple_key: bool = False + ) -> None: ... + def expect_alias(self) -> None: ... + def expect_scalar(self) -> None: ... + def expect_flow_sequence(self, force_flow_indent: bool | None = False) -> None: ... + def expect_first_flow_sequence_item(self) -> None: ... + def expect_flow_sequence_item(self) -> None: ... + def expect_flow_mapping(self, single: bool | None = False, force_flow_indent: bool | None = False) -> None: ... + def expect_first_flow_mapping_key(self) -> None: ... + def expect_flow_mapping_key(self) -> None: ... + def expect_flow_mapping_simple_value(self) -> None: ... + def expect_flow_mapping_value(self) -> None: ... + def expect_block_sequence(self) -> None: ... + def expect_first_block_sequence_item(self) -> None: ... + def expect_block_sequence_item(self, first: bool = False) -> None: ... + def expect_block_mapping(self) -> None: ... + def expect_first_block_mapping_key(self) -> None: ... + def expect_block_mapping_key(self, first: bool = False) -> None: ... + def expect_block_mapping_simple_value(self) -> None: ... + def expect_block_mapping_value(self) -> None: ... + def check_empty_sequence(self) -> bool: ... + def check_empty_mapping(self) -> bool: ... + def check_empty_document(self) -> bool: ... + def check_simple_key(self) -> bool: ... + def process_anchor(self, indicator: str) -> bool: ... + def process_tag(self) -> None: ... + def choose_scalar_style(self) -> _ScalarStyle | None: ... + def process_scalar(self) -> None: ... + def prepare_version(self, version: _VersionTuple) -> str: ... + def prepare_tag_handle(self, handle: str) -> str: ... + def prepare_tag_prefix(self, prefix: str) -> str: ... + def prepare_tag(self, tag: Tag) -> str: ... + def prepare_anchor(self, anchor: str) -> str: ... + def analyze_scalar(self, scalar: str) -> ScalarAnalysis: ... + def flush_stream(self) -> None: ... + def write_stream_start(self) -> None: ... + def write_stream_end(self) -> None: ... + def write_indicator( + self, indicator: str, need_whitespace: bool, whitespace: bool = False, indention: bool = False + ) -> None: ... + def write_indent(self) -> None: ... + def write_line_break(self, data: str | None = None) -> None: ... + def write_version_directive(self, version_text: str) -> None: ... + def write_tag_directive(self, handle_text: str, prefix_text: str) -> None: ... + def write_single_quoted(self, text: str, split: bool = True) -> None: ... + ESCAPE_REPLACEMENTS: Final[dict[str, str]] + def write_double_quoted(self, text: str, split: bool = True) -> None: ... + def determine_block_hints(self, text: str) -> tuple[str, int, str]: ... + def write_folded(self, text: str, comment: str) -> None: ... + def write_literal(self, text: str, comment: str | None = None) -> None: ... + def write_plain(self, text: str, split: bool = True) -> None: ... + def write_comment(self, comment: CommentToken, pre: bool = False) -> None: ... + def write_pre_comment(self, event: Event) -> bool: ... + def write_post_comment(self, event: Event) -> bool: ... + +class RoundTripEmitter(Emitter): + def prepare_tag(self, ctag: Tag) -> str: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/error.pyi b/stubs/ruamel.yaml/ruamel/yaml/error.pyi new file mode 100644 index 000000000000..ac5e4a7d8c3f --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/error.pyi @@ -0,0 +1,111 @@ +from typing import ClassVar +from typing_extensions import Self, TypeAlias + +from _ruamel_yaml import Mark + +from .nodes import ScalarNode + +__all__ = [ + "FileMark", + "StringMark", + "CommentMark", + "YAMLError", + "MarkedYAMLError", + "ReusedAnchorWarning", + "UnsafeLoaderWarning", + "MarkedYAMLWarning", + "MarkedYAMLFutureWarning", +] + +_Mark: TypeAlias = Mark | StreamMark + +class StreamMark: + name: str | None + index: int + line: int + column: int + def __init__(self, name: str | None, index: int, line: int, column: int) -> None: ... + def __eq__(self, other: Self, /) -> bool: ... # type: ignore[override] + def __ne__(self, other: Self, /) -> bool: ... # type: ignore[override] + +class FileMark(StreamMark): ... + +class StringMark(StreamMark): + buffer: str + pointer: int + def __init__(self, name: str | None, index: int, line: int, column: int, buffer: str, pointer: int) -> None: ... + def get_snippet(self, indent: int = 4, max_length: int = 75) -> str: ... + +class CommentMark: + column: int + def __init__(self, column: int) -> None: ... + +class YAMLError(Exception): ... + +class MarkedYAMLError(YAMLError): + context: str | None + context_mark: _Mark | None + problem: str | None + problem_mark: _Mark | None + note: str | None + def __init__( + self, + context: str | None = None, + context_mark: _Mark | None = None, + problem: str | None = None, + problem_mark: _Mark | None = None, + note: str | None = None, + warn: str | None = None, + ) -> None: ... + def check_append(self, lines: list[str], val: str | None) -> None: ... + +class YAMLStreamError(Exception): ... +class YAMLWarning(Warning): ... + +class MarkedYAMLWarning(YAMLWarning): + context: str | None + context_mark: _Mark | None + problem: str | None + problem_mark: _Mark | None + note: str | None + warn: str | None + def __init__( + self, + context: str | None = None, + context_mark: _Mark | None = None, + problem: str | None = None, + problem_mark: _Mark | None = None, + note: str | None = None, + warn: str | None = None, + ) -> None: ... + def check_append(self, lines: list[str], val: str | None) -> None: ... + +class ReusedAnchorWarning(YAMLWarning): ... + +class UnsafeLoaderWarning(YAMLWarning): + text: ClassVar[str] + +class MantissaNoDotYAML1_1Warning(YAMLWarning): + node: ScalarNode + flt: str + def __init__(self, node: ScalarNode, flt_str: str) -> None: ... + +class YAMLFutureWarning(Warning): ... + +class MarkedYAMLFutureWarning(YAMLFutureWarning): + context: str | None + context_mark: _Mark | None + problem: str | None + problem_mark: _Mark | None + note: str | None + warn: str | None + def __init__( + self, + context: str | None = None, + context_mark: _Mark | None = None, + problem: str | None = None, + problem_mark: _Mark | None = None, + note: str | None = None, + warn: str | None = None, + ) -> None: ... + def check_append(self, lines: list[str], val: str | None) -> None: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/events.pyi b/stubs/ruamel.yaml/ruamel/yaml/events.pyi new file mode 100644 index 000000000000..db8f1000ffb6 --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/events.pyi @@ -0,0 +1,141 @@ +from _typeshed import sentinel +from typing import ClassVar, Literal + +from .error import _Mark +from .tag import Tag, _TagHandleToPrefix +from .tokens import _CommentGroup, _ScalarStyle, _VersionTuple + +class Event: + crepr: ClassVar[str] + start_mark: _Mark | None + end_mark: _Mark | None + comment: _CommentGroup | None + def __init__( + self, start_mark: _Mark | None = None, end_mark: _Mark | None = None, comment: _CommentGroup | None = sentinel + ) -> None: ... + def compact_repr(self) -> str: ... + +class NodeEvent(Event): + anchor: str | None + def __init__( + self, + anchor: str | None, + start_mark: _Mark | None = None, + end_mark: _Mark | None = None, + comment: _CommentGroup | None = None, + ) -> None: ... + +class CollectionStartEvent(NodeEvent): + ctag: Tag | str | None + implicit: bool + flow_style: bool | None + nr_items: int | None + def __init__( + self, + anchor: str | None, + tag: Tag | str | None, + implicit: bool, + start_mark: _Mark | None = None, + end_mark: _Mark | None = None, + flow_style: bool | None = None, + comment: _CommentGroup | None = None, + nr_items: int | None = None, + ) -> None: ... + @property + def tag(self) -> str | None: ... + +class CollectionEndEvent(Event): ... + +# Implementations. + +class StreamStartEvent(Event): + crepr: ClassVar[Literal["+STR"]] + encoding: str | None + def __init__( + self, + start_mark: _Mark | None = None, + end_mark: _Mark | None = None, + encoding: str | None = None, + comment: _CommentGroup | None = None, + ) -> None: ... + +class StreamEndEvent(Event): + crepr: ClassVar[Literal["-STR"]] + +class DocumentStartEvent(Event): + crepr: ClassVar[Literal["+DOC"]] + explicit: bool | None + version: _VersionTuple | None + tags: _TagHandleToPrefix | None + def __init__( + self, + start_mark: _Mark | None = None, + end_mark: _Mark | None = None, + explicit: bool | None = None, + version: _VersionTuple | None = None, + tags: _TagHandleToPrefix | None = None, + comment: _CommentGroup | None = None, + ) -> None: ... + def compact_repr(self) -> str: ... + +class DocumentEndEvent(Event): + crepr: ClassVar[Literal["-DOC"]] + explicit: bool | None + def __init__( + self, + start_mark: _Mark | None = None, + end_mark: _Mark | None = None, + explicit: bool | None = None, + comment: _CommentGroup | None = None, + ) -> None: ... + def compact_repr(self) -> str: ... + +class AliasEvent(NodeEvent): + crepr: ClassVar[Literal["=ALI"]] + style: Literal["?"] | None + def __init__( + self, + anchor: str, + start_mark: _Mark | None = None, + end_mark: _Mark | None = None, + style: Literal["?"] | None = None, + comment: _CommentGroup | None = None, + ) -> None: ... + def compact_repr(self) -> str: ... + +class ScalarEvent(NodeEvent): + crepr: ClassVar[Literal["=VAL"]] + ctag: Tag | None + implicit: tuple[bool, bool] + value: str + style: _ScalarStyle | None + def __init__( + self, + anchor: str | None, + tag: Tag | None, + implicit: tuple[bool, bool], + value: str, + start_mark: _Mark | None = None, + end_mark: _Mark | None = None, + style: _ScalarStyle | None = None, + comment: _CommentGroup | None = None, + ) -> None: ... + @property + def tag(self) -> str | None: ... + @tag.setter + def tag(self, val: Tag | str) -> None: ... + def compact_repr(self) -> str: ... + +class SequenceStartEvent(CollectionStartEvent): + crepr: ClassVar[Literal["+SEQ"]] + def compact_repr(self) -> str: ... + +class SequenceEndEvent(CollectionEndEvent): + crepr: ClassVar[Literal["-SEQ"]] + +class MappingStartEvent(CollectionStartEvent): + crepr: ClassVar[Literal["+MAP"]] + def compact_repr(self) -> str: ... + +class MappingEndEvent(CollectionEndEvent): + crepr: ClassVar[Literal["-MAP"]] diff --git a/stubs/ruamel.yaml/ruamel/yaml/loader.pyi b/stubs/ruamel.yaml/ruamel/yaml/loader.pyi new file mode 100644 index 000000000000..7aa09cc47aa5 --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/loader.pyi @@ -0,0 +1,30 @@ +from _typeshed import Unused +from typing_extensions import TypeAlias + +from .compat import VersionType, _ReadStream +from .composer import Composer +from .constructor import BaseConstructor, Constructor, RoundTripConstructor, SafeConstructor +from .parser import Parser, RoundTripParser +from .reader import Reader +from .resolver import VersionedResolver +from .scanner import RoundTripScanner, Scanner + +__all__ = ["BaseLoader", "SafeLoader", "Loader", "RoundTripLoader"] + +_Loader: TypeAlias = Loader | BaseLoader | SafeLoader | RoundTripLoader # noqa: Y047 + +class BaseLoader(Reader, Scanner, Parser, Composer, BaseConstructor, VersionedResolver): # type: ignore[misc] + comment_handling: int | None + def __init__(self, stream: _ReadStream, version: VersionType | None = None, preserve_quotes: Unused = None) -> None: ... + +class SafeLoader(Reader, Scanner, Parser, Composer, SafeConstructor, VersionedResolver): # type: ignore[misc] + comment_handling: int | None + def __init__(self, stream: _ReadStream, version: VersionType | None = None, preserve_quotes: Unused = None) -> None: ... + +class Loader(Reader, Scanner, Parser, Composer, Constructor, VersionedResolver): # type: ignore[misc] + comment_handling: int | None + def __init__(self, stream: _ReadStream, version: VersionType | None = None, preserve_quotes: Unused = None) -> None: ... + +class RoundTripLoader(Reader, RoundTripScanner, RoundTripParser, Composer, RoundTripConstructor, VersionedResolver): # type: ignore[misc] + comment_handling: int | None + def __init__(self, stream: _ReadStream, version: VersionType | None = None, preserve_quotes: bool | None = None) -> None: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/main.pyi b/stubs/ruamel.yaml/ruamel/yaml/main.pyi new file mode 100644 index 000000000000..6657ca089ee4 --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/main.pyi @@ -0,0 +1,375 @@ +from _typeshed import Unused +from collections.abc import Callable, Iterable, Iterator, Sequence +from pathlib import Path +from re import Pattern +from types import ModuleType, TracebackType +from typing import Any, ClassVar, Final, Literal, NoReturn, Protocol, TypeVar, overload +from typing_extensions import Self, TypeAlias, deprecated + +from _ruamel_yaml import CEmitter, CParser + +from .comments import CommentedMap, CommentedSeq +from .compat import VersionType, _ReadStream, _WriteStream +from .composer import Composer +from .constructor import BaseConstructor, Constructor, RoundTripConstructor, _ConstructorFunction, _MultiConstructorFunction +from .docinfo import DocInfo +from .emitter import Emitter, RoundTripEmitter, _Inf, _LineBreak +from .events import Event +from .nodes import Node +from .parser import Parser, RoundTripParser +from .reader import Reader +from .representer import BaseRepresenter, Representer, RoundTripRepresenter, _RepresenterFunction +from .resolver import BaseResolver +from .scanner import RoundTripScanner, Scanner +from .serializer import Serializer +from .tag import Tag, _TagHandleToPrefix +from .tokens import Token, _ScalarStyle, _VersionTuple + +_T = TypeVar("_T") +_Constructor = TypeVar("_Constructor", bound=BaseConstructor) +_Representer = TypeVar("_Representer", bound=BaseRepresenter) + +_YAMLType: TypeAlias = str | Literal["rt", "safe", "unsafe", "full", "base"] # noqa: Y051 + +# type aliases to avoid name clashes and make mypy happy +_Reader: TypeAlias = Reader +_Scanner: TypeAlias = Scanner +_Parser: TypeAlias = Parser +_Composer: TypeAlias = Composer +_Emitter: TypeAlias = Emitter +_Serializer: TypeAlias = Serializer + +class YAML: + typ: list[_YAMLType] + pure: Final[bool] + plug_ins: list[ModuleType] + Resolver: type[BaseResolver] + allow_unicode: bool + Reader: type[Reader] | None + Representer: type[BaseRepresenter] + Constructor: type[BaseConstructor] + Scanner: type[Scanner] | None + Serializer: type[Serializer] | None + default_flow_style: bool | None + comment_handling: int | None + Emitter: type[Emitter | CEmitter] + Parser: type[Parser | CParser] + Composer: type[Composer] + stream: None + canonical: bool | None + old_indent: int | None + width: int | _Inf | None + line_break: _LineBreak | None + map_indent: int | None + sequence_indent: int | None + sequence_dash_offset: int + compact_seq_seq: bool | None + compact_seq_map: bool | None + sort_base_mapping_type_on_output: bool | None + top_level_colon_align: int | Literal[True] | None + prefix_colon: str | None + preserve_quotes: bool | None + allow_duplicate_keys: bool + encoding: str + explicit_start: bool | None + explicit_end: bool | None + doc_infos: list[DocInfo] + default_style: _ScalarStyle | None + top_level_block_style_scalar_no_indent_error_1_1: bool + scalar_after_indicator: bool | None + brace_single_entry_mapping_in_flow_sequence: bool + boolean_representation: Sequence[str] + @overload + def __new__( + cls, + *, + typ: Literal["rt"] | list[Literal["rt"]] | None = None, + pure: bool = False, + output: Path | _WriteStream | None = None, + plug_ins: list[str] | None = None, + ) -> _RoundTripYAML: ... + @overload + def __new__( + cls, + *, + typ: Literal["full"] | list[Literal["full"]], + pure: bool = False, + output: Path | _WriteStream | None = None, + plug_ins: list[str] | None = None, + ) -> _FullYAML: ... + @overload + def __new__( + cls, + *, + typ: _YAMLType | list[_YAMLType], + pure: bool = False, + output: Path | _WriteStream | None = None, + plug_ins: list[str] | None = None, + ) -> Self: ... + # This redundant overload prevents type checkers from matching the deprecated "unsafe" overload + # when users are typing `YAML(typ=)`. + @overload + def __init__( + self, + *, + typ: Literal["rt"] | list[Literal["rt"]] | None = None, + pure: bool = False, + output: Path | _WriteStream | None = None, + plug_ins: list[str] | None = None, + ) -> None: ... + @overload + @deprecated("For **dumping only** use YAML(typ='full')", category=PendingDeprecationWarning) + def __init__( + self, + *, + typ: Literal["unsafe"] | list[Literal["unsafe"]], + pure: bool = False, + output: Path | _WriteStream | None = None, + plug_ins: list[str] | None = None, + ) -> None: ... + @overload + def __init__( + self, + *, + typ: _YAMLType | list[_YAMLType], + pure: bool = False, + output: Path | _WriteStream | None = None, + plug_ins: list[str] | None = None, + ) -> None: ... + @property + def reader(self) -> _Reader: ... + @property + def scanner(self) -> _Scanner: ... + @property + def parser(self) -> _Parser | CParser | None: ... + @property + def composer(self) -> _Composer: ... + @property + def constructor(self) -> BaseConstructor: ... + @property + def resolver(self) -> BaseResolver: ... + @property + def emitter(self) -> _Emitter | CEmitter | None: ... + @property + def serializer(self) -> _Serializer: ... + @property + def representer(self) -> BaseRepresenter: ... + def scan(self, stream: _ReadStream) -> Iterator[Token]: ... + def parse(self, stream: _ReadStream) -> Iterator[Event]: ... + def compose(self, stream: Path | _ReadStream) -> Node: ... + def compose_all(self, stream: _ReadStream) -> Iterator[Node]: ... + def load(self, stream: Path | _ReadStream) -> Any: ... + def load_all(self, stream: Path | _ReadStream) -> Iterator[Any]: ... + def get_constructor_parser(self, stream: _ReadStream) -> tuple[BaseConstructor, _Parser | CParser]: ... + def emit(self, events: Iterable[Event], stream: _WriteStream) -> None: ... + def serialize(self, node: Node, stream: _WriteStream) -> None: ... + def serialize_all(self, nodes: Iterable[Node], stream: _WriteStream) -> None: ... + def dump(self, data: Any, stream: Path | _WriteStream, *, transform: Callable[[str], str] | None = None) -> None: ... + def dump_all( + self, documents: Iterable[Any], stream: Path | _WriteStream, *, transform: Callable[[str], str] | None = None + ) -> None: ... + def Xdump_all( + self, documents: Iterable[Any], stream: Path | _WriteStream, *, transform: Callable[[str], str] | None = None + ) -> None: ... + def get_serializer_representer_emitter( + self, stream: _WriteStream, tlca: int | None + ) -> tuple[_Serializer, BaseRepresenter, _Emitter | CEmitter]: ... + @overload + def map(self) -> dict[Any, Any]: ... + @overload + def map(self, **kw: _T) -> dict[str, _T]: ... + @overload + def seq(self) -> list[Any]: ... + @overload + def seq(self, iterable: Iterable[_T], /) -> list[_T]: ... + def official_plug_ins(self) -> list[str]: ... + def register_class(self, cls: _RegistrableClass) -> _RegistrableClass: ... + def __enter__(self) -> _YAMLContext: ... + def __exit__(self, typ: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None) -> None: ... + @property + def version(self) -> _VersionTuple | None: ... + @version.setter + def version(self, val: VersionType) -> None: ... + @property + def tags(self) -> _TagHandleToPrefix | None: ... + @tags.setter + def tags(self, val: _TagHandleToPrefix | None) -> None: ... + @property + def indent(self) -> _IndentSetter: ... + @indent.setter + def indent(self, val: int | None) -> None: ... + @property + def block_seq_indent(self) -> int: ... + @block_seq_indent.setter + def block_seq_indent(self, val: int) -> None: ... + def compact(self, seq_seq: bool | None = None, seq_map: bool | None = None) -> None: ... + +class _IndentSetter(Protocol): + def __call__(self, mapping: int | None = None, sequence: int | None = None, offset: int | None = None) -> None: ... + +class _RoundTripYAML(YAML): + Representer: type[RoundTripRepresenter] + Constructor: type[RoundTripConstructor] + Scanner: type[RoundTripScanner] + Emitter: type[RoundTripEmitter] + Parser: type[RoundTripParser] + @overload + def map(self) -> CommentedMap[Any, Any]: ... + @overload + def map(self, **kw: _T) -> CommentedMap[str, _T]: ... + @overload + def seq(self) -> CommentedSeq[Any]: ... + @overload + def seq(self, iterable: Iterable[_T], /) -> CommentedSeq[_T]: ... + def __enter__(self) -> _RoundTripYAMLContext: ... + +class _FullYAML(YAML): + @property + def composer(self) -> NoReturn: ... + @property + def constructor(self) -> NoReturn: ... + @deprecated("You can only use YAML(typ='full') for dumping") + def scan(self, stream) -> NoReturn: ... + @deprecated("You can only use YAML(typ='full') for dumping") + def parse(self, stream) -> NoReturn: ... + @deprecated("You can only use YAML(typ='full') for dumping") + def compose(self, stream) -> NoReturn: ... + @deprecated("You can only use YAML(typ='full') for dumping") + def compose_all(self, stream) -> NoReturn: ... + @deprecated("You can only use YAML(typ='full') for dumping") + def load(self, stream) -> NoReturn: ... + @deprecated("You can only use YAML(typ='full') for dumping") + def load_all(self, stream) -> NoReturn: ... + def get_constructor_parser(self, stream) -> NoReturn: ... + def __enter__(self) -> _FullYAMLContext: ... + +class _YAMLContext(YAML): + def dump(self, data: Any, stream: Unused = None, *, transform: None = None) -> None: ... # type: ignore[override] + def dump_all(self, documents, stream=None, *, transform=None) -> NoReturn: ... + +class _RoundTripYAMLContext(_YAMLContext, _RoundTripYAML): ... +class _FullYAMLContext(_YAMLContext, _FullYAML): ... + +class YAMLContextManager: + def __init__(self, yaml: YAML, transform: Callable[[str], str] | None = None) -> None: ... + def teardown_output(self) -> None: ... + def init_output(self, first_data: Any) -> None: ... + def dump(self, data: Any) -> None: ... + +# This is because we can't mark protocol fields as not required +# See https://github.com/python/typing/issues/601 +_RegistrableClass: TypeAlias = type[_RegistrableObject | object] + +class _RegistrableObject(Protocol): + yaml_tag: str + @classmethod + def to_yaml(cls, representer: BaseRepresenter, data: Self, /) -> Node: ... + @classmethod + def from_yaml(cls, constructor: BaseConstructor, node: Node, /) -> Self: ... + +def yaml_object(yml: YAML) -> Callable[[_RegistrableClass], _RegistrableClass]: ... +def warn_deprecation(fun: str, method: str, arg: str = "") -> None: ... +def error_deprecation(fun: str, method: str, arg: str = "", comment: str = "instead of") -> NoReturn: ... +@deprecated("Use YAML().scan() instead") +def scan(*args, **kwargs) -> NoReturn: ... +@deprecated("Use YAML().parse() instead") +def parse(*args, **kwargs) -> NoReturn: ... +@deprecated("Use YAML().compose() instead") +def compose(*args, **kwargs) -> NoReturn: ... +@deprecated("Use YAML().compose_all() instead") +def compose_all(*args, **kwargs) -> NoReturn: ... +@deprecated("Use YAML().load() instead") +def load(*args, **kwargs) -> NoReturn: ... +@deprecated("Use YAML().load_all() instead") +def load_all(*args, **kwargs) -> NoReturn: ... +@deprecated("Use YAML(typ='safe', pure=True).load() instead") +def safe_load(*args, **kwargs) -> NoReturn: ... +@deprecated("Use YAML(typ='safe', pure=True).load_all() instead") +def safe_load_all(*args, **kwargs) -> NoReturn: ... +@deprecated("Use YAML().load() instead") +def round_trip_load(*args, **kwargs) -> NoReturn: ... +@deprecated("Use YAML().load_all() instead") +def round_trip_load_all(*args, **kwargs) -> NoReturn: ... +@deprecated("Use YAML(typ='safe', pure=True).emit() instead") +def emit(*args, **kwargs) -> NoReturn: ... +@deprecated("Use YAML(typ='safe', pure=True).serialize_all() instead") +def serialize_all(*args, **kwargs) -> NoReturn: ... +@deprecated("Use YAML(typ='safe', pure=True).serialize() instead") +def serialize(*args, **kwargs) -> NoReturn: ... +@deprecated("Use YAML(typ='unsafe', pure=True).dump_all() instead") +def dump_all(*args, **kwargs) -> NoReturn: ... +@deprecated("Use YAML(typ='unsafe', pure=True).dump() instead") +def dump(*args, **kwargs) -> NoReturn: ... +@deprecated("Use YAML(typ='safe', pure=True).dump() instead") +def safe_dump(*args, **kwargs) -> NoReturn: ... +@deprecated("Use YAML().dump() instead") +def round_trip_dump(*args, **kwargs) -> NoReturn: ... +def add_implicit_resolver( + tag: str, + regexp: Pattern[str], + first: list[str] | None = None, + Loader: type[BaseResolver] | None = None, + Dumper: type[BaseResolver] | None = None, + resolver: type[BaseResolver] = ..., +) -> None: ... +def add_path_resolver( + tag: str, + path: Iterable[Any], + kind: type | None = None, + Loader: type[BaseResolver] | None = None, + Dumper: type[BaseResolver] | None = None, + resolver: type[BaseResolver] = ..., +) -> None: ... +@overload +def add_constructor( + tag: Tag | str | None, object_constructor: _ConstructorFunction[_Constructor], *, constructor: type[_Constructor] +) -> None: ... +@overload +def add_constructor( + tag: Tag | str | None, object_constructor: _ConstructorFunction[_Constructor], Loader: type[_Constructor] +) -> None: ... +@overload +def add_constructor(tag: Tag | str | None, object_constructor: _ConstructorFunction[Constructor]) -> None: ... +@overload +def add_multi_constructor( + tag_prefix: str | None, multi_constructor: _MultiConstructorFunction[_Constructor], *, constructor: type[_Constructor] +) -> None: ... +@overload +def add_multi_constructor( + tag_prefix: str | None, multi_constructor: _MultiConstructorFunction[_Constructor], Loader: type[_Constructor] +) -> None: ... +@overload +def add_multi_constructor(tag_prefix: str | None, multi_constructor: _MultiConstructorFunction[Constructor]) -> None: ... +@overload +def add_representer( + data_type: type[_T] | None, object_representer: _RepresenterFunction[_Representer, _T], *, representer: type[_Representer] +) -> None: ... +@overload +def add_representer( + data_type: type[_T] | None, object_representer: _RepresenterFunction[_Representer, _T], Dumper: type[_Representer] +) -> None: ... +@overload +def add_representer(data_type: type[_T] | None, object_representer: _RepresenterFunction[Representer, _T]) -> None: ... +@overload +def add_multi_representer( + data_type: type[_T] | None, multi_representer: _RepresenterFunction[_Representer, _T], *, representer: type[_Representer] +) -> None: ... +@overload +def add_multi_representer( + data_type: type[_T] | None, multi_representer: _RepresenterFunction[_Representer, _T], Dumper: type[_Representer] +) -> None: ... +@overload +def add_multi_representer(data_type: type[_T] | None, multi_representer: _RepresenterFunction[Representer, _T]) -> None: ... + +class YAMLObjectMetaclass(type): + def __init__(cls, name: str, bases: tuple[type, ...], kwds: dict[str, Any], /) -> None: ... + +class YAMLObject(metaclass=YAMLObjectMetaclass): + yaml_constructor: ClassVar[type[BaseConstructor]] + yaml_representer: ClassVar[type[BaseRepresenter]] + yaml_tag: Tag | str | None + yaml_flow_style: bool | None + @classmethod + def from_yaml(cls, constructor: BaseConstructor, node: Node) -> Self: ... + @classmethod + def to_yaml(cls, representer: BaseRepresenter, data: Self) -> Node: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/nodes.pyi b/stubs/ruamel.yaml/ruamel/yaml/nodes.pyi new file mode 100644 index 000000000000..524ce7218565 --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/nodes.pyi @@ -0,0 +1,95 @@ +from typing import Any, ClassVar, Literal +from typing_extensions import TypeAlias + +from .anchor import Anchor +from .error import _Mark +from .tag import Tag +from .tokens import _CommentGroup, _ScalarStyle + +_ScalarNodeStyle: TypeAlias = Literal["?", "-"] | _ScalarStyle + +class Node: + id: ClassVar[str] + ctag: Tag + value: Any + start_mark: _Mark | None + end_mark: _Mark | None + comment: _CommentGroup | None + anchor: Anchor | str | None + def __init__( + self, + tag: Tag | str | None, + value: Any, + start_mark: _Mark | None, + end_mark: _Mark | None, + *, + comment: _CommentGroup | None = None, + anchor: Anchor | str | None = None, + ) -> None: ... + @property + def tag(self) -> str | None: ... + @tag.setter + def tag(self, val: Tag | str | None, /) -> None: ... + def dump(self, *, indent: int = 0) -> None: ... + +class ScalarNode(Node): + id: ClassVar[Literal["scalar"]] + value: str + style: _ScalarNodeStyle | None + def __init__( + self, + tag: Tag | str | None, + value: str, + start_mark: _Mark | None = None, + end_mark: _Mark | None = None, + *, + style: _ScalarNodeStyle | None = None, + comment: _CommentGroup | None = None, + anchor: Anchor | str | None = None, + ) -> None: ... + +class CollectionNode(Node): + value: list[Any] + flow_style: bool | None + def __init__( + self, + tag: Tag | str | None, + value: list[Any], + start_mark: _Mark | None = None, + end_mark: _Mark | None = None, + *, + flow_style: bool | None = None, + comment: _CommentGroup | None = None, + anchor: Anchor | str | None = None, + ) -> None: ... + +class SequenceNode(CollectionNode): + id: ClassVar[Literal["sequence"]] + value: list[Node] + def __init__( + self, + tag: Tag | str | None, + value: list[Node], + start_mark: _Mark | None = None, + end_mark: _Mark | None = None, + *, + flow_style: bool | None = None, + comment: _CommentGroup | None = None, + anchor: Anchor | str | None = None, + ) -> None: ... + +class MappingNode(CollectionNode): + id: ClassVar[Literal["mapping"]] + value: list[tuple[Node, Node]] + merge: list[tuple[Node, Node]] | None + def __init__( + self, + tag: Tag | str | None, + value: list[tuple[Node, Node]], + start_mark: _Mark | None = None, + end_mark: _Mark | None = None, + *, + flow_style: bool | None = None, + comment: _CommentGroup | None = None, + anchor: Anchor | str | None = None, + ) -> None: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/parser.pyi b/stubs/ruamel.yaml/ruamel/yaml/parser.pyi new file mode 100644 index 000000000000..73fd419f2314 --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/parser.pyi @@ -0,0 +1,71 @@ +from collections.abc import Callable +from typing import Final + +from .error import MarkedYAMLError, _Mark +from .events import Event +from .loader import _Loader +from .main import YAML +from .resolver import BaseResolver +from .scanner import Scanner +from .tag import Tag, _TagHandleToPrefix +from .tokens import CommentToken, Token, _VersionTuple + +__all__ = ["Parser", "RoundTripParser", "ParserError"] + +class ParserError(MarkedYAMLError): ... + +class Parser: + DEFAULT_TAGS: Final[_TagHandleToPrefix] + loader: YAML | _Loader + def __init__(self, loader: YAML | _Loader) -> None: ... + current_event: Event | None + last_event: Event | None + tag_handles: _TagHandleToPrefix + states: list[Callable[[], Event]] + marks: list[_Mark] + state: Callable[[], Event] + def reset_parser(self) -> None: ... + def dispose(self) -> None: ... + @property + def scanner(self) -> Scanner: ... + @property + def resolver(self) -> BaseResolver: ... + def check_event(self, *choices: type[Event]) -> bool: ... + def peek_event(self) -> Event: ... + def get_event(self) -> Event: ... + def parse_stream_start(self) -> Event: ... + def parse_implicit_document_start(self) -> Event: ... + def parse_document_start(self) -> Event: ... + def parse_document_end(self) -> Event: ... + def parse_document_content(self) -> Event: ... + def process_directives(self) -> tuple[_VersionTuple | None, _TagHandleToPrefix | None]: ... + def parse_block_node(self) -> Event: ... + def parse_flow_node(self) -> Event: ... + def parse_block_node_or_indentless_sequence(self) -> Event: ... + def select_tag_transform(self, tag: Tag) -> None: ... + def parse_node(self, block: bool = False, indentless_sequence: bool = False) -> Event: ... + def parse_block_sequence_first_entry(self) -> Event: ... + def parse_block_sequence_entry(self) -> Event: ... + def parse_indentless_sequence_entry(self) -> Event: ... + def parse_block_mapping_first_key(self) -> Event: ... + def parse_block_mapping_key(self) -> Event: ... + def parse_block_mapping_value(self) -> Event: ... + def parse_flow_sequence_first_entry(self) -> Event: ... + def parse_flow_sequence_entry(self, first: bool = False) -> Event: ... + def parse_flow_sequence_entry_mapping_key(self) -> Event: ... + def parse_flow_sequence_entry_mapping_value(self) -> Event: ... + def parse_flow_sequence_entry_mapping_end(self) -> Event: ... + def parse_flow_mapping_first_key(self) -> Event: ... + def parse_flow_mapping_key(self, first: bool = False) -> Event: ... + def parse_flow_mapping_value(self) -> Event: ... + def parse_flow_mapping_empty_value(self) -> Event: ... + def process_empty_scalar(self, mark: _Mark, comment: list[CommentToken | None] | list[None] | None = None) -> Event: ... + def move_token_comment(self, token: Token, nt: Token | None = None, empty: bool | None = False) -> None: ... + +class RoundTripParser(Parser): + def select_tag_transform(self, tag: Tag) -> None: ... + def move_token_comment(self, token: Token, nt: Token | None = None, empty: bool | None = False) -> None: ... + +class RoundTripParserSC(RoundTripParser): + def move_token_comment(self, token: Token, nt: Token | None = None, empty: bool | None = False) -> None: ... + def distribute_comment(self, comment: list[list[int] | None] | None, line: int) -> list[list[int] | None]: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/reader.pyi b/stubs/ruamel.yaml/ruamel/yaml/reader.pyi new file mode 100644 index 000000000000..919a7e32b124 --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/reader.pyi @@ -0,0 +1,52 @@ +from _typeshed import ReadableBuffer, SupportsRead +from re import Pattern +from typing import Final, Literal, Protocol + +from .compat import _ReadStream +from .error import StreamMark, YAMLError +from .loader import _Loader +from .main import YAML + +__all__ = ["Reader", "ReaderError"] + +# One of codecs.{utf_16_le_decode, utf_16_be_decode, utf_8_decode} +class _BufferDecoder(Protocol): + def __call__(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ... + +class ReaderError(YAMLError): + name: str | None + character: int + position: int + encoding: str + reason: str + def __init__(self, name: str | None, position: int, character: int, encoding: str, reason: str) -> None: ... + +class Reader: + loader: YAML | _Loader | None + def __init__(self, stream: _ReadStream | None, loader: YAML | _Loader | None = None) -> None: ... + name: str | None + stream_pointer: int + eof: bool + buffer: str + pointer: int + raw_buffer: str | bytes | None + raw_decode: _BufferDecoder | None + encoding: Literal["utf-16-le", "utf-16-be", "utf-8"] | None + index: int + line: int + column: int + def reset_reader(self) -> None: ... + @property + def stream(self) -> SupportsRead[str | bytes] | None: ... + @stream.setter + def stream(self, val: _ReadStream | None, /) -> None: ... + def peek(self, index: int = 0) -> str: ... + def prefix(self, length: int = 1) -> str: ... + def forward_1_1(self, length: int = 1) -> None: ... + def forward(self, length: int = 1) -> None: ... + def get_mark(self) -> StreamMark: ... + def determine_encoding(self) -> None: ... + NON_PRINTABLE: Final[Pattern[str]] + def check_printable(self, data: str) -> None: ... + def update(self, length: int) -> None: ... + def update_raw(self, size: int | None = None) -> None: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/representer.pyi b/stubs/ruamel.yaml/ruamel/yaml/representer.pyi new file mode 100644 index 000000000000..8ccdeaead9b1 --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/representer.pyi @@ -0,0 +1,150 @@ +from _typeshed import Unused +from collections import OrderedDict +from collections.abc import Collection, Mapping, Set as AbstractSet +from datetime import date, datetime +from types import ModuleType +from typing import Any, ClassVar, Final, NoReturn, Protocol, TypeVar +from typing_extensions import Self + +from .anchor import Anchor +from .comments import CommentedSet, TaggedScalar +from .dumper import _Dumper +from .error import YAMLError +from .main import YAML +from .nodes import MappingNode, Node, ScalarNode, SequenceNode +from .scalarbool import ScalarBoolean +from .scalarfloat import ScalarFloat +from .scalarint import BinaryInt, HexCapsInt, HexInt, OctalInt, ScalarInt, _Underscore +from .scalarstring import ( + DoubleQuotedScalarString, + FoldedScalarString, + LiteralScalarString, + PlainScalarString, + SingleQuotedScalarString, +) +from .serializer import Serializer +from .tag import Tag +from .timestamp import TimeStamp +from .tokens import _CommentGroup, _ScalarStyle + +__all__ = ["BaseRepresenter", "SafeRepresenter", "Representer", "RepresenterError", "RoundTripRepresenter"] + +_T = TypeVar("_T") +_T_contra = TypeVar("_T_contra", contravariant=True) +_Representer = TypeVar("_Representer", bound=BaseRepresenter, contravariant=True) + +class _RepresenterFunction(Protocol[_Representer, _T_contra]): + def __call__(self, dumper: _Representer, data: _T_contra, /) -> Node: ... + +class RepresenterError(YAMLError): ... + +class BaseRepresenter: + yaml_representers: ClassVar[dict[type | None, _RepresenterFunction[Self, Any]]] + yaml_multi_representers: ClassVar[dict[type | None, _RepresenterFunction[Self, Any]]] + dumper: YAML | _Dumper | None + default_style: _ScalarStyle | None + default_flow_style: bool | None + represented_objects: dict[int, Node] + object_keeper: list[Any] + alias_key: int | None + sort_base_mapping_type_on_output: bool + def __init__( + self, + default_style: _ScalarStyle | None = None, + default_flow_style: bool | None = None, + dumper: YAML | _Dumper | None = None, + ) -> None: ... + @property + def serializer(self) -> Serializer: ... + def represent(self, data: Any) -> None: ... + def represent_data(self, data: Any) -> Node: ... + def represent_key(self, data: Any) -> Node: ... + @classmethod + def add_representer(cls, data_type: type[_T] | None, representer: _RepresenterFunction[Self, _T]) -> None: ... + @classmethod + def add_multi_representer(cls, data_type: type[_T] | None, representer: _RepresenterFunction[Self, _T]) -> None: ... + def represent_scalar( + self, tag: Tag | str | None, value: str, style: _ScalarStyle | None = None, anchor: Anchor | None = None + ) -> ScalarNode: ... + def represent_sequence( + self, tag: Tag | str | None, sequence: Collection[Any], flow_style: bool | None = None + ) -> SequenceNode: ... + def represent_omap( + self, tag: Tag | str | None, omap: OrderedDict[Any, Any], flow_style: bool | None = None + ) -> SequenceNode: ... + def represent_mapping( + self, tag: Tag | str | None, mapping: Mapping[Any, Any], flow_style: bool | None = None + ) -> MappingNode: ... + def ignore_aliases(self, data: Any) -> bool: ... + +class SafeRepresenter(BaseRepresenter): + def ignore_aliases(self, data: Any) -> bool: ... + def represent_none(self, data: None) -> ScalarNode: ... + def represent_str(self, data: str) -> ScalarNode: ... + def represent_binary(self, data: bytes) -> ScalarNode: ... + def represent_bool(self, data: bool, anchor: Anchor | None = None) -> ScalarNode: ... + def represent_int(self, data: int) -> ScalarNode: ... + inf_value: Final[float] + def represent_float(self, data: float) -> ScalarNode: ... + def represent_list(self, data: Collection[Any]) -> SequenceNode: ... + def represent_dict(self, data: Mapping[Any, Any]) -> MappingNode: ... + def represent_ordereddict(self, data: OrderedDict[Any, Any]) -> SequenceNode: ... + def represent_set(self, data: AbstractSet[Any]) -> MappingNode: ... + def represent_date(self, data: date) -> ScalarNode: ... + def represent_datetime(self, data: datetime) -> ScalarNode: ... + def represent_yaml_object( + self, tag: Tag | str | None, data: Any, cls: Unused, flow_style: bool | None = None + ) -> MappingNode: ... + def represent_undefined(self, data: object) -> NoReturn: ... + +class Representer(SafeRepresenter): + def represent_complex(self, data: complex) -> ScalarNode: ... + def represent_tuple(self, data: tuple[Any, ...]) -> SequenceNode: ... + def represent_name(self, data: Any) -> ScalarNode: ... + def represent_module(self, data: ModuleType) -> ScalarNode: ... + def represent_object(self, data: Any) -> Node: ... + +class RoundTripRepresenter(SafeRepresenter): + def __init__( + self, + default_style: _ScalarStyle | None = None, + default_flow_style: bool | None = None, + dumper: YAML | _Dumper | None = None, + ) -> None: ... + def ignore_aliases(self, data: Any) -> bool: ... + def represent_none(self, data: None) -> ScalarNode: ... + def represent_literal_scalarstring(self, data: LiteralScalarString) -> ScalarNode: ... + represent_preserved_scalarstring = represent_literal_scalarstring + def represent_folded_scalarstring(self, data: FoldedScalarString) -> ScalarNode: ... + def represent_single_quoted_scalarstring(self, data: SingleQuotedScalarString) -> ScalarNode: ... + def represent_double_quoted_scalarstring(self, data: DoubleQuotedScalarString) -> ScalarNode: ... + def represent_plain_scalarstring(self, data: PlainScalarString) -> ScalarNode: ... + def insert_underscore( + self, prefix: str, s: str, underscore: _Underscore | None, anchor: Anchor | None = None + ) -> ScalarNode: ... + def represent_scalar_int(self, data: ScalarInt) -> ScalarNode: ... + def represent_binary_int(self, data: BinaryInt) -> ScalarNode: ... + def represent_octal_int(self, data: OctalInt) -> ScalarNode: ... + def represent_hex_int(self, data: HexInt) -> ScalarNode: ... + def represent_hex_caps_int(self, data: HexCapsInt) -> ScalarNode: ... + def represent_scalar_float(self, data: ScalarFloat) -> ScalarNode: ... + def represent_sequence( + self, tag: Tag | str | None, sequence: Collection[Any], flow_style: bool | None = None + ) -> SequenceNode: ... + def merge_comments(self, node: Node, comments: _CommentGroup | None) -> Node: ... + def represent_key(self, data: Any) -> Node: ... + def represent_mapping( + self, tag: Tag | str | None, mapping: Mapping[Any, Any], flow_style: bool | None = None + ) -> MappingNode: ... + def represent_omap( + self, tag: Tag | str | None, omap: OrderedDict[Any, Any], flow_style: bool | None = None + ) -> SequenceNode: ... + def represent_set(self, setting: CommentedSet[Any]) -> MappingNode: ... # type: ignore[override] + def represent_dict(self, data: Mapping[Any, Any]) -> MappingNode: ... + def represent_list(self, data: Collection[Any]) -> SequenceNode: ... + def represent_datetime(self, data: TimeStamp) -> ScalarNode: ... # type: ignore[override] + def represent_tagged_scalar(self, data: TaggedScalar) -> ScalarNode: ... + def represent_scalar_bool(self, data: ScalarBoolean) -> ScalarNode: ... + def represent_yaml_object( + self, tag: Tag | str | None, data: Any, cls: Unused, flow_style: bool | None = None + ) -> MappingNode: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/resolver.pyi b/stubs/ruamel.yaml/ruamel/yaml/resolver.pyi new file mode 100644 index 000000000000..725aeea87ef1 --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/resolver.pyi @@ -0,0 +1,71 @@ +from collections.abc import Iterable +from re import Pattern +from typing import Any, Final, overload +from typing_extensions import TypeAlias + +from .compat import VersionType +from .dumper import _Dumper +from .error import YAMLError +from .loader import _Loader +from .main import YAML +from .nodes import CollectionNode, MappingNode, Node, ScalarNode, SequenceNode +from .parser import Parser +from .tag import Tag +from .tokens import _VersionTuple + +__all__ = ["BaseResolver", "Resolver", "VersionedResolver"] + +_TagStr: TypeAlias = str +_First: TypeAlias = str | None + +implicit_resolvers: list[tuple[list[_VersionTuple], _TagStr, Pattern[str], list[_First]]] + +class ResolverError(YAMLError): ... + +class BaseResolver: + DEFAULT_SCALAR_TAG: Final[Tag] + DEFAULT_SEQUENCE_TAG: Final[Tag] + DEFAULT_MAPPING_TAG: Final[Tag] + yaml_implicit_resolvers: dict[_First, list[tuple[_TagStr, Pattern[str]]]] + yaml_path_resolvers: dict[Any, _TagStr] + loadumper: YAML | _Loader | _Dumper | None + resolver_exact_paths: list[Any] + resolver_prefix_paths: list[Any] + def __init__(self, loadumper: YAML | _Loader | _Dumper | None = None) -> None: ... + @property + def parser(self) -> Parser | None: ... + @classmethod + def add_implicit_resolver_base(cls, tag: _TagStr, regexp: Pattern[str], first: list[_First] | None) -> None: ... + @classmethod + def add_implicit_resolver(cls, tag: _TagStr, regexp: Pattern[str], first: list[_First] | None) -> None: ... + @classmethod + def add_path_resolver(cls, tag: _TagStr, path: Iterable[Any], kind: type | None = None) -> None: ... + def descend_resolver(self, current_node: CollectionNode | None, current_index: int | Node | None) -> None: ... + def ascend_resolver(self) -> None: ... + def check_resolver_prefix(self, depth: int, path, kind, current_node, current_index) -> bool: ... + @overload + def resolve(self, kind: type[ScalarNode], value: str, implicit: tuple[bool, bool]) -> Tag: ... + @overload + def resolve(self, kind: type[SequenceNode], value: list[Node] | None, implicit: bool) -> Tag: ... + @overload + def resolve(self, kind: type[MappingNode], value: list[tuple[Node, Node]] | None, implicit: bool) -> Tag: ... + @property + def processing_version(self) -> _VersionTuple | None: ... + +class Resolver(BaseResolver): ... + +class VersionedResolver(BaseResolver): + def __init__( + self, + version: VersionType | None = None, + loader: YAML | _Loader | _Dumper | None = None, + loadumper: YAML | _Loader | _Dumper | None = None, + ) -> None: ... + def add_version_implicit_resolver( + self, version: VersionType, tag: _TagStr, regexp: Pattern[str], first: list[_First] | None + ) -> None: ... + def get_loader_version(self, version: VersionType | None) -> _VersionTuple | None: ... + @property + def versioned_resolver(self) -> dict[_First, list[tuple[_TagStr, Pattern[str]]]]: ... + @property + def processing_version(self) -> _VersionTuple: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/scalarbool.pyi b/stubs/ruamel.yaml/ruamel/yaml/scalarbool.pyi new file mode 100644 index 000000000000..7f99a221b08f --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/scalarbool.pyi @@ -0,0 +1,12 @@ +from typing_extensions import Self + +from .anchor import Anchor + +__all__ = ["ScalarBoolean"] + +class ScalarBoolean(int): + def __new__(cls, value: bool, /, *, anchor: str | None = None) -> Self: ... + @property + def anchor(self) -> Anchor: ... + def yaml_anchor(self, *, any: bool = False) -> Anchor | None: ... + def yaml_set_anchor(self, value: str, /, *, always_dump: bool = False) -> None: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/scalarfloat.pyi b/stubs/ruamel.yaml/ruamel/yaml/scalarfloat.pyi new file mode 100644 index 000000000000..9b2ef7b50590 --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/scalarfloat.pyi @@ -0,0 +1,50 @@ +from _typeshed import SupportsWrite +from typing import Literal +from typing_extensions import Self + +from .anchor import Anchor +from .scalarint import _Underscore + +__all__ = ["ScalarFloat", "ExponentialFloat", "ExponentialCapsFloat"] + +class ScalarFloat(float): + _width: int + _prec: int + _m_sign: Literal[False, "+", "-"] + _m_lead0: int + _exp: Literal["e", "E"] | None + _e_width: int | None + _e_sign: bool | None + _underscore: _Underscore | None + def __new__( + cls, + value: float, + /, + *, + width: int, + prec: int, + m_sign: Literal[False, "+", "-"], + m_lead0: int, + exp: Literal["e", "E"] | None = None, + e_width: int | None = None, + e_sign: bool | None = None, + underscore: _Underscore | None = None, + anchor: str | None = None, + ) -> Self: ... + # The following methods explicitly return floats + def __iadd__(self, a: float, /) -> float: ... # noqa: Y034 + def __ifloordiv__(self, a: float, /) -> float: ... # noqa: Y034 + def __imul__(self, a: float, /) -> float: ... # noqa: Y034 + def __ipow__(self, a: float, /) -> float: ... # type: ignore[override, misc] # noqa: Y034 + def __isub__(self, a: float, /) -> float: ... # noqa: Y034 + @property + def anchor(self) -> Anchor: ... + def yaml_anchor(self, *, any: bool = False) -> Anchor: ... + def yaml_set_anchor(self, value: str, /, *, always_dump: bool = False) -> None: ... + def dump(self, out: SupportsWrite[str] = ...) -> None: ... + +class ExponentialFloat(ScalarFloat): + def __new__(cls, value: float, /, *, width: int | None = None, underscore: _Underscore | None = None) -> Self: ... + +class ExponentialCapsFloat(ScalarFloat): + def __new__(cls, value: float, /, *, width: int | None = None, underscore: _Underscore | None = None) -> Self: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/scalarint.pyi b/stubs/ruamel.yaml/ruamel/yaml/scalarint.pyi new file mode 100644 index 000000000000..019f4bb51c09 --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/scalarint.pyi @@ -0,0 +1,48 @@ +from typing_extensions import Self, TypeAlias + +from .anchor import Anchor + +__all__ = ["ScalarInt", "BinaryInt", "OctalInt", "HexInt", "HexCapsInt", "DecimalInt"] + +_Underscore: TypeAlias = list[int | bool] # [int, bool, bool] + +class ScalarInt(int): + _width: int | None + _underscore: _Underscore | None + def __new__( + cls, value: int, /, *, width: int | None = None, underscore: _Underscore | None = None, anchor: str | None = None + ) -> Self: ... + def __iadd__(self, a: int, /) -> Self: ... + def __ifloordiv__(self, a: int, /) -> Self: ... + def __imul__(self, a: int, /) -> Self: ... + def __ipow__(self, a: int, /) -> Self: ... # type: ignore[override, misc] + def __isub__(self, a: int, /) -> Self: ... + @property + def anchor(self) -> Anchor: ... + def yaml_anchor(self, *, any: bool = False) -> Anchor | None: ... + def yaml_set_anchor(self, value: str, /, *, always_dump: bool = False) -> None: ... + +class BinaryInt(ScalarInt): + def __new__( + cls, value: int, /, *, width: int | None = None, underscore: _Underscore | None = None, anchor: str | None = None + ) -> Self: ... + +class OctalInt(ScalarInt): + def __new__( + cls, value: int, /, *, width: int | None = None, underscore: _Underscore | None = None, anchor: str | None = None + ) -> Self: ... + +class HexInt(ScalarInt): + def __new__( + cls, value: int, /, *, width: int | None = None, underscore: _Underscore | None = None, anchor: str | None = None + ) -> Self: ... + +class HexCapsInt(ScalarInt): + def __new__( + cls, value: int, /, *, width: int | None = None, underscore: _Underscore | None = None, anchor: str | None = None + ) -> Self: ... + +class DecimalInt(ScalarInt): + def __new__( + cls, value: int, /, *, width: int | None = None, underscore: _Underscore | None = None, anchor: str | None = None + ) -> Self: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/scalarstring.pyi b/stubs/ruamel.yaml/ruamel/yaml/scalarstring.pyi new file mode 100644 index 000000000000..09a331ca0f58 --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/scalarstring.pyi @@ -0,0 +1,55 @@ +from collections.abc import Callable, Mapping +from typing import Any, Final, SupportsIndex +from typing_extensions import Self + +from .anchor import Anchor +from .comments import CommentedMap, CommentedSeq +from .tokens import _ScalarStyle + +__all__ = [ + "ScalarString", + "LiteralScalarString", + "FoldedScalarString", + "SingleQuotedScalarString", + "DoubleQuotedScalarString", + "PlainScalarString", + "PreservedScalarString", +] + +class ScalarString(str): + def __new__(cls, value: str, /, *, anchor: str | None = None) -> Self: ... + def replace(self, old: str, new: str, maxreplace: SupportsIndex = -1, /) -> Self: ... + @property + def anchor(self) -> Anchor: ... + def yaml_anchor(self, *, any: bool = False) -> Anchor: ... + def yaml_set_anchor(self, value: str, /, *, always_dump: bool = False) -> None: ... + +class LiteralScalarString(ScalarString): + style: Final[_ScalarStyle] = "|" + comment: str + def __new__(cls, value: str, /, *, anchor: str | None = None) -> Self: ... + +PreservedScalarString = LiteralScalarString + +class FoldedScalarString(ScalarString): + style: Final[_ScalarStyle] = ">" + fold_pos: list[int] + comment: str + def __new__(cls, value: str, /, *, anchor: str | None = None) -> Self: ... + +class SingleQuotedScalarString(ScalarString): + style: Final[_ScalarStyle] = "'" + def __new__(cls, value: str, /, *, anchor: str | None = None) -> Self: ... + +class DoubleQuotedScalarString(ScalarString): + style: Final[_ScalarStyle] = '"' + def __new__(cls, value: str, /, *, anchor: str | None = None) -> Self: ... + +class PlainScalarString(ScalarString): + style: Final[_ScalarStyle] = "" + def __new__(cls, value: str, /, *, anchor: str | None = None) -> Self: ... + +def preserve_literal(s: str, /) -> str: ... +def walk_tree( + base: CommentedMap[Any, Any] | CommentedSeq[Any], map: Mapping[str, Callable[[str], str]] | None = None +) -> None: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/scanner.pyi b/stubs/ruamel.yaml/ruamel/yaml/scanner.pyi new file mode 100644 index 000000000000..63a541c6933d --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/scanner.pyi @@ -0,0 +1,190 @@ +from collections.abc import Iterator +from typing import ClassVar, Final, Literal + +from .error import MarkedYAMLError, StreamMark +from .loader import _Loader +from .main import YAML +from .reader import Reader +from .tokens import ( + AliasToken, + AnchorToken, + BlockEndToken, + DirectiveToken, + DocumentEndToken, + DocumentStartToken, + FlowMappingEndToken, + FlowMappingStartToken, + FlowSequenceEndToken, + FlowSequenceStartToken, + ScalarToken, + TagToken, + Token, + _BlockScalarStyle, + _FlowScalarStyle, + _TagDirective, + _VersionTuple, +) + +__all__ = ["Scanner", "RoundTripScanner", "ScannerError"] + +class ScannerError(MarkedYAMLError): ... + +class SimpleKey: + token_number: int + required: bool + index: int + line: int + column: int + mark: StreamMark + def __init__(self, token_number: int, required: bool, index: int, line: int, column: int, mark: StreamMark) -> None: ... + +class Scanner: + loader: YAML | _Loader | None + first_time: bool + def __init__(self, loader: YAML | _Loader | None = None) -> None: ... + @property + def flow_level(self) -> int: ... + done: bool + flow_context: list[str] + tokens: list[Token] + tokens_taken: int + indent: int + indents: list[int] + allow_simple_key: bool + possible_simple_keys: dict[int, SimpleKey] + yaml_version: _VersionTuple | None + tag_directives: list[_TagDirective] + def reset_scanner(self) -> None: ... + @property + def reader(self) -> Reader: ... + @property + def scanner_processing_version(self) -> _VersionTuple: ... + def check_token(self, *choices: type[Token]) -> bool: ... + def peek_token(self) -> Token: ... + def get_token(self) -> Token: ... + def need_more_tokens(self) -> bool: ... + def fetch_comment(self, comment) -> None: ... + def fetch_more_tokens(self) -> None: ... + def next_possible_simple_key(self) -> int | None: ... + def stale_possible_simple_keys(self) -> None: ... + def save_possible_simple_key(self) -> None: ... + def remove_possible_simple_key(self) -> None: ... + def unwind_indent(self, column: int) -> None: ... + def add_indent(self, column: int) -> bool: ... + def fetch_stream_start(self) -> None: ... + def fetch_stream_end(self) -> None: ... + def fetch_directive(self) -> None: ... + def fetch_document_start(self) -> None: ... + def fetch_document_end(self) -> None: ... + def fetch_document_indicator(self, TokenClass: type[DocumentStartToken | DocumentEndToken]) -> None: ... + def fetch_flow_sequence_start(self) -> None: ... + def fetch_flow_mapping_start(self) -> None: ... + def fetch_flow_collection_start( + self, TokenClass: type[FlowSequenceStartToken | FlowMappingStartToken], to_push: str + ) -> None: ... + def fetch_flow_sequence_end(self) -> None: ... + def fetch_flow_mapping_end(self) -> None: ... + def fetch_flow_collection_end(self, TokenClass: type[FlowSequenceEndToken | FlowMappingEndToken]) -> None: ... + def fetch_flow_entry(self) -> None: ... + def fetch_block_entry(self) -> None: ... + def fetch_key(self) -> None: ... + def fetch_value(self) -> None: ... + def fetch_alias(self) -> None: ... + def fetch_anchor(self) -> None: ... + def fetch_tag(self) -> None: ... + def fetch_literal(self) -> None: ... + def fetch_folded(self) -> None: ... + def fetch_block_scalar(self, style: _BlockScalarStyle) -> None: ... + def fetch_single(self) -> None: ... + def fetch_double(self) -> None: ... + def fetch_flow_scalar(self, style: _FlowScalarStyle) -> None: ... + def fetch_plain(self) -> None: ... + def check_directive(self) -> Literal[True] | None: ... + def check_document_start(self) -> Literal[True] | None: ... + def check_document_end(self) -> Literal[True] | None: ... + def check_block_entry(self) -> bool: ... + def check_key(self) -> bool: ... + def check_value(self) -> bool: ... + def check_plain(self) -> bool: ... + def scan_to_next_token(self) -> tuple[str, StreamMark, StreamMark] | None: ... + def scan_directive(self) -> DirectiveToken: ... + def scan_directive_name(self, start_mark: StreamMark) -> str: ... + def scan_yaml_directive_value(self, start_mark: StreamMark) -> _VersionTuple: ... + def scan_yaml_directive_number(self, start_mark: StreamMark) -> int: ... + def scan_tag_directive_value(self, start_mark: StreamMark) -> _TagDirective: ... + def scan_tag_directive_handle(self, start_mark: StreamMark) -> str: ... + def scan_tag_directive_prefix(self, start_mark: StreamMark) -> str: ... + def scan_directive_ignored_line(self, start_mark: StreamMark) -> None: ... + def scan_anchor(self, TokenClass: type[AliasToken | AnchorToken]) -> AliasToken | AnchorToken: ... + def scan_tag(self) -> TagToken: ... + def scan_block_scalar(self, style: _BlockScalarStyle, rt: bool | None = False) -> ScalarToken: ... + def scan_block_scalar_indicators(self, start_mark: StreamMark) -> tuple[bool | None, int | None]: ... + def scan_block_scalar_ignored_line(self, start_mark: StreamMark) -> str | None: ... + def scan_block_scalar_indentation(self) -> tuple[list[str], int, StreamMark]: ... + def scan_block_scalar_breaks(self, indent: int) -> tuple[list[str], StreamMark]: ... + def scan_flow_scalar(self, style: _FlowScalarStyle) -> ScalarToken: ... + ESCAPE_REPLACEMENTS: Final[dict[str, str]] + ESCAPE_CODES: Final[dict[str, int]] + def scan_flow_scalar_non_spaces(self, double: bool, start_mark: StreamMark) -> list[str]: ... + def scan_flow_scalar_spaces(self, double: bool, start_mark: StreamMark) -> list[str]: ... + def scan_flow_scalar_breaks(self, double: bool, start_mark: StreamMark) -> list[str]: ... + def scan_plain(self) -> ScalarToken: ... + def scan_plain_spaces(self, indent: int, start_mark: StreamMark) -> list[str]: ... + def scan_tag_handle(self, name: str, start_mark: StreamMark) -> str: ... + def scan_tag_uri(self, name: str, start_mark: StreamMark) -> str: ... + def scan_uri_escapes(self, name: str, start_mark: StreamMark) -> str: ... + def scan_line_break(self) -> str: ... + +class RoundTripScanner(Scanner): + def check_token(self, *choices: type[Token]) -> bool: ... + def peek_token(self) -> Token: ... + def get_token(self) -> Token: ... + def fetch_comment(self, comment: tuple[str, StreamMark, StreamMark]) -> None: ... + def scan_to_next_token(self) -> tuple[str, StreamMark, StreamMark]: ... + def scan_line_break(self, empty_line: bool = False) -> str: ... + def scan_block_scalar(self, style: _BlockScalarStyle, rt: bool | None = True) -> ScalarToken: ... + def scan_uri_escapes(self, name: str, start_mark: StreamMark) -> str: ... + +class CommentBase: # RTSC + name: ClassVar[str] + value: str + line: int + column: int + used: str + def __init__(self, value: str, line: int, column: int) -> None: ... + def set_used(self, v: str = "+") -> None: ... + def set_assigned(self) -> None: ... + def info(self) -> str: ... + +class EOLComment(CommentBase): + name: Final = "EOLC" + +class FullLineComment(CommentBase): + name: Final = "FULL" + +class BlankLineComment(CommentBase): + name: Final = "BLNK" + +class ScannedComments: # RTSC + comments: dict[int, CommentBase] + unused: list[int] + def __init__(self) -> None: ... + def add_eol_comment(self, comment: str, column: int, line: int) -> EOLComment: ... + def add_blank_line(self, comment: str, column: int, line: int) -> BlankLineComment: ... + def add_full_line_comment(self, comment: str, column: int, line: int) -> FullLineComment: ... + def __getitem__(self, idx: int) -> CommentBase: ... + def last(self) -> str: ... + def any_unprocessed(self) -> bool: ... + def unprocessed(self, use: bool = False) -> Iterator[tuple[int, CommentBase]]: ... + def assign_pre(self, token: Token) -> bool: ... + def assign_eol(self, tokens: list[Token]) -> None: ... + def assign_post(self, token: BlockEndToken) -> bool: ... + def str_unprocessed(self) -> str: ... + +class RoundTripScannerSC(Scanner): + comments: ScannedComments | None + def get_token(self) -> Token: ... + def need_more_tokens(self) -> bool: ... + def scan_to_next_token(self) -> None: ... + def scan_empty_or_full_line_comments(self) -> None: ... + def scan_block_scalar_ignored_line(self, start_mark) -> None: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/serializer.pyi b/stubs/ruamel.yaml/ruamel/yaml/serializer.pyi new file mode 100644 index 000000000000..13aa0c2e6d03 --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/serializer.pyi @@ -0,0 +1,49 @@ +from re import Pattern +from typing import Final, Literal + +from .compat import VersionType +from .dumper import _Dumper +from .emitter import Emitter +from .error import YAMLError +from .main import YAML +from .nodes import CollectionNode, Node +from .resolver import BaseResolver +from .tag import _TagHandleToPrefix +from .tokens import _VersionTuple + +__all__ = ["Serializer", "SerializerError"] + +class SerializerError(YAMLError): ... + +class Serializer: + ANCHOR_TEMPLATE: Final[str] + ANCHOR_RE: Final[Pattern[str]] + dumper: YAML | _Dumper | None + use_encoding: str | None + use_explicit_start: bool | None + use_explicit_end: bool | None + use_version: _VersionTuple | None + use_tags: _TagHandleToPrefix | None + serialized_nodes: dict[Node, Literal[True]] + anchors: dict[Node, str | None] + last_anchor_id: int + closed: bool | None + def __init__( + self, + encoding: str | None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: VersionType | None = None, + tags: _TagHandleToPrefix | None = None, + dumper: YAML | _Dumper | None = None, + ) -> None: ... + @property + def emitter(self) -> Emitter: ... + @property + def resolver(self) -> BaseResolver: ... + def open(self) -> None: ... + def close(self) -> None: ... + def serialize(self, node: Node) -> None: ... + def anchor_node(self, node: Node) -> None: ... + def generate_anchor(self, node: Node) -> str: ... + def serialize_node(self, node: Node, parent: CollectionNode | None, index: int | Node | None) -> None: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/tag.pyi b/stubs/ruamel.yaml/ruamel/yaml/tag.pyi new file mode 100644 index 000000000000..6f86910b6850 --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/tag.pyi @@ -0,0 +1,25 @@ +from typing import Final +from typing_extensions import TypeAlias + +_TagHandleToPrefix: TypeAlias = dict[str, str] + +tag_attrib: Final = "_yaml_tag" + +class Tag: + attrib: Final = tag_attrib + handle: str | None + suffix: str | None + handles: _TagHandleToPrefix | None + def __init__( + self, *, handle: str | None = None, suffix: str | None = None, handles: _TagHandleToPrefix | None = None + ) -> None: ... + def __hash__(self) -> int: ... + def __eq__(self, other: Tag | str, /) -> bool: ... # type: ignore[override] + def startswith(self, x: str, /) -> bool: ... + @property + def trval(self) -> str | None: ... + value = trval + @property + def uri_decoded_suffix(self) -> str | None: ... + def select_transform(self, val: bool, /) -> None: ... + def check_handle(self) -> bool: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/timestamp.pyi b/stubs/ruamel.yaml/ruamel/yaml/timestamp.pyi new file mode 100644 index 000000000000..319849518d11 --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/timestamp.pyi @@ -0,0 +1,5 @@ +from _typeshed import Unused +from datetime import datetime + +class TimeStamp(datetime): + def __deepcopy__(self, memo: Unused) -> TimeStamp: ... diff --git a/stubs/ruamel.yaml/ruamel/yaml/tokens.pyi b/stubs/ruamel.yaml/ruamel/yaml/tokens.pyi new file mode 100644 index 000000000000..fd57b768bc92 --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/tokens.pyi @@ -0,0 +1,133 @@ +from typing import ClassVar, Literal, overload +from typing_extensions import Self, TypeAlias + +from .error import CommentMark, StreamMark, _Mark + +_PostComment: TypeAlias = CommentToken +_PreComments: TypeAlias = list[CommentToken] | list[str] +_CommentGroup: TypeAlias = list[_PostComment | _PreComments | None] +_VersionTuple: TypeAlias = tuple[int, int] +_TagDirective: TypeAlias = tuple[str, str] +_FlowScalarStyle: TypeAlias = Literal['"', "'"] +_BlockScalarStyle: TypeAlias = Literal["|", ">"] +_ScalarStyle: TypeAlias = _FlowScalarStyle | _BlockScalarStyle | Literal[""] + +class Token: + id: ClassVar[str] + start_mark: _Mark + end_mark: _Mark + def __init__(self, start_mark: _Mark, end_mark: _Mark) -> None: ... + @property + def column(self) -> int: ... + @column.setter + def column(self, pos: int, /) -> None: ... + def add_post_comment(self, comment: _PostComment, /) -> None: ... + def add_pre_comments(self, comments: _PreComments, /) -> None: ... + def add_comment_pre(self, comment: int) -> None: ... # RTSC + def add_comment_eol(self, comment: int, comment_type: int) -> None: ... # RTSC + def add_comment_post(self, comment: int) -> None: ... # RTSC + @property + def comment(self) -> _CommentGroup | None: ... + def move_old_comment(self, target: Token, *, empty: bool = False) -> Self | None: ... + def split_old_comment(self) -> list[CommentToken | None]: ... + def move_new_comment(self, target: Token, *, empty: bool = False) -> Self | None: ... + +class DirectiveToken(Token): + id: ClassVar[Literal[""]] + name: str + value: _VersionTuple | _TagDirective | None + @overload + def __init__(self, name: Literal["YAML"], value: _VersionTuple, start_mark: _Mark, end_mark: _Mark) -> None: ... + @overload + def __init__(self, name: Literal["TAG"], value: _TagDirective, start_mark: _Mark, end_mark: _Mark) -> None: ... + @overload + def __init__(self, name: str, value: None, start_mark: _Mark, end_mark: _Mark) -> None: ... + +class DocumentStartToken(Token): + id: ClassVar[Literal[""]] + +class DocumentEndToken(Token): + id: ClassVar[Literal[""]] + +class StreamStartToken(Token): + id: ClassVar[Literal[""]] + encoding: str | None + def __init__(self, start_mark: _Mark, end_mark: _Mark, encoding: str | None = None) -> None: ... + +class StreamEndToken(Token): + id: ClassVar[Literal[""]] + +class BlockSequenceStartToken(Token): + id: ClassVar[Literal[""]] + +class BlockMappingStartToken(Token): + id: ClassVar[Literal[""]] + +class BlockEndToken(Token): + id: ClassVar[Literal[""]] + +class FlowSequenceStartToken(Token): + id: ClassVar[Literal["["]] + +class FlowMappingStartToken(Token): + id: ClassVar[Literal["{"]] + +class FlowSequenceEndToken(Token): + id: ClassVar[Literal["]"]] + +class FlowMappingEndToken(Token): + id: ClassVar[Literal["}"]] + +class KeyToken(Token): + id: ClassVar[Literal["?"]] + +class ValueToken(Token): + id: ClassVar[Literal[":"]] + +class BlockEntryToken(Token): + id: ClassVar[Literal["-"]] + +class FlowEntryToken(Token): + id: ClassVar[Literal[","]] + +class AliasToken(Token): + id: ClassVar[Literal[""]] + value: str + def __init__(self, value: str, start_mark: _Mark, end_mark: _Mark) -> None: ... + +class AnchorToken(Token): + id: ClassVar[Literal[""]] + value: str + def __init__(self, value: str, start_mark: _Mark, end_mark: _Mark) -> None: ... + +class TagToken(Token): + id: ClassVar[Literal[""]] + value: tuple[str | None, str] + def __init__(self, value: tuple[str | None, str], start_mark: _Mark, end_mark: _Mark) -> None: ... + +class ScalarToken(Token): + id: ClassVar[Literal[""]] + value: str + plain: bool + style: _ScalarStyle | None + def __init__( + self, value: str, plain: bool, start_mark: _Mark, end_mark: _Mark, style: _ScalarStyle | None = None + ) -> None: ... + +class CommentToken(Token): + id: ClassVar[Literal[""]] + pre_done: bool + def __init__( + self, + value: str, + start_mark: CommentMark | StreamMark | None = None, + end_mark: StreamMark | None = None, + column: int | None = None, + ) -> None: ... + @property + def value(self) -> str: ... + @value.setter + def value(self, val: str, /) -> None: ... + def reset(self) -> None: ... + def __eq__(self, other: CommentToken, /) -> bool: ... # type: ignore[override] + def __ne__(self, other: CommentToken, /) -> bool: ... # type: ignore[override] diff --git a/stubs/ruamel.yaml/ruamel/yaml/util.pyi b/stubs/ruamel.yaml/ruamel/yaml/util.pyi new file mode 100644 index 000000000000..e4a1b82f17ae --- /dev/null +++ b/stubs/ruamel.yaml/ruamel/yaml/util.pyi @@ -0,0 +1,34 @@ +import re +from collections.abc import Callable, Iterator +from datetime import date, datetime +from typing import Any, Final + +from configobj import ConfigObj # type: ignore[import-not-found] # pyright: ignore[reportMissingImports] + +from .compat import _ReadStream + +class LazyEval: + def __init__(self, func: Callable[..., Any], *args, **kwargs) -> None: ... + def __getattribute__(self, name: str, /) -> Any: ... + def __setattr__(self, name: str, value: Any, /) -> None: ... + +RegExp: Final = re.compile +timestamp_regexp: Final[re.Pattern[str]] + +def create_timestamp( + *, + year: str, + month: str, + day: str, + t: str | None, + hour: str | None, + minute: str | None, + second: str | None, + fraction: str | None, + tz: str | None, + tz_sign: str | None, + tz_hour: str | None, + tz_minute: str | None, +) -> date | datetime: ... +def load_yaml_guess_indent(stream: _ReadStream, /) -> tuple[Any, int | None, int | None]: ... +def configobj_walker(cfg: ConfigObj, /) -> Iterator[str]: ... diff --git a/tests/pytype_exclude_list.txt b/tests/pytype_exclude_list.txt index 0355bc94076e..8e967f45fe40 100644 --- a/tests/pytype_exclude_list.txt +++ b/tests/pytype_exclude_list.txt @@ -18,3 +18,7 @@ stubs/openpyxl/openpyxl/descriptors/nested.pyi # matplotlib not installed during tests stubs/shapely/shapely/plotting.pyi + +# configobj not installed during tests +stubs/ruamel.yaml/ruamel/yaml/configobjwalker.pyi +stubs/ruamel.yaml/ruamel/yaml/util.pyi