.config/coc/extensions/node_modules/coc-pyright/node_modules/pyright/dist/typeshed-fallback/stubs/PyYAML/yaml/__init__.pyi

   1 from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence
   2 from typing import IO, Any, Pattern, Type, TypeVar, overload
   3
   4 from . import resolver as resolver  # Help mypy a bit; this is implied by loader and dumper
   5 from .constructor import BaseConstructor
   6 from .cyaml import *
   7 from .dumper import *
   8 from .error import *
   9 from .events import *
  10 from .loader import *
  11 from .nodes import *
  12 from .representer import BaseRepresenter
  13 from .resolver import BaseResolver
  14 from .tokens import *
  15
  16 # FIXME: the functions really return str if encoding is None, otherwise bytes. Waiting for python/mypy#5621
  17 _Yaml = Any
  18
  19 __with_libyaml__: Any
  20 __version__: str
  21
  22 _T = TypeVar("_T")
  23 _Constructor = TypeVar("_Constructor", bound=BaseConstructor)
  24 _Representer = TypeVar("_Representer", bound=BaseRepresenter)
  25
  26 def warnings(settings=...): ...
  27 def scan(stream, Loader=...): ...
  28 def parse(stream, Loader=...): ...
  29 def compose(stream, Loader=...): ...
  30 def compose_all(stream, Loader=...): ...
  31 def load(stream: bytes | IO[bytes] | str | IO[str], Loader) -> Any: ...
  32 def load_all(stream: bytes | IO[bytes] | str | IO[str], Loader) -> Iterator[Any]: ...
  33 def full_load(stream: bytes | IO[bytes] | str | IO[str]) -> Any: ...
  34 def full_load_all(stream: bytes | IO[bytes] | str | IO[str]) -> Iterator[Any]: ...
  35 def safe_load(stream: bytes | IO[bytes] | str | IO[str]) -> Any: ...
  36 def safe_load_all(stream: bytes | IO[bytes] | str | IO[str]) -> Iterator[Any]: ...
  37 def unsafe_load(stream: bytes | IO[bytes] | str | IO[str]) -> Any: ...
  38 def unsafe_load_all(stream: bytes | IO[bytes] | str | IO[str]) -> Iterator[Any]: ...
  39 def emit(
  40     events,
  41     stream=...,
  42     Dumper=...,
  43     canonical: bool | None = ...,
  44     indent: int | None = ...,
  45     width: int | None = ...,
  46     allow_unicode: bool | None = ...,
  47     line_break: str | None = ...,
  48 ): ...
  49 @overload
  50 def serialize_all(
  51     nodes,
  52     stream: IO[str],
  53     Dumper=...,
  54     canonical: bool | None = ...,
  55     indent: int | None = ...,
  56     width: int | None = ...,
  57     allow_unicode: bool | None = ...,
  58     line_break: str | None = ...,
  59     encoding: str | None = ...,
  60     explicit_start: bool | None = ...,
  61     explicit_end: bool | None = ...,
  62     version: tuple[int, int] | None = ...,
  63     tags: Mapping[str, str] | None = ...,
  64 ) -> None: ...
  65 @overload
  66 def serialize_all(
  67     nodes,
  68     stream: None = ...,
  69     Dumper=...,
  70     canonical: bool | None = ...,
  71     indent: int | None = ...,
  72     width: int | None = ...,
  73     allow_unicode: bool | None = ...,
  74     line_break: str | None = ...,
  75     encoding: str | None = ...,
  76     explicit_start: bool | None = ...,
  77     explicit_end: bool | None = ...,
  78     version: tuple[int, int] | None = ...,
  79     tags: Mapping[str, str] | None = ...,
  80 ) -> _Yaml: ...
  81 @overload
  82 def serialize(
  83     node,
  84     stream: IO[str],
  85     Dumper=...,
  86     *,
  87     canonical: bool | None = ...,
  88     indent: int | None = ...,
  89     width: int | None = ...,
  90     allow_unicode: bool | None = ...,
  91     line_break: str | None = ...,
  92     encoding: str | None = ...,
  93     explicit_start: bool | None = ...,
  94     explicit_end: bool | None = ...,
  95     version: tuple[int, int] | None = ...,
  96     tags: Mapping[str, str] | None = ...,
  97 ) -> None: ...
  98 @overload
  99 def serialize(
 100     node,
 101     stream: None = ...,
 102     Dumper=...,
 103     *,
 104     canonical: bool | None = ...,
 105     indent: int | None = ...,
 106     width: int | None = ...,
 107     allow_unicode: bool | None = ...,
 108     line_break: str | None = ...,
 109     encoding: str | None = ...,
 110     explicit_start: bool | None = ...,
 111     explicit_end: bool | None = ...,
 112     version: tuple[int, int] | None = ...,
 113     tags: Mapping[str, str] | None = ...,
 114 ) -> _Yaml: ...
 115 @overload
 116 def dump_all(
 117     documents: Sequence[Any],
 118     stream: IO[str],
 119     Dumper=...,
 120     default_style: str | None = ...,
 121     default_flow_style: bool | None = ...,
 122     canonical: bool | None = ...,
 123     indent: int | None = ...,
 124     width: int | None = ...,
 125     allow_unicode: bool | None = ...,
 126     line_break: str | None = ...,
 127     encoding: str | None = ...,
 128     explicit_start: bool | None = ...,
 129     explicit_end: bool | None = ...,
 130     version: tuple[int, int] | None = ...,
 131     tags: Mapping[str, str] | None = ...,
 132     sort_keys: bool = ...,
 133 ) -> None: ...
 134 @overload
 135 def dump_all(
 136     documents: Sequence[Any],
 137     stream: None = ...,
 138     Dumper=...,
 139     default_style: str | None = ...,
 140     default_flow_style: bool | None = ...,
 141     canonical: bool | None = ...,
 142     indent: int | None = ...,
 143     width: int | None = ...,
 144     allow_unicode: bool | None = ...,
 145     line_break: str | None = ...,
 146     encoding: str | None = ...,
 147     explicit_start: bool | None = ...,
 148     explicit_end: bool | None = ...,
 149     version: tuple[int, int] | None = ...,
 150     tags: Mapping[str, str] | None = ...,
 151     sort_keys: bool = ...,
 152 ) -> _Yaml: ...
 153 @overload
 154 def dump(
 155     data: Any,
 156     stream: IO[str],
 157     Dumper=...,
 158     *,
 159     default_style: str | None = ...,
 160     default_flow_style: bool | None = ...,
 161     canonical: bool | None = ...,
 162     indent: int | None = ...,
 163     width: int | None = ...,
 164     allow_unicode: bool | None = ...,
 165     line_break: str | None = ...,
 166     encoding: str | None = ...,
 167     explicit_start: bool | None = ...,
 168     explicit_end: bool | None = ...,
 169     version: tuple[int, int] | None = ...,
 170     tags: Mapping[str, str] | None = ...,
 171     sort_keys: bool = ...,
 172 ) -> None: ...
 173 @overload
 174 def dump(
 175     data: Any,
 176     stream: None = ...,
 177     Dumper=...,
 178     *,
 179     default_style: str | None = ...,
 180     default_flow_style: bool | None = ...,
 181     canonical: bool | None = ...,
 182     indent: int | None = ...,
 183     width: int | None = ...,
 184     allow_unicode: bool | None = ...,
 185     line_break: str | None = ...,
 186     encoding: str | None = ...,
 187     explicit_start: bool | None = ...,
 188     explicit_end: bool | None = ...,
 189     version: tuple[int, int] | None = ...,
 190     tags: Mapping[str, str] | None = ...,
 191     sort_keys: bool = ...,
 192 ) -> _Yaml: ...
 193 @overload
 194 def safe_dump_all(
 195     documents: Sequence[Any],
 196     stream: IO[str],
 197     *,
 198     default_style: str | None = ...,
 199     default_flow_style: bool | None = ...,
 200     canonical: bool | None = ...,
 201     indent: int | None = ...,
 202     width: int | None = ...,
 203     allow_unicode: bool | None = ...,
 204     line_break: str | None = ...,
 205     encoding: str | None = ...,
 206     explicit_start: bool | None = ...,
 207     explicit_end: bool | None = ...,
 208     version: tuple[int, int] | None = ...,
 209     tags: Mapping[str, str] | None = ...,
 210     sort_keys: bool = ...,
 211 ) -> None: ...
 212 @overload
 213 def safe_dump_all(
 214     documents: Sequence[Any],
 215     stream: None = ...,
 216     *,
 217     default_style: str | None = ...,
 218     default_flow_style: bool | None = ...,
 219     canonical: bool | None = ...,
 220     indent: int | None = ...,
 221     width: int | None = ...,
 222     allow_unicode: bool | None = ...,
 223     line_break: str | None = ...,
 224     encoding: str | None = ...,
 225     explicit_start: bool | None = ...,
 226     explicit_end: bool | None = ...,
 227     version: tuple[int, int] | None = ...,
 228     tags: Mapping[str, str] | None = ...,
 229     sort_keys: bool = ...,
 230 ) -> _Yaml: ...
 231 @overload
 232 def safe_dump(
 233     data: Any,
 234     stream: IO[str],
 235     *,
 236     default_style: str | None = ...,
 237     default_flow_style: bool | None = ...,
 238     canonical: bool | None = ...,
 239     indent: int | None = ...,
 240     width: int | None = ...,
 241     allow_unicode: bool | None = ...,
 242     line_break: str | None = ...,
 243     encoding: str | None = ...,
 244     explicit_start: bool | None = ...,
 245     explicit_end: bool | None = ...,
 246     version: tuple[int, int] | None = ...,
 247     tags: Mapping[str, str] | None = ...,
 248     sort_keys: bool = ...,
 249 ) -> None: ...
 250 @overload
 251 def safe_dump(
 252     data: Any,
 253     stream: None = ...,
 254     *,
 255     default_style: str | None = ...,
 256     default_flow_style: bool | None = ...,
 257     canonical: bool | None = ...,
 258     indent: int | None = ...,
 259     width: int | None = ...,
 260     allow_unicode: bool | None = ...,
 261     line_break: str | None = ...,
 262     encoding: str | None = ...,
 263     explicit_start: bool | None = ...,
 264     explicit_end: bool | None = ...,
 265     version: tuple[int, int] | None = ...,
 266     tags: Mapping[str, str] | None = ...,
 267     sort_keys: bool = ...,
 268 ) -> _Yaml: ...
 269 def add_implicit_resolver(
 270     tag: str,
 271     regexp: Pattern[str],
 272     first: Iterable[Any] | None = ...,
 273     Loader: Type[BaseResolver] | None = ...,
 274     Dumper: Type[BaseResolver] = ...,
 275 ) -> None: ...
 276 def add_path_resolver(
 277     tag: str,
 278     path: Iterable[Any],
 279     kind: Type[Any] | None = ...,
 280     Loader: Type[BaseResolver] | None = ...,
 281     Dumper: Type[BaseResolver] = ...,
 282 ) -> None: ...
 283 @overload
 284 def add_constructor(
 285     tag: str, constructor: Callable[[Loader | FullLoader | UnsafeLoader, Node], Any], Loader: None = ...
 286 ) -> None: ...
 287 @overload
 288 def add_constructor(tag: str, constructor: Callable[[_Constructor, Node], Any], Loader: Type[_Constructor]) -> None: ...
 289 @overload
 290 def add_multi_constructor(
 291     tag_prefix: str, multi_constructor: Callable[[Loader | FullLoader | UnsafeLoader, str, Node], Any], Loader: None = ...
 292 ) -> None: ...
 293 @overload
 294 def add_multi_constructor(
 295     tag_prefix: str, multi_constructor: Callable[[_Constructor, str, Node], Any], Loader: Type[_Constructor]
 296 ) -> None: ...
 297 @overload
 298 def add_representer(data_type: Type[_T], representer: Callable[[Dumper, _T], Node]) -> None: ...
 299 @overload
 300 def add_representer(data_type: Type[_T], representer: Callable[[_Representer, _T], Node], Dumper: Type[_Representer]) -> None: ...
 301 @overload
 302 def add_multi_representer(data_type: Type[_T], multi_representer: Callable[[Dumper, _T], Node]) -> None: ...
 303 @overload
 304 def add_multi_representer(
 305     data_type: Type[_T], multi_representer: Callable[[_Representer, _T], Node], Dumper: Type[_Representer]
 306 ) -> None: ...
 307
 308 class YAMLObjectMetaclass(type):
 309     def __init__(cls, name, bases, kwds) -> None: ...
 310
 311 class YAMLObject(metaclass=YAMLObjectMetaclass):
 312     yaml_loader: Any
 313     yaml_dumper: Any
 314     yaml_tag: Any
 315     yaml_flow_style: Any
 316     @classmethod
 317     def from_yaml(cls, loader, node): ...
 318     @classmethod
 319     def to_yaml(cls, dumper, data): ...