diff options
Diffstat (limited to '.venv/lib/python3.12/site-packages/yaml-stubs')
20 files changed, 1417 insertions, 0 deletions
diff --git a/.venv/lib/python3.12/site-packages/yaml-stubs/METADATA.toml b/.venv/lib/python3.12/site-packages/yaml-stubs/METADATA.toml new file mode 100644 index 00000000..c31b588e --- /dev/null +++ b/.venv/lib/python3.12/site-packages/yaml-stubs/METADATA.toml @@ -0,0 +1,2 @@ +version = "6.0.*" +upstream_repository = "https://github.com/yaml/pyyaml" diff --git a/.venv/lib/python3.12/site-packages/yaml-stubs/__init__.pyi b/.venv/lib/python3.12/site-packages/yaml-stubs/__init__.pyi new file mode 100644 index 00000000..883492c7 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/yaml-stubs/__init__.pyi @@ -0,0 +1,438 @@ +from collections.abc import Callable, Iterable, Iterator, Mapping +from re import Pattern +from typing import Any, TypeVar, overload + +from . import resolver as resolver # Help mypy a bit; this is implied by loader and dumper +from .constructor import BaseConstructor +from .cyaml import * +from .cyaml import _CLoader +from .dumper import * +from .dumper import _Inf +from .emitter import _WriteStream +from .error import * +from .events import * +from .loader import * +from .loader import _Loader +from .nodes import * +from .reader import _ReadStream +from .representer import BaseRepresenter +from .resolver import BaseResolver +from .tokens import * + +_T = TypeVar("_T") +_Constructor = TypeVar("_Constructor", bound=BaseConstructor) +_Representer = TypeVar("_Representer", bound=BaseRepresenter) + +__with_libyaml__: bool +__version__: str + +def warnings(settings=None): ... +def scan(stream, Loader: type[_Loader | _CLoader] = ...): ... +def parse(stream, Loader: type[_Loader | _CLoader] = ...): ... +def compose(stream, Loader: type[_Loader | _CLoader] = ...): ... +def compose_all(stream, Loader: type[_Loader | _CLoader] = ...): ... +def load(stream: _ReadStream, Loader: type[_Loader | _CLoader]) -> Any: ... +def load_all(stream: _ReadStream, Loader: type[_Loader | _CLoader]) -> Iterator[Any]: ... +def full_load(stream: _ReadStream) -> Any: ... +def full_load_all(stream: _ReadStream) -> Iterator[Any]: ... +def safe_load(stream: _ReadStream) -> Any: ... +def safe_load_all(stream: _ReadStream) -> Iterator[Any]: ... +def unsafe_load(stream: _ReadStream) -> Any: ... +def unsafe_load_all(stream: _ReadStream) -> Iterator[Any]: ... +def emit( + events, + stream: _WriteStream[Any] | None = None, + Dumper=..., + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: str | None = None, +): ... +@overload +def serialize_all( + nodes, + stream: _WriteStream[Any], + Dumper=..., + *, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: str | None = None, + encoding: str | None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: tuple[int, int] | None = None, + tags: Mapping[str, str] | None = None, +) -> None: ... +@overload +def serialize_all( + nodes, + stream: None = None, + Dumper=..., + *, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: str | None = None, + encoding: None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: tuple[int, int] | None = None, + tags: Mapping[str, str] | None = None, +) -> str: ... +@overload +def serialize_all( + nodes, + stream: None = None, + Dumper=..., + *, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: str | None = None, + encoding: str, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: tuple[int, int] | None = None, + tags: Mapping[str, str] | None = None, +) -> bytes: ... +@overload +def serialize( + node, + stream: _WriteStream[Any], + Dumper=..., + *, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: str | None = None, + encoding: str | None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: tuple[int, int] | None = None, + tags: Mapping[str, str] | None = None, +) -> None: ... +@overload +def serialize( + node, + stream: None = None, + Dumper=..., + *, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: str | None = None, + encoding: None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: tuple[int, int] | None = None, + tags: Mapping[str, str] | None = None, +) -> str: ... +@overload +def serialize( + node, + stream: None = None, + Dumper=..., + *, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: str | None = None, + encoding: str, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: tuple[int, int] | None = None, + tags: Mapping[str, str] | None = None, +) -> bytes: ... +@overload +def dump_all( + documents: Iterable[Any], + stream: _WriteStream[Any], + Dumper=..., + *, + default_style: str | None = None, + default_flow_style: bool | None = False, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: str | None = None, + encoding: str | None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: tuple[int, int] | None = None, + tags: Mapping[str, str] | None = None, + sort_keys: bool = True, +) -> None: ... +@overload +def dump_all( + documents: Iterable[Any], + stream: None = None, + Dumper=..., + *, + default_style: str | None = None, + default_flow_style: bool | None = False, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: str | None = None, + encoding: None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: tuple[int, int] | None = None, + tags: Mapping[str, str] | None = None, + sort_keys: bool = True, +) -> str: ... +@overload +def dump_all( + documents: Iterable[Any], + stream: None = None, + Dumper=..., + *, + default_style: str | None = None, + default_flow_style: bool | None = False, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: str | None = None, + encoding: str, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: tuple[int, int] | None = None, + tags: Mapping[str, str] | None = None, + sort_keys: bool = True, +) -> bytes: ... +@overload +def dump( + data: Any, + stream: _WriteStream[Any], + Dumper=..., + *, + default_style: str | None = None, + default_flow_style: bool | None = False, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: str | None = None, + encoding: str | None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: tuple[int, int] | None = None, + tags: Mapping[str, str] | None = None, + sort_keys: bool = True, +) -> None: ... +@overload +def dump( + data: Any, + stream: None = None, + Dumper=..., + *, + default_style: str | None = None, + default_flow_style: bool | None = False, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: str | None = None, + encoding: None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: tuple[int, int] | None = None, + tags: Mapping[str, str] | None = None, + sort_keys: bool = True, +) -> str: ... +@overload +def dump( + data: Any, + stream: None = None, + Dumper=..., + *, + default_style: str | None = None, + default_flow_style: bool | None = False, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: str | None = None, + encoding: str, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: tuple[int, int] | None = None, + tags: Mapping[str, str] | None = None, + sort_keys: bool = True, +) -> bytes: ... +@overload +def safe_dump_all( + documents: Iterable[Any], + stream: _WriteStream[Any], + *, + default_style: str | None = None, + default_flow_style: bool | None = False, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: str | None = None, + encoding: str | None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: tuple[int, int] | None = None, + tags: Mapping[str, str] | None = None, + sort_keys: bool = True, +) -> None: ... +@overload +def safe_dump_all( + documents: Iterable[Any], + stream: None = None, + *, + default_style: str | None = None, + default_flow_style: bool | None = False, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: str | None = None, + encoding: None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: tuple[int, int] | None = None, + tags: Mapping[str, str] | None = None, + sort_keys: bool = True, +) -> str: ... +@overload +def safe_dump_all( + documents: Iterable[Any], + stream: None = None, + *, + default_style: str | None = None, + default_flow_style: bool | None = False, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: str | None = None, + encoding: str, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: tuple[int, int] | None = None, + tags: Mapping[str, str] | None = None, + sort_keys: bool = True, +) -> bytes: ... +@overload +def safe_dump( + data: Any, + stream: _WriteStream[Any], + *, + default_style: str | None = None, + default_flow_style: bool | None = False, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: str | None = None, + encoding: str | None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: tuple[int, int] | None = None, + tags: Mapping[str, str] | None = None, + sort_keys: bool = True, +) -> None: ... +@overload +def safe_dump( + data: Any, + stream: None = None, + *, + default_style: str | None = None, + default_flow_style: bool | None = False, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: str | None = None, + encoding: None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: tuple[int, int] | None = None, + tags: Mapping[str, str] | None = None, + sort_keys: bool = True, +) -> str: ... +@overload +def safe_dump( + data: Any, + stream: None = None, + *, + default_style: str | None = None, + default_flow_style: bool | None = False, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: str | None = None, + encoding: str, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: tuple[int, int] | None = None, + tags: Mapping[str, str] | None = None, + sort_keys: bool = True, +) -> bytes: ... +def add_implicit_resolver( + tag: str, + regexp: Pattern[str], + first: Iterable[Any] | None = None, + Loader: type[BaseResolver] | None = None, + Dumper: type[BaseResolver] = ..., +) -> None: ... +def add_path_resolver( + tag: str, + path: Iterable[Any], + kind: type[Any] | None = None, + Loader: type[BaseResolver] | None = None, + Dumper: type[BaseResolver] = ..., +) -> None: ... +@overload +def add_constructor( + tag: str, constructor: Callable[[Loader | FullLoader | UnsafeLoader, Node], Any], Loader: None = None +) -> None: ... +@overload +def add_constructor(tag: str, constructor: Callable[[_Constructor, Node], Any], Loader: type[_Constructor]) -> None: ... +@overload +def add_multi_constructor( + tag_prefix: str, multi_constructor: Callable[[Loader | FullLoader | UnsafeLoader, str, Node], Any], Loader: None = None +) -> None: ... +@overload +def add_multi_constructor( + tag_prefix: str, multi_constructor: Callable[[_Constructor, str, Node], Any], Loader: type[_Constructor] +) -> None: ... +@overload +def add_representer(data_type: type[_T], representer: Callable[[Dumper, _T], Node]) -> None: ... +@overload +def add_representer(data_type: type[_T], representer: Callable[[_Representer, _T], Node], Dumper: type[_Representer]) -> None: ... +@overload +def add_multi_representer(data_type: type[_T], multi_representer: Callable[[Dumper, _T], Node]) -> None: ... +@overload +def add_multi_representer( + data_type: type[_T], multi_representer: Callable[[_Representer, _T], Node], Dumper: type[_Representer] +) -> None: ... + +class YAMLObjectMetaclass(type): + def __init__(cls, name, bases, kwds) -> None: ... + +class YAMLObject(metaclass=YAMLObjectMetaclass): + yaml_loader: Any + yaml_dumper: Any + yaml_tag: Any + yaml_flow_style: Any + @classmethod + def from_yaml(cls, loader, node): ... + @classmethod + def to_yaml(cls, dumper, data): ... diff --git a/.venv/lib/python3.12/site-packages/yaml-stubs/_yaml.pyi b/.venv/lib/python3.12/site-packages/yaml-stubs/_yaml.pyi new file mode 100644 index 00000000..33dfb596 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/yaml-stubs/_yaml.pyi @@ -0,0 +1,56 @@ +from _typeshed import Incomplete, SupportsRead +from collections.abc import Mapping, Sequence +from typing import IO, Any + +from .events import Event +from .nodes import Node +from .tokens import Token + +def get_version_string() -> str: ... +def get_version() -> tuple[int, int, int]: ... + +class Mark: + name: Any + index: int + line: int + column: int + buffer: Any + pointer: Any + def __init__(self, name, index: int, line: int, column: int, buffer, pointer) -> None: ... + def get_snippet(self): ... + +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) -> bool: ... + def get_event(self) -> Event | None: ... + def peek_event(self) -> Event | None: ... + def check_event(self, *choices) -> 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: IO[Any], + canonical: Incomplete | None = ..., + indent: int | None = ..., + width: int | None = ..., + allow_unicode: Incomplete | None = ..., + line_break: str | None = ..., + encoding: str | None = ..., + explicit_start: Incomplete | None = ..., + explicit_end: Incomplete | None = ..., + version: Sequence[int] | None = ..., + tags: Mapping[str, str] | None = ..., + ) -> None: ... + def dispose(self) -> None: ... + def emit(self, event_object) -> None: ... + def open(self) -> None: ... + def close(self) -> None: ... + def serialize(self, node) -> None: ... diff --git a/.venv/lib/python3.12/site-packages/yaml-stubs/composer.pyi b/.venv/lib/python3.12/site-packages/yaml-stubs/composer.pyi new file mode 100644 index 00000000..7bc87357 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/yaml-stubs/composer.pyi @@ -0,0 +1,18 @@ +from typing import Any + +from yaml.error import MarkedYAMLError +from yaml.nodes import MappingNode, Node, ScalarNode, SequenceNode + +class ComposerError(MarkedYAMLError): ... + +class Composer: + anchors: dict[Any, Node] + def __init__(self) -> None: ... + def check_node(self) -> bool: ... + def get_node(self) -> Node | None: ... + def get_single_node(self) -> Node | None: ... + def compose_document(self) -> Node | None: ... + def compose_node(self, parent: Node | None, index: int) -> Node | None: ... + def compose_scalar_node(self, anchor: dict[Any, Node]) -> ScalarNode: ... + def compose_sequence_node(self, anchor: dict[Any, Node]) -> SequenceNode: ... + def compose_mapping_node(self, anchor: dict[Any, Node]) -> MappingNode: ... diff --git a/.venv/lib/python3.12/site-packages/yaml-stubs/constructor.pyi b/.venv/lib/python3.12/site-packages/yaml-stubs/constructor.pyi new file mode 100644 index 00000000..14aeb646 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/yaml-stubs/constructor.pyi @@ -0,0 +1,103 @@ +from collections.abc import Callable, Hashable +from datetime import date +from re import Pattern +from typing import Any, ClassVar, TypeVar + +from yaml.error import MarkedYAMLError +from yaml.nodes import MappingNode, Node, ScalarNode, SequenceNode + +from .cyaml import _CLoader +from .loader import _Loader + +_L = TypeVar("_L", bound=_Loader | _CLoader) +_N = TypeVar("_N", bound=Node) + +class ConstructorError(MarkedYAMLError): ... + +class BaseConstructor: + yaml_constructors: Any + yaml_multi_constructors: Any + constructed_objects: Any + recursive_objects: Any + state_generators: Any + deep_construct: Any + def __init__(self) -> None: ... + def check_data(self): ... + def check_state_key(self, key: str) -> None: ... + def get_data(self): ... + def get_single_data(self) -> Any: ... + def construct_document(self, node): ... + def construct_object(self, node, deep=False): ... + 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[Hashable, Any]: ... + def construct_pairs(self, node, deep=False): ... + @classmethod + # Use typevars so we can have covariant behaviour in the parameter types + def add_constructor(cls, tag: str, constructor: Callable[[_L, _N], Any]) -> None: ... + @classmethod + def add_multi_constructor(cls, tag_prefix, multi_constructor): ... + +class SafeConstructor(BaseConstructor): + def construct_scalar(self, node: ScalarNode | MappingNode) -> str: ... + def flatten_mapping(self, node: MappingNode) -> None: ... + def construct_mapping(self, node: MappingNode, deep: bool = False) -> dict[Hashable, Any]: ... + def construct_yaml_null(self, node: ScalarNode) -> None: ... + bool_values: ClassVar[dict[str, bool]] + def construct_yaml_bool(self, node: ScalarNode) -> bool: ... + def construct_yaml_int(self, node: ScalarNode) -> int: ... + inf_value: ClassVar[float] + nan_value: ClassVar[float] + def construct_yaml_float(self, node: ScalarNode) -> float: ... + def construct_yaml_binary(self, node: ScalarNode) -> bytes: ... + timestamp_regexp: ClassVar[Pattern[str]] + def construct_yaml_timestamp(self, node: ScalarNode) -> date: ... + def construct_yaml_omap(self, node): ... + def construct_yaml_pairs(self, node): ... + def construct_yaml_set(self, node): ... + def construct_yaml_str(self, node): ... + def construct_yaml_seq(self, node): ... + def construct_yaml_map(self, node): ... + def construct_yaml_object(self, node, cls): ... + def construct_undefined(self, node): ... + +class FullConstructor(SafeConstructor): + def get_state_keys_blacklist(self) -> list[str]: ... + def get_state_keys_blacklist_regexp(self) -> Pattern[str]: ... + def construct_python_str(self, node): ... + def construct_python_unicode(self, node): ... + def construct_python_bytes(self, node): ... + def construct_python_long(self, node): ... + def construct_python_complex(self, node): ... + def construct_python_tuple(self, node): ... + def find_python_module(self, name: str, mark, unsafe: bool = False): ... + def find_python_name(self, name: str, mark, unsafe: bool = False): ... + def construct_python_name(self, suffix, node): ... + def construct_python_module(self, suffix, node): ... + def make_python_instance(self, suffix, node, args=None, kwds=None, newobj: bool = False, unsafe: bool = False): ... + def set_python_instance_state(self, instance: Any, state, unsafe: bool = False) -> None: ... + def construct_python_object(self, suffix, node): ... + def construct_python_object_apply(self, suffix, node, newobj=False): ... + def construct_python_object_new(self, suffix, node): ... + +class UnsafeConstructor(FullConstructor): + def find_python_module(self, name: str, mark): ... # type: ignore[override] + def find_python_name(self, name: str, mark): ... # type: ignore[override] + def make_python_instance(self, suffix: str, node, args=None, kwds=None, newobj: bool = False): ... # type: ignore[override] + def set_python_instance_state(self, instance: Any, state): ... # type: ignore[override] + +class Constructor(SafeConstructor): + def construct_python_str(self, node): ... + def construct_python_unicode(self, node): ... + def construct_python_long(self, node): ... + def construct_python_complex(self, node): ... + def construct_python_tuple(self, node): ... + def find_python_module(self, name, mark): ... + def find_python_name(self, name, mark): ... + def construct_python_name(self, suffix, node): ... + def construct_python_module(self, suffix, node): ... + def make_python_instance(self, suffix, node, args=None, kwds=None, newobj=False): ... + def set_python_instance_state(self, instance, state): ... + def construct_python_object(self, suffix, node): ... + def construct_python_object_apply(self, suffix, node, newobj=False): ... + def construct_python_object_new(self, suffix, node): ... diff --git a/.venv/lib/python3.12/site-packages/yaml-stubs/cyaml.pyi b/.venv/lib/python3.12/site-packages/yaml-stubs/cyaml.pyi new file mode 100644 index 00000000..85526cc4 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/yaml-stubs/cyaml.pyi @@ -0,0 +1,69 @@ +from _typeshed import Incomplete, SupportsRead +from collections.abc import Mapping, Sequence +from typing import IO, Any +from typing_extensions import TypeAlias + +from ._yaml import CEmitter, CParser +from .constructor import BaseConstructor, FullConstructor, SafeConstructor, UnsafeConstructor +from .representer import BaseRepresenter, SafeRepresenter +from .resolver import BaseResolver, Resolver + +__all__ = ["CBaseLoader", "CSafeLoader", "CFullLoader", "CUnsafeLoader", "CLoader", "CBaseDumper", "CSafeDumper", "CDumper"] + +_Readable: TypeAlias = SupportsRead[str | bytes] +_CLoader: TypeAlias = CLoader | CBaseLoader | CFullLoader | CSafeLoader | CUnsafeLoader # noqa: Y047 # Used in other modules + +class CBaseLoader(CParser, BaseConstructor, BaseResolver): + def __init__(self, stream: str | bytes | _Readable) -> None: ... + +class CLoader(CParser, SafeConstructor, Resolver): + def __init__(self, stream: str | bytes | _Readable) -> None: ... + +class CSafeLoader(CParser, SafeConstructor, Resolver): + def __init__(self, stream: str | bytes | _Readable) -> None: ... + +class CFullLoader(CParser, FullConstructor, Resolver): + def __init__(self, stream: str | bytes | _Readable) -> None: ... + +class CUnsafeLoader(CParser, UnsafeConstructor, Resolver): + def __init__(self, stream: str | bytes | _Readable) -> None: ... + +class CBaseDumper(CEmitter, BaseRepresenter, BaseResolver): + def __init__( + self, + stream: IO[Any], + default_style: str | None = None, + default_flow_style: bool | None = False, + canonical: Incomplete | None = None, + indent: int | None = None, + width: int | None = None, + allow_unicode: Incomplete | None = None, + line_break: str | None = None, + encoding: str | None = None, + explicit_start: Incomplete | None = None, + explicit_end: Incomplete | None = None, + version: Sequence[int] | None = None, + tags: Mapping[str, str] | None = None, + sort_keys: bool = True, + ) -> None: ... + +class CDumper(CEmitter, SafeRepresenter, Resolver): + def __init__( + self, + stream: IO[Any], + default_style: str | None = None, + default_flow_style: bool = False, + canonical: Incomplete | None = None, + indent: int | None = None, + width: int | None = None, + allow_unicode: Incomplete | None = None, + line_break: str | None = None, + encoding: str | None = None, + explicit_start: Incomplete | None = None, + explicit_end: Incomplete | None = None, + version: Sequence[int] | None = None, + tags: Mapping[str, str] | None = None, + sort_keys: bool = True, + ) -> None: ... + +CSafeDumper = CDumper diff --git a/.venv/lib/python3.12/site-packages/yaml-stubs/dumper.pyi b/.venv/lib/python3.12/site-packages/yaml-stubs/dumper.pyi new file mode 100644 index 00000000..e9b18e1d --- /dev/null +++ b/.venv/lib/python3.12/site-packages/yaml-stubs/dumper.pyi @@ -0,0 +1,71 @@ +from collections.abc import Mapping +from typing import Any +from typing_extensions import TypeAlias + +from yaml.emitter import Emitter +from yaml.representer import BaseRepresenter, Representer, SafeRepresenter +from yaml.resolver import BaseResolver, Resolver +from yaml.serializer import Serializer + +from .emitter import _WriteStream + +# Ideally, there would be a way to limit these values to only +/- float("inf"), +# but that's not possible at the moment (https://github.com/python/typing/issues/1160). +_Inf: TypeAlias = float + +class BaseDumper(Emitter, Serializer, BaseRepresenter, BaseResolver): + def __init__( + self, + stream: _WriteStream[Any], + default_style: str | None = None, + default_flow_style: bool | None = False, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: str | None = None, + encoding: str | None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: tuple[int, int] | None = None, + tags: Mapping[str, str] | None = None, + sort_keys: bool = True, + ) -> None: ... + +class SafeDumper(Emitter, Serializer, SafeRepresenter, Resolver): + def __init__( + self, + stream: _WriteStream[Any], + default_style: str | None = None, + default_flow_style: bool | None = False, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: str | None = None, + encoding: str | None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: tuple[int, int] | None = None, + tags: Mapping[str, str] | None = None, + sort_keys: bool = True, + ) -> None: ... + +class Dumper(Emitter, Serializer, Representer, Resolver): + def __init__( + self, + stream: _WriteStream[Any], + default_style: str | None = None, + default_flow_style: bool | None = False, + canonical: bool | None = None, + indent: int | None = None, + width: int | _Inf | None = None, + allow_unicode: bool | None = None, + line_break: str | None = None, + encoding: str | None = None, + explicit_start: bool | None = None, + explicit_end: bool | None = None, + version: tuple[int, int] | None = None, + tags: Mapping[str, str] | None = None, + sort_keys: bool = True, + ) -> None: ... diff --git a/.venv/lib/python3.12/site-packages/yaml-stubs/emitter.pyi b/.venv/lib/python3.12/site-packages/yaml-stubs/emitter.pyi new file mode 100644 index 00000000..ee8f9403 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/yaml-stubs/emitter.pyi @@ -0,0 +1,128 @@ +from collections.abc import Callable +from typing import Any, NoReturn, Protocol, TypeVar + +from yaml.error import YAMLError + +from .events import Event + +_T_contra = TypeVar("_T_contra", str, bytes, contravariant=True) + +class _WriteStream(Protocol[_T_contra]): + def write(self, data: _T_contra, /) -> object: ... + # Optional fields: + # encoding: str + # def flush(self) -> object: ... + +class EmitterError(YAMLError): ... + +class ScalarAnalysis: + scalar: Any + empty: Any + multiline: Any + allow_flow_plain: Any + allow_block_plain: Any + allow_single_quoted: Any + allow_double_quoted: Any + allow_block: Any + def __init__( + self, scalar, empty, multiline, allow_flow_plain, allow_block_plain, allow_single_quoted, allow_double_quoted, allow_block + ) -> None: ... + +class Emitter: + DEFAULT_TAG_PREFIXES: dict[str, str] + stream: _WriteStream[Any] + encoding: str | None + states: list[Callable[[], None]] + state: Callable[[], None] | None + events: list[Event] + event: Event | None + indents: list[int | None] + indent: int | None + flow_level: int + root_context: bool + sequence_context: bool + mapping_context: bool + simple_key_context: bool + line: int + column: int + whitespace: bool + indention: bool + open_ended: bool + canonical: bool | None + allow_unicode: bool | None + best_indent: int + best_width: int + best_line_break: str + tag_prefixes: dict[str, str] | None + prepared_anchor: str | None + prepared_tag: str | None + analysis: ScalarAnalysis | None + style: str | None + def __init__( + self, + stream: _WriteStream[Any], + canonical: bool | None = ..., + indent: int | None = ..., + width: int | None = ..., + allow_unicode: bool | None = ..., + line_break: str | None = ..., + ) -> None: ... + 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 = ..., indentless: bool = ...) -> None: ... + def expect_stream_start(self) -> None: ... + def expect_nothing(self) -> NoReturn: ... + 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 = ..., sequence: bool = ..., mapping: bool = ..., simple_key: bool = ...) -> None: ... + def expect_alias(self) -> None: ... + def expect_scalar(self) -> None: ... + def expect_flow_sequence(self) -> None: ... + def expect_first_flow_sequence_item(self) -> None: ... + def expect_flow_sequence_item(self) -> None: ... + def expect_flow_mapping(self) -> 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 = ...) -> None: ... + def expect_block_mapping(self) -> None: ... + def expect_first_block_mapping_key(self) -> None: ... + def expect_block_mapping_key(self, first: bool = ...) -> 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) -> None: ... + def process_tag(self) -> None: ... + def choose_scalar_style(self) -> str: ... + def process_scalar(self) -> None: ... + def prepare_version(self, version) -> str: ... + def prepare_tag_handle(self, handle: str) -> str: ... + def prepare_tag_prefix(self, prefix: str) -> str: ... + def prepare_tag(self, tag: str) -> 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 = ..., indention: bool = ...) -> None: ... + def write_indent(self) -> None: ... + def write_line_break(self, data: str | 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 = ...) -> None: ... + ESCAPE_REPLACEMENTS: dict[str, str] + def write_double_quoted(self, text: str, split: bool = ...) -> None: ... + def determine_block_hints(self, text: str) -> str: ... + def write_folded(self, text: str) -> None: ... + def write_literal(self, text: str) -> None: ... + def write_plain(self, text: str, split: bool = ...) -> None: ... diff --git a/.venv/lib/python3.12/site-packages/yaml-stubs/error.pyi b/.venv/lib/python3.12/site-packages/yaml-stubs/error.pyi new file mode 100644 index 00000000..35c410ac --- /dev/null +++ b/.venv/lib/python3.12/site-packages/yaml-stubs/error.pyi @@ -0,0 +1,26 @@ +class Mark: + name: str + index: int + line: int + column: int + buffer: str | None + pointer: int + def __init__(self, name: str, index: int, line: int, column: int, buffer: str | None, pointer: int) -> None: ... + def get_snippet(self, indent: int = 4, max_length: int = 75) -> str | 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, + ) -> None: ... diff --git a/.venv/lib/python3.12/site-packages/yaml-stubs/events.pyi b/.venv/lib/python3.12/site-packages/yaml-stubs/events.pyi new file mode 100644 index 00000000..e4e2a8f1 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/yaml-stubs/events.pyi @@ -0,0 +1,62 @@ +from typing import Any + +class Event: + start_mark: Any + end_mark: Any + def __init__(self, start_mark=None, end_mark=None) -> None: ... + +class NodeEvent(Event): + anchor: Any + start_mark: Any + end_mark: Any + def __init__(self, anchor, start_mark=None, end_mark=None) -> None: ... + +class CollectionStartEvent(NodeEvent): + anchor: Any + tag: Any + implicit: Any + start_mark: Any + end_mark: Any + flow_style: Any + def __init__(self, anchor, tag, implicit, start_mark=None, end_mark=None, flow_style=None) -> None: ... + +class CollectionEndEvent(Event): ... + +class StreamStartEvent(Event): + start_mark: Any + end_mark: Any + encoding: Any + def __init__(self, start_mark=None, end_mark=None, encoding=None) -> None: ... + +class StreamEndEvent(Event): ... + +class DocumentStartEvent(Event): + start_mark: Any + end_mark: Any + explicit: Any + version: Any + tags: Any + def __init__(self, start_mark=None, end_mark=None, explicit=None, version=None, tags=None) -> None: ... + +class DocumentEndEvent(Event): + start_mark: Any + end_mark: Any + explicit: Any + def __init__(self, start_mark=None, end_mark=None, explicit=None) -> None: ... + +class AliasEvent(NodeEvent): ... + +class ScalarEvent(NodeEvent): + anchor: Any + tag: Any + implicit: Any + value: Any + start_mark: Any + end_mark: Any + style: Any + def __init__(self, anchor, tag, implicit, value, start_mark=None, end_mark=None, style=None) -> None: ... + +class SequenceStartEvent(CollectionStartEvent): ... +class SequenceEndEvent(CollectionEndEvent): ... +class MappingStartEvent(CollectionStartEvent): ... +class MappingEndEvent(CollectionEndEvent): ... diff --git a/.venv/lib/python3.12/site-packages/yaml-stubs/loader.pyi b/.venv/lib/python3.12/site-packages/yaml-stubs/loader.pyi new file mode 100644 index 00000000..950f18f9 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/yaml-stubs/loader.pyi @@ -0,0 +1,27 @@ +from typing_extensions import TypeAlias + +from yaml.composer import Composer +from yaml.constructor import BaseConstructor, Constructor, FullConstructor, SafeConstructor +from yaml.parser import Parser +from yaml.reader import Reader +from yaml.resolver import BaseResolver, Resolver +from yaml.scanner import Scanner + +from .reader import _ReadStream + +_Loader: TypeAlias = Loader | BaseLoader | FullLoader | SafeLoader | UnsafeLoader # noqa: Y047 # Used in other modules + +class BaseLoader(Reader, Scanner, Parser, Composer, BaseConstructor, BaseResolver): + def __init__(self, stream: _ReadStream) -> None: ... + +class FullLoader(Reader, Scanner, Parser, Composer, FullConstructor, Resolver): + def __init__(self, stream: _ReadStream) -> None: ... + +class SafeLoader(Reader, Scanner, Parser, Composer, SafeConstructor, Resolver): + def __init__(self, stream: _ReadStream) -> None: ... + +class Loader(Reader, Scanner, Parser, Composer, Constructor, Resolver): + def __init__(self, stream: _ReadStream) -> None: ... + +class UnsafeLoader(Reader, Scanner, Parser, Composer, Constructor, Resolver): + def __init__(self, stream: _ReadStream) -> None: ... diff --git a/.venv/lib/python3.12/site-packages/yaml-stubs/nodes.pyi b/.venv/lib/python3.12/site-packages/yaml-stubs/nodes.pyi new file mode 100644 index 00000000..de490db9 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/yaml-stubs/nodes.pyi @@ -0,0 +1,32 @@ +from typing import Any, ClassVar + +from yaml.error import Mark + +# Any Unions: Avoid forcing the user to check for None when they know what Node was instantiated with +# Using generics may be overkill without support for default Generics +# Permissive Unions could also be useful here. +class Node: + tag: str + value: Any + start_mark: Mark | Any + end_mark: Mark | Any + def __init__(self, tag: str, value, start_mark: Mark | None, end_mark: Mark | None) -> None: ... + +class ScalarNode(Node): + id: ClassVar[str] + style: str | Any + def __init__( + self, tag: str, value, start_mark: Mark | None = None, end_mark: Mark | None = None, style: str | None = None + ) -> None: ... + +class CollectionNode(Node): + flow_style: bool | Any + def __init__( + self, tag: str, value, start_mark: Mark | None = None, end_mark: Mark | None = None, flow_style: bool | None = None + ) -> None: ... + +class SequenceNode(CollectionNode): + id: ClassVar[str] + +class MappingNode(CollectionNode): + id: ClassVar[str] diff --git a/.venv/lib/python3.12/site-packages/yaml-stubs/parser.pyi b/.venv/lib/python3.12/site-packages/yaml-stubs/parser.pyi new file mode 100644 index 00000000..1db45c4e --- /dev/null +++ b/.venv/lib/python3.12/site-packages/yaml-stubs/parser.pyi @@ -0,0 +1,45 @@ +from typing import Any + +from yaml.error import MarkedYAMLError + +class ParserError(MarkedYAMLError): ... + +class Parser: + DEFAULT_TAGS: Any + current_event: Any + yaml_version: Any + tag_handles: Any + states: Any + marks: Any + state: Any + def __init__(self) -> None: ... + def dispose(self): ... + def check_event(self, *choices): ... + def peek_event(self): ... + def get_event(self): ... + def parse_stream_start(self): ... + def parse_implicit_document_start(self): ... + def parse_document_start(self): ... + def parse_document_end(self): ... + def parse_document_content(self): ... + def process_directives(self): ... + def parse_block_node(self): ... + def parse_flow_node(self): ... + def parse_block_node_or_indentless_sequence(self): ... + def parse_node(self, block=False, indentless_sequence=False): ... + def parse_block_sequence_first_entry(self): ... + def parse_block_sequence_entry(self): ... + def parse_indentless_sequence_entry(self): ... + def parse_block_mapping_first_key(self): ... + def parse_block_mapping_key(self): ... + def parse_block_mapping_value(self): ... + def parse_flow_sequence_first_entry(self): ... + def parse_flow_sequence_entry(self, first=False): ... + def parse_flow_sequence_entry_mapping_key(self): ... + def parse_flow_sequence_entry_mapping_value(self): ... + def parse_flow_sequence_entry_mapping_end(self): ... + def parse_flow_mapping_first_key(self): ... + def parse_flow_mapping_key(self, first=False): ... + def parse_flow_mapping_value(self): ... + def parse_flow_mapping_empty_value(self): ... + def process_empty_scalar(self, mark): ... diff --git a/.venv/lib/python3.12/site-packages/yaml-stubs/py.typed b/.venv/lib/python3.12/site-packages/yaml-stubs/py.typed new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/.venv/lib/python3.12/site-packages/yaml-stubs/py.typed diff --git a/.venv/lib/python3.12/site-packages/yaml-stubs/reader.pyi b/.venv/lib/python3.12/site-packages/yaml-stubs/reader.pyi new file mode 100644 index 00000000..cace808a --- /dev/null +++ b/.venv/lib/python3.12/site-packages/yaml-stubs/reader.pyi @@ -0,0 +1,39 @@ +from _typeshed import SupportsRead +from typing import Any +from typing_extensions import TypeAlias + +from yaml.error import YAMLError + +_ReadStream: TypeAlias = str | bytes | SupportsRead[str] | SupportsRead[bytes] + +class ReaderError(YAMLError): + name: Any + character: Any + position: Any + encoding: Any + reason: Any + def __init__(self, name, position, character, encoding, reason) -> None: ... + +class Reader: + name: Any + stream: SupportsRead[str] | SupportsRead[bytes] | None + stream_pointer: Any + eof: Any + buffer: Any + pointer: Any + raw_buffer: Any + raw_decode: Any + encoding: Any + index: Any + line: Any + column: Any + def __init__(self, stream: _ReadStream) -> None: ... + def peek(self, index=0): ... + def prefix(self, length=1): ... + def forward(self, length=1): ... + def get_mark(self): ... + def determine_encoding(self): ... + NON_PRINTABLE: Any + def check_printable(self, data): ... + def update(self, length): ... + def update_raw(self, size=4096): ... diff --git a/.venv/lib/python3.12/site-packages/yaml-stubs/representer.pyi b/.venv/lib/python3.12/site-packages/yaml-stubs/representer.pyi new file mode 100644 index 00000000..c84c5621 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/yaml-stubs/representer.pyi @@ -0,0 +1,61 @@ +import datetime +from _typeshed import Incomplete, ReadableBuffer, SupportsItems +from collections.abc import Callable, Iterable, Mapping +from types import BuiltinFunctionType, FunctionType, ModuleType +from typing import Any, ClassVar, NoReturn, TypeVar + +from yaml.error import YAMLError as YAMLError +from yaml.nodes import MappingNode as MappingNode, Node as Node, ScalarNode as ScalarNode, SequenceNode as SequenceNode + +_T = TypeVar("_T") +_R = TypeVar("_R", bound=BaseRepresenter) + +class RepresenterError(YAMLError): ... + +class BaseRepresenter: + yaml_representers: ClassVar[dict[type[Any], Callable[[BaseRepresenter, Any], Node]]] + yaml_multi_representers: ClassVar[dict[type[Any], Callable[[BaseRepresenter, Any], Node]]] + default_style: str | Incomplete + sort_keys: bool + default_flow_style: bool + represented_objects: dict[int, Node] + object_keeper: list[Any] + alias_key: int | Incomplete + def __init__(self, default_style: str | None = None, default_flow_style: bool = False, sort_keys: bool = True) -> None: ... + def represent(self, data) -> None: ... + def represent_data(self, data) -> Node: ... + @classmethod + def add_representer(cls: type[_R], data_type: type[_T], representer: Callable[[_R, _T], Node]) -> None: ... + @classmethod + def add_multi_representer(cls: type[_R], data_type: type[_T], representer: Callable[[_R, _T], Node]) -> None: ... + def represent_scalar(self, tag: str, value, style: str | None = None) -> ScalarNode: ... + def represent_sequence(self, tag: str, sequence: Iterable[Any], flow_style: bool | None = None) -> SequenceNode: ... + def represent_mapping( + self, tag: str, mapping: SupportsItems[Any, Any] | Iterable[tuple[Any, Any]], flow_style: bool | None = None + ) -> MappingNode: ... + def ignore_aliases(self, data) -> bool: ... + +class SafeRepresenter(BaseRepresenter): + inf_value: ClassVar[float] + def ignore_aliases(self, data) -> bool: ... + def represent_none(self, data) -> ScalarNode: ... + def represent_str(self, data: str) -> ScalarNode: ... + def represent_binary(self, data: ReadableBuffer) -> ScalarNode: ... + def represent_bool(self, data: bool) -> ScalarNode: ... + def represent_int(self, data: int) -> ScalarNode: ... + def represent_float(self, data: float) -> ScalarNode: ... + def represent_list(self, data: Iterable[Any]) -> SequenceNode: ... + def represent_dict(self, data: SupportsItems[Any, Any] | Iterable[tuple[Any, Any]]) -> MappingNode: ... + def represent_set(self, data: Iterable[Any]) -> MappingNode: ... + def represent_date(self, data: datetime.date) -> ScalarNode: ... + def represent_datetime(self, data: datetime.datetime) -> ScalarNode: ... + def represent_yaml_object(self, tag: str, data, cls, flow_style: bool | None = None) -> MappingNode: ... + def represent_undefined(self, data) -> NoReturn: ... + +class Representer(SafeRepresenter): + def represent_complex(self, data: complex) -> ScalarNode: ... + def represent_tuple(self, data: Iterable[Any]) -> SequenceNode: ... + def represent_name(self, data: BuiltinFunctionType | FunctionType) -> ScalarNode: ... + def represent_module(self, data: ModuleType) -> ScalarNode: ... + def represent_object(self, data) -> SequenceNode | MappingNode: ... + def represent_ordered_dict(self, data: Mapping[Any, Any]) -> SequenceNode: ... diff --git a/.venv/lib/python3.12/site-packages/yaml-stubs/resolver.pyi b/.venv/lib/python3.12/site-packages/yaml-stubs/resolver.pyi new file mode 100644 index 00000000..cffe02a4 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/yaml-stubs/resolver.pyi @@ -0,0 +1,25 @@ +from typing import Any + +from yaml.error import YAMLError + +class ResolverError(YAMLError): ... + +class BaseResolver: + DEFAULT_SCALAR_TAG: Any + DEFAULT_SEQUENCE_TAG: Any + DEFAULT_MAPPING_TAG: Any + yaml_implicit_resolvers: Any + yaml_path_resolvers: Any + resolver_exact_paths: Any + resolver_prefix_paths: Any + def __init__(self) -> None: ... + @classmethod + def add_implicit_resolver(cls, tag, regexp, first): ... + @classmethod + def add_path_resolver(cls, tag, path, kind=None): ... + def descend_resolver(self, current_node, current_index): ... + def ascend_resolver(self): ... + def check_resolver_prefix(self, depth, path, kind, current_node, current_index): ... + def resolve(self, kind, value, implicit): ... + +class Resolver(BaseResolver): ... diff --git a/.venv/lib/python3.12/site-packages/yaml-stubs/scanner.pyi b/.venv/lib/python3.12/site-packages/yaml-stubs/scanner.pyi new file mode 100644 index 00000000..64890a19 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/yaml-stubs/scanner.pyi @@ -0,0 +1,97 @@ +from typing import Any + +from yaml.error import MarkedYAMLError + +class ScannerError(MarkedYAMLError): ... + +class SimpleKey: + token_number: Any + required: Any + index: Any + line: Any + column: Any + mark: Any + def __init__(self, token_number, required, index, line, column, mark) -> None: ... + +class Scanner: + done: Any + flow_level: Any + tokens: Any + tokens_taken: Any + indent: Any + indents: Any + allow_simple_key: Any + possible_simple_keys: Any + def __init__(self) -> None: ... + def check_token(self, *choices): ... + def peek_token(self): ... + def get_token(self): ... + def need_more_tokens(self): ... + def fetch_more_tokens(self): ... + def next_possible_simple_key(self): ... + def stale_possible_simple_keys(self): ... + def save_possible_simple_key(self): ... + def remove_possible_simple_key(self): ... + def unwind_indent(self, column): ... + def add_indent(self, column): ... + def fetch_stream_start(self): ... + def fetch_stream_end(self): ... + def fetch_directive(self): ... + def fetch_document_start(self): ... + def fetch_document_end(self): ... + def fetch_document_indicator(self, TokenClass): ... + def fetch_flow_sequence_start(self): ... + def fetch_flow_mapping_start(self): ... + def fetch_flow_collection_start(self, TokenClass): ... + def fetch_flow_sequence_end(self): ... + def fetch_flow_mapping_end(self): ... + def fetch_flow_collection_end(self, TokenClass): ... + def fetch_flow_entry(self): ... + def fetch_block_entry(self): ... + def fetch_key(self): ... + def fetch_value(self): ... + def fetch_alias(self): ... + def fetch_anchor(self): ... + def fetch_tag(self): ... + def fetch_literal(self): ... + def fetch_folded(self): ... + def fetch_block_scalar(self, style): ... + def fetch_single(self): ... + def fetch_double(self): ... + def fetch_flow_scalar(self, style): ... + def fetch_plain(self): ... + def check_directive(self): ... + def check_document_start(self): ... + def check_document_end(self): ... + def check_block_entry(self): ... + def check_key(self): ... + def check_value(self): ... + def check_plain(self): ... + def scan_to_next_token(self): ... + def scan_directive(self): ... + def scan_directive_name(self, start_mark): ... + def scan_yaml_directive_value(self, start_mark): ... + def scan_yaml_directive_number(self, start_mark): ... + def scan_tag_directive_value(self, start_mark): ... + def scan_tag_directive_handle(self, start_mark): ... + def scan_tag_directive_prefix(self, start_mark): ... + def scan_directive_ignored_line(self, start_mark): ... + def scan_anchor(self, TokenClass): ... + def scan_tag(self): ... + def scan_block_scalar(self, style): ... + def scan_block_scalar_indicators(self, start_mark): ... + def scan_block_scalar_ignored_line(self, start_mark): ... + def scan_block_scalar_indentation(self): ... + def scan_block_scalar_breaks(self, indent): ... + def scan_flow_scalar(self, style): ... + ESCAPE_REPLACEMENTS: Any + ESCAPE_CODES: Any + def scan_flow_scalar_non_spaces(self, double, start_mark): ... + def scan_flow_scalar_spaces(self, double, start_mark): ... + def scan_flow_scalar_breaks(self, double, start_mark): ... + def scan_plain(self): ... + def scan_plain_spaces(self, indent, start_mark): ... + def scan_tag_handle(self, name, start_mark): ... + def scan_tag_uri(self, name, start_mark): ... + def scan_uri_escapes(self, name, start_mark): ... + def scan_line_break(self): ... diff --git a/.venv/lib/python3.12/site-packages/yaml-stubs/serializer.pyi b/.venv/lib/python3.12/site-packages/yaml-stubs/serializer.pyi new file mode 100644 index 00000000..47142902 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/yaml-stubs/serializer.pyi @@ -0,0 +1,25 @@ +from typing import Any + +from yaml.error import YAMLError +from yaml.nodes import Node + +class SerializerError(YAMLError): ... + +class Serializer: + ANCHOR_TEMPLATE: Any + use_encoding: Any + use_explicit_start: Any + use_explicit_end: Any + use_version: Any + use_tags: Any + serialized_nodes: Any + anchors: Any + last_anchor_id: Any + closed: Any + def __init__(self, encoding=None, explicit_start=None, explicit_end=None, version=None, tags=None) -> None: ... + def open(self) -> None: ... + def close(self) -> None: ... + def serialize(self, node: Node) -> None: ... + def anchor_node(self, node): ... + def generate_anchor(self, node): ... + def serialize_node(self, node, parent, index): ... diff --git a/.venv/lib/python3.12/site-packages/yaml-stubs/tokens.pyi b/.venv/lib/python3.12/site-packages/yaml-stubs/tokens.pyi new file mode 100644 index 00000000..632a1644 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/yaml-stubs/tokens.pyi @@ -0,0 +1,93 @@ +from typing import Any + +class Token: + start_mark: Any + end_mark: Any + def __init__(self, start_mark, end_mark) -> None: ... + +class DirectiveToken(Token): + id: Any + name: Any + value: Any + start_mark: Any + end_mark: Any + def __init__(self, name, value, start_mark, end_mark) -> None: ... + +class DocumentStartToken(Token): + id: Any + +class DocumentEndToken(Token): + id: Any + +class StreamStartToken(Token): + id: Any + start_mark: Any + end_mark: Any + encoding: Any + def __init__(self, start_mark=None, end_mark=None, encoding=None) -> None: ... + +class StreamEndToken(Token): + id: Any + +class BlockSequenceStartToken(Token): + id: Any + +class BlockMappingStartToken(Token): + id: Any + +class BlockEndToken(Token): + id: Any + +class FlowSequenceStartToken(Token): + id: Any + +class FlowMappingStartToken(Token): + id: Any + +class FlowSequenceEndToken(Token): + id: Any + +class FlowMappingEndToken(Token): + id: Any + +class KeyToken(Token): + id: Any + +class ValueToken(Token): + id: Any + +class BlockEntryToken(Token): + id: Any + +class FlowEntryToken(Token): + id: Any + +class AliasToken(Token): + id: Any + value: Any + start_mark: Any + end_mark: Any + def __init__(self, value, start_mark, end_mark) -> None: ... + +class AnchorToken(Token): + id: Any + value: Any + start_mark: Any + end_mark: Any + def __init__(self, value, start_mark, end_mark) -> None: ... + +class TagToken(Token): + id: Any + value: Any + start_mark: Any + end_mark: Any + def __init__(self, value, start_mark, end_mark) -> None: ... + +class ScalarToken(Token): + id: Any + value: Any + plain: Any + start_mark: Any + end_mark: Any + style: Any + def __init__(self, value, plain, start_mark, end_mark, style=None) -> None: ... |